Publish

- @transia/ripple-binary-codec@1.4.6-alpha.9
 - @transia/xrpl@2.7.3-alpha.26

packages/ripple-binary-codec/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@transia/ripple-binary-codec",
-  "version": "1.4.6-alpha.7",
+  "version": "1.4.6-alpha.9",
   "description": "XRP Ledger binary codec",
   "files": [
     "dist/*",

packages/ripple-binary-codec/src/enums/definitions.json

@@ -1998,6 +1998,16 @@
         "type": "AccountID"
       }
     ],
+    [
+      "Inform",
+      {
+        "nth": 99,
+        "isVLEncoded": true,
+        "isSerialized": true,
+        "isSigningField": true,
+        "type": "AccountID"
+      }
+    ],
     [
       "Indexes",
       {
@@ -2048,6 +2058,16 @@
         "type": "Vector256"
       }
     ],
+    [
+      "URITokenIDs",
+      {
+        "nth": 99,
+        "isVLEncoded": true,
+        "isSerialized": true,
+        "isSigningField": true,
+        "type": "Vector256"
+      }
+    ],
     [
       "Paths",
       {
@@ -2308,6 +2328,26 @@
         "type": "STObject"
       }
     ],
+    [
+      "MintURIToken",
+      {
+        "nth": 92,
+        "isVLEncoded": false,
+        "isSerialized": true,
+        "isSigningField": true,
+        "type": "STObject"
+      }
+    ],
+    [
+      "AmountEntry",
+      {
+        "nth": 91,
+        "isVLEncoded": false,
+        "isSerialized": true,
+        "isSigningField": true,
+        "type": "STObject"
+      }
+    ],
     [
       "Signers",
       {
@@ -2487,6 +2527,16 @@
         "isSigningField": true,
         "type": "STArray"
       }
+    ],
+    [
+      "Amounts",
+      {
+        "nth": 92,
+        "isVLEncoded": false,
+        "isSerialized": true,
+        "isSigningField": true,
+        "type": "STArray"
+      }
     ]
   ],
   "TRANSACTION_RESULTS": {
@@ -2710,6 +2760,7 @@
     "URITokenBuy": 47,
     "URITokenCreateSellOffer": 48,
     "URITokenCancelSellOffer": 49,
+    "Remit": 95,
     "GenesisMint": 96,
     "Import": 97,
     "ClaimReward": 98,

packages/ripple-binary-codec/test/binary-serializer.test.js

@@ -111,6 +111,11 @@ const UNLReport = {
   meta: require('./fixtures/unl-report-meta-binary.json'),
 }
 
+const Remit = {
+  tx: require('./fixtures/remit-tx.json'),
+  binary: require('./fixtures/remit-binary.json'),
+}
+
 function bytesListTest() {
   const list = new BytesList()
     .put(Buffer.from([0]))
@@ -291,6 +296,12 @@ function nfTokenTest() {
   }
 }
 
+function RemitTest() {
+  test('can serialize Remit', () => {
+    expect(encode(Remit.tx)).toEqual(Remit.binary)
+  })
+}
+
 describe('Binary Serialization', function () {
   describe('nestedObjectTests', nestedObjectTests)
   describe('BytesList', bytesListTest)
@@ -304,4 +315,5 @@ describe('Binary Serialization', function () {
   describe('TicketTest', ticketTest)
   describe('NFToken', nfTokenTest)
   describe('UNLReport', UNLReportTest)
+  describe('Remit', RemitTest)
 })

packages/ripple-binary-codec/test/fixtures/remit-binary.json

@@ -0,0 +1 @@
+"12005F22000000002403EDEB4A2E00000001201B03EE5D3150116F1DFD1D0FE8A32E40E1F2C05CF1C15545BAB56B617F9C6C2D63A6B704BEF59B68400000000000000C732102F9E33F16DF9507705EC954E3F94EB5F10D1FC4A354606DBE6297DBB1096FE65474473045022100E3FAE0EDEC3D6A8FF6D81BC9CF8288A61B7EEDE8071E90FF9314CB4621058D10022043545CF631706D700CEE65A1DB83EFDD185413808292D9D90F14D87D3DC2D8CB701A04DEADBEEF81147990EC5D1D8DF69E070A968D4B186986FDF06ED0831449FF0C73CA6AF9733DA805F76CA2C37776B7C46B806314757C4A9ED08284D61F3D8807280795F858BAB61DE05C220000000150156F1DFD1D0FE8A32E40E1F2C05CF1C15545BAB56B617F9C6C2D63A6B704BEF59B7504DEADBEEFE1F05CE05B6140000000000003E8E1E05B61D4838D7EA4C68000000000000000000000000000555344000000000006B80F0F1D98AEDA846ED981F741C398FB2C4FD1E1F100136320AED08CC1F50DD5F23A1948AF86153A3F3B7593E5EC77D65A02BB1B29E05AB6AE"

packages/ripple-binary-codec/test/fixtures/remit-tx.json

@@ -0,0 +1,39 @@
+{
+  "TransactionType": "Remit",
+  "Account": "rUn84CUYbNjRoTQ6mSW7BVJPSVJNLb1QLo",
+  "Destination": "rfkE1aSy9G8Upk4JssnwBxhEv5p4mn2KTy",
+  "DestinationTag": 1,
+  "Fee": "12",
+  "Flags": 0,
+  "LastLedgerSequence": 65953073,
+  "Sequence": 65923914,
+  "SigningPubKey": "02F9E33F16DF9507705EC954E3F94EB5F10D1FC4A354606DBE6297DBB1096FE654",
+  "TxnSignature": "3045022100E3FAE0EDEC3D6A8FF6D81BC9CF8288A61B7EEDE8071E90FF9314CB4621058D10022043545CF631706D700CEE65A1DB83EFDD185413808292D9D90F14D87D3DC2D8CB",
+  "Amounts": [
+    {
+      "AmountEntry": {
+        "Amount": "1000"
+      }
+    },
+    {
+      "AmountEntry": {
+        "Amount": {
+          "currency": "USD",
+          "issuer": "rcXY84C4g14iFp6taFXjjQGVeHqSCh9RX",
+          "value": "1"
+        }
+      }
+    }
+  ],
+  "MintURIToken": {
+    "URI": "DEADBEEF",
+    "Digest": "6F1DFD1D0FE8A32E40E1F2C05CF1C15545BAB56B617F9C6C2D63A6B704BEF59B",
+    "Flags": 1
+  },
+  "URITokenIDs": [
+    "AED08CC1F50DD5F23A1948AF86153A3F3B7593E5EC77D65A02BB1B29E05AB6AE"
+  ],
+  "InvoiceID": "6F1DFD1D0FE8A32E40E1F2C05CF1C15545BAB56B617F9C6C2D63A6B704BEF59B",
+  "Blob": "DEADBEEF",
+  "Inform": "rB5Ux4Lv2nRx6eeoAAsZmtctnBQ2LiACnk"
+}

packages/xrpl/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@transia/xrpl",
-  "version": "2.7.3-alpha.23",
+  "version": "2.7.3-alpha.26",
   "license": "ISC",
   "description": "A TypeScript/JavaScript API for interacting with the XRP Ledger in Node.js and the browser",
   "files": [
@@ -23,7 +23,7 @@
   },
   "dependencies": {
     "@transia/ripple-address-codec": "^4.2.8-alpha.0",
-    "@transia/ripple-binary-codec": "^1.4.6-alpha.7",
+    "@transia/ripple-binary-codec": "^1.4.6-alpha.9",
     "@transia/ripple-keypairs": "^1.1.8-alpha.0",
     "bignumber.js": "^9.0.0",
     "bip32": "^2.0.6",

packages/xrpl/src/models/common/index.ts

@@ -17,6 +17,8 @@ export interface IssuedCurrencyAmount extends IssuedCurrency {
 
 export type Amount = IssuedCurrencyAmount | string
 
+export type AmountEntry = Amount
+
 export interface Signer {
   Signer: {
     Account: string
@@ -205,3 +207,21 @@ export interface EmitDetails {
   EmitHookHash: string
   EmitParentTxnID: string
 }
+
+/**
+ * The object that describes the uritoken in MintURIToken.
+ */
+export interface MintURIToken {
+  /**
+   *
+   */
+  URI: string
+  /**
+   *
+   */
+  Digest?: string
+  /**
+   * The flags that are set on the uritoken.
+   */
+  Flags?: number
+}

packages/xrpl/src/models/methods/accountNamespace.ts

@@ -0,0 +1,46 @@
+import { HookState } from '../ledger'
+
+import { BaseRequest, BaseResponse } from './baseMethod'
+
+/**
+ * The `account_namespace` command retrieves the account namespace. All information retrieved is relative to a
+ * particular version of the ledger. Returns an {@link AccountNamespaceResponse}.
+ *
+ * @category Requests
+ */
+export interface AccountNamespaceRequest extends BaseRequest {
+  command: 'account_namespace'
+  /** A unique identifier for the account, most commonly the account's address. */
+  account: string
+  /** The hex namespace. */
+  namespace_id?: string
+}
+
+/**
+ * Response expected from an {@link AccountNamespaceRequest}.
+ *
+ * @category Responses
+ */
+export interface AccountNamespaceResponse extends BaseResponse {
+  result: {
+    /**
+     * The account requested.
+     */
+    account: string
+    /**
+     * The namespace_id requested.
+     */
+    namespace_id: string
+    /**
+     * A list of HookStates for the specified account namespace_id.
+     */
+    namespace_entries: HookState[]
+    /**
+     * The ledger index of the current open ledger, which was used when
+     * retrieving this information.
+     */
+    ledger_current_index: number
+    /** If true, this data comes from a validated ledger. */
+    validated: boolean
+  }
+}

packages/xrpl/src/models/methods/index.ts

@@ -8,6 +8,10 @@ import {
 } from './accountCurrencies'
 import { AccountInfoRequest, AccountInfoResponse } from './accountInfo'
 import { AccountLinesRequest, AccountLinesResponse } from './accountLines'
+import {
+  AccountNamespaceRequest,
+  AccountNamespaceResponse,
+} from './accountNamespace'
 import { AccountNFTsRequest, AccountNFTsResponse } from './accountNFTs'
 import { AccountObjectsRequest, AccountObjectsResponse } from './accountObjects'
 import {
@@ -83,6 +87,7 @@ type Request =
   | AccountCurrenciesRequest
   | AccountInfoRequest
   | AccountLinesRequest
+  | AccountNamespaceRequest
   | AccountNFTsRequest
   | AccountObjectsRequest
   | AccountOffersRequest
@@ -133,6 +138,7 @@ type Response =
   | AccountCurrenciesResponse
   | AccountInfoResponse
   | AccountLinesResponse
+  | AccountNamespaceResponse
   | AccountNFTsResponse
   | AccountObjectsResponse
   | AccountOffersResponse

packages/xrpl/src/models/transactions/escrowCancel.ts

@@ -15,7 +15,12 @@ export interface EscrowCancel extends BaseTransaction {
    * Transaction sequence (or Ticket  number) of EscrowCreate transaction that.
    * created the escrow to cancel.
    */
-  OfferSequence: number
+  OfferSequence?: number
+  /**
+   * The ID of the Escrow ledger object to cancel as a 64-character hexadecimal
+   * string.
+   */
+  EscrowID?: string
 }
 
 /**
@@ -35,11 +40,17 @@ export function validateEscrowCancel(tx: Record<string, unknown>): void {
     throw new ValidationError('EscrowCancel: Owner must be a string')
   }
 
-  if (tx.OfferSequence === undefined) {
+  if (tx.OfferSequence === undefined && tx.EscrowID === undefined) {
-    throw new ValidationError('EscrowCancel: missing OfferSequence')
+    throw new ValidationError(
+      'EscrowCancel: must include OfferSequence or EscrowID',
+    )
   }
 
-  if (typeof tx.OfferSequence !== 'number') {
+  if (tx.OfferSequence !== undefined && typeof tx.OfferSequence !== 'number') {
-    throw new ValidationError('EscrowCancel: OfferSequence must be a number')
+    throw new ValidationError('EscrowCancel: invalid OfferSequence')
+  }
+
+  if (tx.EscrowID !== undefined && typeof tx.EscrowID !== 'string') {
+    throw new ValidationError('EscrowCancel: invalid EscrowID')
   }
 }

packages/xrpl/src/models/transactions/index.ts

@@ -44,8 +44,9 @@ export {
 } from './paymentChannelClaim'
 export { PaymentChannelCreate } from './paymentChannelCreate'
 export { PaymentChannelFund } from './paymentChannelFund'
-export { SetRegularKey } from './setRegularKey'
+export { Remit } from './remit'
 export { SetHookFlagsInterface, SetHookFlags, SetHook } from './setHook'
+export { SetRegularKey } from './setRegularKey'
 export { SignerListSet } from './signerListSet'
 export { TicketCreate } from './ticketCreate'
 export { TrustSetFlagsInterface, TrustSetFlags, TrustSet } from './trustSet'

packages/xrpl/src/models/transactions/metadata.ts

@@ -11,17 +11,16 @@ export interface HookExecution {
     HookReturnCode: string
     HookReturnString: string
     HookStateChangeCount: number
+    Flags: number
   }
 }
 
 export interface HookEmission {
   HookEmission: {
-    EmitGeneration: number
+    EmittedTxnID: string
-    EmitBurden: string
+    HookAccount: string
-    EmitParentTxnID: string
+    HookHash: string
     EmitNonce: string
-    EmitCallback: string
-    EmitHookHash: string
   }
 }
 

packages/xrpl/src/models/transactions/offerCancel.ts

@@ -15,7 +15,12 @@ export interface OfferCancel extends BaseTransaction {
    * created by that transaction. It is not considered an error if the offer.
    * specified does not exist.
    */
-  OfferSequence: number
+  OfferSequence?: number
+  /**
+   * The ID of the Escrow ledger object to cancel as a 64-character hexadecimal
+   * string.
+   */
+  OfferID?: string
 }
 
 /**
@@ -27,11 +32,17 @@ export interface OfferCancel extends BaseTransaction {
 export function validateOfferCancel(tx: Record<string, unknown>): void {
   validateBaseTransaction(tx)
 
-  if (tx.OfferSequence === undefined) {
+  if (tx.OfferSequence === undefined && tx.OfferID === undefined) {
-    throw new ValidationError('OfferCancel: missing field OfferSequence')
+    throw new ValidationError(
+      'OfferCancel: must include OfferSequence or OfferID',
+    )
   }
 
-  if (typeof tx.OfferSequence !== 'number') {
+  if (tx.OfferSequence !== undefined && typeof tx.OfferSequence !== 'number') {
-    throw new ValidationError('OfferCancel: OfferSequence must be a number')
+    throw new ValidationError('OfferCancel: invalid OfferSequence')
+  }
+
+  if (tx.OfferID !== undefined && typeof tx.OfferID !== 'string') {
+    throw new ValidationError('OfferCancel: invalid OfferID')
   }
 }

packages/xrpl/src/models/transactions/offerCreate.ts

@@ -103,6 +103,11 @@ export interface OfferCreate extends BaseTransaction {
   Expiration?: number
   /** An offer to delete first, specified in the same way as OfferCancel. */
   OfferSequence?: number
+  /**
+   * The ID of the Offer ledger object to cancel as a 64-character hexadecimal
+   * string.
+   */
+  OfferID?: string
   /** The amount and type of currency being provided by the offer creator. */
   TakerGets: Amount
   /** The amount and type of currency being requested by the offer creator. */
@@ -141,4 +146,8 @@ export function validateOfferCreate(tx: Record<string, unknown>): void {
   if (tx.OfferSequence !== undefined && typeof tx.OfferSequence !== 'number') {
     throw new ValidationError('OfferCreate: invalid OfferSequence')
   }
+
+  if (tx.OfferID !== undefined && typeof tx.OfferID !== 'string') {
+    throw new ValidationError('OfferCreate: invalid OfferID')
+  }
 }

packages/xrpl/src/models/transactions/remit.ts

@@ -0,0 +1,200 @@
+import { ValidationError } from '../../errors'
+import { AmountEntry, MintURIToken } from '../common'
+import { isHex } from '../utils'
+
+import { BaseTransaction, validateBaseTransaction } from './common'
+
+const MAX_URI_LENGTH = 256
+const DIGEST_LENGTH = 64
+const MAX_ARRAY_LENGTH = 32
+const MAX_BLOB_LENGTH = 1024
+
+/**
+ * A Remit transaction represents a transfer of value from one account to
+ * another.
+ *
+ * @category Transaction Models
+ */
+export interface Remit extends BaseTransaction {
+  TransactionType: 'Remit'
+  /** The unique address of the account receiving the payment. */
+  Destination: string
+  /**
+   * Arbitrary tag that identifies the reason for the payment to the
+   * destination, or a hosted recipient to pay.
+   */
+  DestinationTag?: number
+  /**
+   *
+   */
+  Amounts?: AmountEntry[]
+  /**
+   *
+   */
+  MintURIToken?: MintURIToken
+  /**
+   * Arbitrary 256-bit hash representing a specific reason or identifier for
+   * this payment.
+   */
+  InvoiceID?: string
+  /**
+   * Hex value representing a VL Blob.
+   */
+  Blob?: string
+  /** The unique address of the account to inform */
+  Inform?: string
+}
+
+/**
+ * Verify the form and type of a Remit at runtime.
+ *
+ * @param tx - A Remit Transaction.
+ * @throws When the Remit is malformed.
+ */
+// eslint-disable-next-line complexity -- ignore
+export function validateRemit(tx: Record<string, unknown>): void {
+  validateBaseTransaction(tx)
+
+  if (tx.Amounts !== undefined) {
+    checkAmounts(tx)
+  }
+  if (tx.URITokenIDs !== undefined) {
+    checkURITokenIDs(tx)
+  }
+  if (tx.Destination === tx.Account) {
+    throw new ValidationError(
+      'Remit: Destination must not be equal to the account',
+    )
+  }
+  if (tx.DestinationTag != null && typeof tx.DestinationTag !== 'number') {
+    throw new ValidationError('Remit: DestinationTag must be a number')
+  }
+  if (tx.Inform === tx.Account || tx.inform === tx.Destination) {
+    throw new ValidationError(
+      'Remit: Inform must not be equal to the account or destination',
+    )
+  }
+
+  if (tx.MintURIToken !== undefined) {
+    checkMintURIToken(tx)
+  }
+
+  if (tx.Blob !== undefined && typeof tx.Blob !== 'string') {
+    throw new ValidationError('Remit: Blob must be a string')
+  }
+
+  if (tx.Blob !== undefined && typeof tx.Blob === 'string') {
+    if (!isHex(tx.Blob)) {
+      throw new ValidationError('Remit: Blob must be a hex string')
+    }
+    if (tx.Blob.length > MAX_BLOB_LENGTH) {
+      throw new ValidationError('Remit: max size Blob')
+    }
+  }
+}
+
+function checkAmounts(tx: Record<string, unknown>): void {
+  if (!Array.isArray(tx.Amounts)) {
+    throw new ValidationError('Remit: Amounts must be an array')
+  }
+  if (tx.Amounts.length < 1) {
+    throw new ValidationError('Remit: empty field Amounts')
+  }
+  if (tx.Amounts.length > MAX_ARRAY_LENGTH) {
+    throw new ValidationError('Remit: max field Amounts')
+  }
+  const seen = new Set<string>()
+  let seenXrp = false
+  for (const amount of tx.Amounts) {
+    if (
+      // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access -- ignore
+      amount.AmountEntry === undefined ||
+      // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access -- ignore
+      typeof amount.AmountEntry !== 'object'
+    ) {
+      throw new ValidationError('Remit: invalid Amounts.AmountEntry')
+    }
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access -- ignore
+    if (typeof amount.AmountEntry.Amount === 'string') {
+      // eslint-disable-next-line max-depth -- ignore
+      if (seenXrp) {
+        throw new ValidationError(
+          'Remit: Duplicate Native amounts are not allowed',
+        )
+      }
+      seenXrp = true
+    } else {
+      // eslint-disable-next-line max-len -- ignore
+      // eslint-disable-next-line @typescript-eslint/restrict-template-expressions, @typescript-eslint/no-unsafe-member-access -- ignore
+      const amountKey = `${amount.AmountEntry.Amount.currency}:${amount.AmountEntry.Amount.issuer}`
+      // eslint-disable-next-line max-depth -- ingore
+      if (seen.has(amountKey)) {
+        throw new ValidationError('Remit: Duplicate amounts are not allowed')
+      }
+      seen.add(amountKey)
+    }
+  }
+}
+
+function checkURITokenIDs(tx: Record<string, unknown>): void {
+  if (!Array.isArray(tx.URITokenIDs)) {
+    throw new ValidationError('Remit: invalid field URITokenIDs')
+  }
+  if (tx.URITokenIDs.length < 1) {
+    throw new ValidationError('Remit: empty field URITokenIDs')
+  }
+  if (tx.URITokenIDs.length > MAX_ARRAY_LENGTH) {
+    throw new ValidationError('Remit: max field URITokenIDs')
+  }
+  const seen = new Set<string>()
+  for (const token of tx.URITokenIDs) {
+    if (typeof token !== 'string' || !isHex(token)) {
+      throw new ValidationError('Remit: URITokenID must be a hex string')
+    }
+    if (token.length !== DIGEST_LENGTH) {
+      throw new ValidationError(
+        `Remit: URITokenID must be exactly ${DIGEST_LENGTH} characters`,
+      )
+    }
+    if (seen.has(token)) {
+      throw new ValidationError('Remit: Duplicate URITokens are not allowed')
+    }
+    seen.add(token)
+  }
+}
+
+// eslint-disable-next-line complexity -- ignore
+function checkMintURIToken(tx: Record<string, unknown>): void {
+  function isRecord(value: unknown): value is Record<string, unknown> {
+    return value !== null && typeof value === 'object'
+  }
+  if (!isRecord(tx.MintURIToken)) {
+    throw new ValidationError('Remit: invalid MintURIToken')
+  }
+  if (tx.MintURIToken.URI === undefined) {
+    throw new ValidationError('Remit: missing field MintURIToken.URI')
+  }
+  if (typeof tx.MintURIToken.URI !== 'string' || !isHex(tx.MintURIToken.URI)) {
+    throw new ValidationError('Remit: MintURIToken.URI must be a hex string')
+  }
+  if (tx.MintURIToken.URI.length > MAX_URI_LENGTH) {
+    throw new ValidationError(
+      `Remit: URI must be less than ${MAX_URI_LENGTH} characters`,
+    )
+  }
+  if (
+    tx.MintURIToken.Digest !== undefined &&
+    typeof tx.MintURIToken.Digest !== 'string'
+  ) {
+    throw new ValidationError(`Remit: MintURIToken.Digest must be a string`)
+  }
+  if (
+    tx.MintURIToken.Digest !== undefined &&
+    !isHex(tx.MintURIToken.Digest) &&
+    tx.MintURIToken.Digest.length !== DIGEST_LENGTH
+  ) {
+    throw new ValidationError(
+      `Remit: Digest must be exactly ${DIGEST_LENGTH} characters`,
+    )
+  }
+}

packages/xrpl/src/models/transactions/transaction.ts

@@ -46,6 +46,7 @@ import {
   PaymentChannelFund,
   validatePaymentChannelFund,
 } from './paymentChannelFund'
+import { Remit, validateRemit } from './remit'
 import { SetHook, validateSetHook } from './setHook'
 import { SetRegularKey, validateSetRegularKey } from './setRegularKey'
 import { SignerListSet, validateSignerListSet } from './signerListSet'
@@ -90,6 +91,7 @@ export type Transaction =
   | PaymentChannelClaim
   | PaymentChannelCreate
   | PaymentChannelFund
+  | Remit
   | SetHook
   | SetRegularKey
   | SignerListSet
@@ -220,14 +222,18 @@ export function validate(transaction: Record<string, unknown>): void {
       validatePaymentChannelFund(tx)
       break
 
-    case 'SetRegularKey':
+    case 'Remit':
-      validateSetRegularKey(tx)
+      validateRemit(tx)
       break
 
     case 'SetHook':
       validateSetHook(tx)
       break
 
+    case 'SetRegularKey':
+      validateSetRegularKey(tx)
+      break
+
     case 'SignerListSet':
       validateSignerListSet(tx)
       break

packages/xrpl/test/models/remit.test.ts

@@ -0,0 +1,369 @@
+import { assert } from 'chai'
+
+import { validate, ValidationError } from '../../src'
+import { validateRemit } from '../../src/models/transactions/remit'
+
+/**
+ * Remit Verification Testing.
+ *
+ * Providing runtime verification testing for each specific transaction type.
+ */
+
+// eslint-disable-next-line max-statements -- ignore
+describe('Remit', function () {
+  let remit
+
+  beforeEach(function () {
+    remit = {
+      TransactionType: 'Remit',
+      Account: 'rUn84CUYbNjRoTQ6mSW7BVJPSVJNLb1QLo',
+      Destination: 'rfkE1aSy9G8Upk4JssnwBxhEv5p4mn2KTy',
+      DestinationTag: 1,
+      Fee: '12',
+      Flags: 0,
+      LastLedgerSequence: 65953073,
+      Sequence: 65923914,
+      SigningPubKey:
+        '02F9E33F16DF9507705EC954E3F94EB5F10D1FC4A354606DBE6297DBB1096FE654',
+      TxnSignature:
+        '3045022100E3FAE0EDEC3D6A8FF6D81BC9CF8288A61B7EEDE8071E90FF9314CB4621058D10022043545CF631706D700CEE65A1DB83EFDD185413808292D9D90F14D87D3DC2D8CB',
+      Amounts: [
+        { AmountEntry: { Amount: '1000' } },
+        {
+          AmountEntry: {
+            Amount: {
+              currency: 'USD',
+              issuer: 'rcXY84C4g14iFp6taFXjjQGVeHqSCh9RX',
+              value: '1',
+            },
+          },
+        },
+      ],
+      MintURIToken: {
+        URI: 'DEADBEEF',
+        Digest:
+          '6F1DFD1D0FE8A32E40E1F2C05CF1C15545BAB56B617F9C6C2D63A6B704BEF59B',
+        Flags: 1,
+      },
+      URITokenIDs: [
+        'AED08CC1F50DD5F23A1948AF86153A3F3B7593E5EC77D65A02BB1B29E05AB6AE',
+      ],
+      InvoiceID:
+        '6F1DFD1D0FE8A32E40E1F2C05CF1C15545BAB56B617F9C6C2D63A6B704BEF59B',
+      Blob: 'DEADBEEF',
+      Inform: 'rB5Ux4Lv2nRx6eeoAAsZmtctnBQ2LiACnk',
+    } as any
+  })
+
+  it(`verifies valid Remit`, function () {
+    assert.doesNotThrow(() => validateRemit(remit))
+    assert.doesNotThrow(() => validate(remit))
+  })
+
+  it(`throws w/ Bad Amounts`, function () {
+    remit.Amounts = {}
+    assert.throws(
+      () => validateRemit(remit),
+      ValidationError,
+      'Remit: Amounts must be an array',
+    )
+  })
+  it(`throws w/ Empty Amounts`, function () {
+    remit.Amounts = []
+    assert.throws(
+      () => validateRemit(remit),
+      ValidationError,
+      'Remit: empty field Amounts',
+    )
+  })
+  it(`throws w/ Max Amounts`, function () {
+    remit.Amounts = [
+      { AmountEntry: { Amount: '1000' } },
+      { AmountEntry: { Amount: '1000' } },
+      { AmountEntry: { Amount: '1000' } },
+      { AmountEntry: { Amount: '1000' } },
+      { AmountEntry: { Amount: '1000' } },
+      { AmountEntry: { Amount: '1000' } },
+      { AmountEntry: { Amount: '1000' } },
+      { AmountEntry: { Amount: '1000' } },
+      { AmountEntry: { Amount: '1000' } },
+      { AmountEntry: { Amount: '1000' } },
+      { AmountEntry: { Amount: '1000' } },
+      { AmountEntry: { Amount: '1000' } },
+      { AmountEntry: { Amount: '1000' } },
+      { AmountEntry: { Amount: '1000' } },
+      { AmountEntry: { Amount: '1000' } },
+      { AmountEntry: { Amount: '1000' } },
+      { AmountEntry: { Amount: '1000' } },
+      { AmountEntry: { Amount: '1000' } },
+      { AmountEntry: { Amount: '1000' } },
+      { AmountEntry: { Amount: '1000' } },
+      { AmountEntry: { Amount: '1000' } },
+      { AmountEntry: { Amount: '1000' } },
+      { AmountEntry: { Amount: '1000' } },
+      { AmountEntry: { Amount: '1000' } },
+      { AmountEntry: { Amount: '1000' } },
+      { AmountEntry: { Amount: '1000' } },
+      { AmountEntry: { Amount: '1000' } },
+      { AmountEntry: { Amount: '1000' } },
+      { AmountEntry: { Amount: '1000' } },
+      { AmountEntry: { Amount: '1000' } },
+      { AmountEntry: { Amount: '1000' } },
+      { AmountEntry: { Amount: '1000' } },
+      { AmountEntry: { Amount: '1000' } },
+      { AmountEntry: { Amount: '1000' } },
+    ]
+    assert.throws(
+      () => validateRemit(remit),
+      ValidationError,
+      'Remit: max field Amounts',
+    )
+  })
+  it(`throws w/ Duplicate native amounts`, function () {
+    remit.Amounts = [
+      { AmountEntry: { Amount: '1000' } },
+      { AmountEntry: { Amount: '1000' } },
+    ]
+    assert.throws(
+      () => validateRemit(remit),
+      ValidationError,
+      'Remit: Duplicate Native amounts are not allowed',
+    )
+  })
+  it(`throws w/ Duplicate amounts`, function () {
+    remit.Amounts = [
+      {
+        AmountEntry: {
+          Amount: {
+            currency: 'USD',
+            issuer: 'rcXY84C4g14iFp6taFXjjQGVeHqSCh9RX',
+            value: '1',
+          },
+        },
+      },
+      {
+        AmountEntry: {
+          Amount: {
+            currency: 'USD',
+            issuer: 'rcXY84C4g14iFp6taFXjjQGVeHqSCh9RX',
+            value: '1',
+          },
+        },
+      },
+    ]
+    assert.throws(
+      () => validateRemit(remit),
+      ValidationError,
+      'Remit: Duplicate amounts are not allowed',
+    )
+  })
+  it(`throws w/ Bad URITokenIDs`, function () {
+    remit.URITokenIDs = {}
+    assert.throws(
+      () => validateRemit(remit),
+      ValidationError,
+      'Remit: invalid field URITokenIDs',
+    )
+  })
+  it(`throws w/ Empty URITokenIDs`, function () {
+    remit.URITokenIDs = []
+    assert.throws(
+      () => validateRemit(remit),
+      ValidationError,
+      'Remit: empty field URITokenIDs',
+    )
+  })
+  it(`throws w/ Empty URITokenIDs`, function () {
+    remit.URITokenIDs = [
+      'DEADBEEF',
+      'DEADBEEF',
+      'DEADBEEF',
+      'DEADBEEF',
+      'DEADBEEF',
+      'DEADBEEF',
+      'DEADBEEF',
+      'DEADBEEF',
+      'DEADBEEF',
+      'DEADBEEF',
+      'DEADBEEF',
+      'DEADBEEF',
+      'DEADBEEF',
+      'DEADBEEF',
+      'DEADBEEF',
+      'DEADBEEF',
+      'DEADBEEF',
+      'DEADBEEF',
+      'DEADBEEF',
+      'DEADBEEF',
+      'DEADBEEF',
+      'DEADBEEF',
+      'DEADBEEF',
+      'DEADBEEF',
+      'DEADBEEF',
+      'DEADBEEF',
+      'DEADBEEF',
+      'DEADBEEF',
+      'DEADBEEF',
+      'DEADBEEF',
+      'DEADBEEF',
+      'DEADBEEF',
+      'DEADBEEF',
+    ]
+    assert.throws(
+      () => validateRemit(remit),
+      ValidationError,
+      'Remit: max field URITokenIDs',
+    )
+  })
+  it(`throws w/ Invalid URITokenID`, function () {
+    remit.URITokenIDs = [1]
+    assert.throws(
+      () => validateRemit(remit),
+      ValidationError,
+      'Remit: URITokenID must be a hex string',
+    )
+  })
+  it(`throws w/ Invalid URITokenID`, function () {
+    remit.URITokenIDs = ['ZZ11']
+    assert.throws(
+      () => validateRemit(remit),
+      ValidationError,
+      'Remit: URITokenID must be a hex string',
+    )
+  })
+  it(`throws w/ Duplicate URITokenIDs`, function () {
+    remit.URITokenIDs = ['DEADBEEF']
+    assert.throws(
+      () => validateRemit(remit),
+      ValidationError,
+      'Remit: URITokenID must be exactly 64 characters',
+    )
+  })
+  it(`throws w/ Duplicate URITokenIDs`, function () {
+    remit.URITokenIDs = [
+      'AED08CC1F50DD5F23A1948AF86153A3F3B7593E5EC77D65A02BB1B29E05AB6AE',
+      'AED08CC1F50DD5F23A1948AF86153A3F3B7593E5EC77D65A02BB1B29E05AB6AE',
+    ]
+    assert.throws(
+      () => validateRemit(remit),
+      ValidationError,
+      'Remit: Duplicate URITokens are not allowed',
+    )
+  })
+  // it(`throws w/ Bad MintURIToken`, function () {
+  //   remit.MintURIToken = []
+  //   assert.throws(
+  //     () => validateRemit(remit),
+  //     ValidationError,
+  //     'Remit: invalid MintURIToken',
+  //   )
+  // })
+  it(`throws w/ Missing MintURIToken.URI`, function () {
+    remit.MintURIToken = {}
+    assert.throws(
+      () => validateRemit(remit),
+      ValidationError,
+      'Remit: missing field MintURIToken.URI',
+    )
+  })
+  it(`throws w/ Bad MintURIToken.URI`, function () {
+    remit.MintURIToken = {
+      URI: 1,
+    }
+    assert.throws(
+      () => validateRemit(remit),
+      ValidationError,
+      'Remit: MintURIToken.URI must be a hex string',
+    )
+  })
+  it(`throws w/ Bad MintURIToken.URI`, function () {
+    remit.MintURIToken = {
+      URI: 'ZZ11',
+    }
+    assert.throws(
+      () => validateRemit(remit),
+      ValidationError,
+      'Remit: MintURIToken.URI must be a hex string',
+    )
+  })
+  it(`throws w/ Bad MintURIToken Less than 1`, function () {
+    remit.MintURIToken = {
+      URI: '',
+    }
+    assert.throws(
+      () => validateRemit(remit),
+      ValidationError,
+      'Remit: MintURIToken.URI must be a hex string',
+    )
+  })
+  it(`throws w/ Bad MintURIToken.Digest`, function () {
+    remit.MintURIToken = {
+      URI: 'DEADBEEF',
+      Digest: 1,
+    }
+    assert.throws(
+      () => validateRemit(remit),
+      ValidationError,
+      'Remit: MintURIToken.Digest must be a string',
+    )
+  })
+  it(`throws w/ Bad MintURIToken.Digest`, function () {
+    remit.MintURIToken = {
+      URI: 'DEADBEEF',
+      Digest: 'ZZ11',
+    }
+    assert.throws(
+      () => validateRemit(remit),
+      ValidationError,
+      'Remit: Digest must be exactly 64 characters',
+    )
+  })
+  it(`throws w/ Bad Destination`, function () {
+    remit.Destination = 'rUn84CUYbNjRoTQ6mSW7BVJPSVJNLb1QLo'
+    assert.throws(
+      () => validateRemit(remit),
+      ValidationError,
+      'Remit: Destination must not be equal to the account',
+    )
+  })
+  it(`throws w/ Bad Destination Tag`, function () {
+    remit.DestinationTag = '1'
+    assert.throws(
+      () => validateRemit(remit),
+      ValidationError,
+      'Remit: DestinationTag must be a number',
+    )
+  })
+  it(`throws w/ Bad Inform`, function () {
+    remit.Inform = 'rUn84CUYbNjRoTQ6mSW7BVJPSVJNLb1QLo'
+    assert.throws(
+      () => validateRemit(remit),
+      ValidationError,
+      'Remit: Inform must not be equal to the account or destination',
+    )
+  })
+  it(`throws w/ Bad Blob Type`, function () {
+    remit.Blob = 1
+    assert.throws(
+      () => validateRemit(remit),
+      ValidationError,
+      'Remit: Blob must be a string',
+    )
+  })
+  it(`throws w/ Bad Blob Not Hex`, function () {
+    remit.Blob = 'ZZ11'
+    assert.throws(
+      () => validateRemit(remit),
+      ValidationError,
+      'Remit: Blob must be a hex string',
+    )
+  })
+  // it(`throws w/ Bad Blob Max Size`, function () {
+  //   remit.Blob = ''
+  //   assert.throws(
+  //     () => validateRemit(remit),
+  //     ValidationError,
+  //     'Remit: Blob must be a hex string',
+  //   )
+  // })
+})