xrpl 4.3.0-smartescrow.2 → 4.3.0

package/src/models/transactions/oracleSet.ts

@@ -86,113 +86,117 @@ export function validateOracleSet(tx: Record<string, unknown>): void {
   validateOptionalField(tx, 'AssetClass', isString)
 
   /* eslint-disable max-statements, max-lines-per-function -- necessary to validate many fields */
-  validateRequiredField(tx, 'PriceDataSeries', (value) => {
-    if (!Array.isArray(value)) {
-      throw new ValidationError('OracleSet: PriceDataSeries must be an array')
-    }
-
-    if (value.length > PRICE_DATA_SERIES_MAX_LENGTH) {
-      throw new ValidationError(
-        `OracleSet: PriceDataSeries must have at most ${PRICE_DATA_SERIES_MAX_LENGTH} PriceData objects`,
-      )
-    }
-
-    // TODO: add support for handling inner objects easier (similar to validateRequiredField/validateOptionalField)
-    for (const priceData of value) {
-      if (typeof priceData !== 'object') {
-        throw new ValidationError(
-          'OracleSet: PriceDataSeries must be an array of objects',
-        )
+  validateRequiredField(
+    tx,
+    'PriceDataSeries',
+    (value: unknown): value is PriceData => {
+      if (!Array.isArray(value)) {
+        throw new ValidationError('OracleSet: PriceDataSeries must be an array')
       }
 
-      // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access -- we are validating the type
-      if (priceData.PriceData == null) {
+      if (value.length > PRICE_DATA_SERIES_MAX_LENGTH) {
         throw new ValidationError(
-          'OracleSet: PriceDataSeries must have a `PriceData` object',
+          `OracleSet: PriceDataSeries must have at most ${PRICE_DATA_SERIES_MAX_LENGTH} PriceData objects`,
         )
       }
 
-      // check if priceData only has PriceData
-      if (Object.keys(priceData).length !== 1) {
-        throw new ValidationError(
-          'OracleSet: PriceDataSeries must only have a single PriceData object',
-        )
-      }
+      // TODO: add support for handling inner objects easier (similar to validateRequiredField/validateOptionalField)
+      for (const priceData of value) {
+        if (typeof priceData !== 'object') {
+          throw new ValidationError(
+            'OracleSet: PriceDataSeries must be an array of objects',
+          )
+        }
 
-      // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access -- we are validating the type
-      if (typeof priceData.PriceData.BaseAsset !== 'string') {
-        throw new ValidationError(
-          'OracleSet: PriceDataSeries must have a `BaseAsset` string',
-        )
-      }
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access -- we are validating the type
+        if (priceData.PriceData == null) {
+          throw new ValidationError(
+            'OracleSet: PriceDataSeries must have a `PriceData` object',
+          )
+        }
 
-      // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access -- we are validating the type
-      if (typeof priceData.PriceData.QuoteAsset !== 'string') {
-        throw new ValidationError(
-          'OracleSet: PriceDataSeries must have a `QuoteAsset` string',
-        )
-      }
+        // check if priceData only has PriceData
+        if (Object.keys(priceData).length !== 1) {
+          throw new ValidationError(
+            'OracleSet: PriceDataSeries must only have a single PriceData object',
+          )
+        }
 
-      // Either AssetPrice and Scale are both present or both excluded
-      if (
         // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access -- we are validating the type
-        (priceData.PriceData.AssetPrice == null) !==
+        if (typeof priceData.PriceData.BaseAsset !== 'string') {
+          throw new ValidationError(
+            'OracleSet: PriceDataSeries must have a `BaseAsset` string',
+          )
+        }
+
         // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access -- we are validating the type
-        (priceData.PriceData.Scale == null)
-      ) {
-        throw new ValidationError(
-          'OracleSet: PriceDataSeries must have both `AssetPrice` and `Scale` if any are present',
-        )
-      }
+        if (typeof priceData.PriceData.QuoteAsset !== 'string') {
+          throw new ValidationError(
+            'OracleSet: PriceDataSeries must have a `QuoteAsset` string',
+          )
+        }
+
+        // Either AssetPrice and Scale are both present or both excluded
+        if (
+          // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access -- we are validating the type
+          (priceData.PriceData.AssetPrice == null) !==
+          // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access -- we are validating the type
+          (priceData.PriceData.Scale == null)
+        ) {
+          throw new ValidationError(
+            'OracleSet: PriceDataSeries must have both `AssetPrice` and `Scale` if any are present',
+          )
+        }
 
-      /* eslint-disable @typescript-eslint/no-unsafe-member-access, max-depth --
+        /* eslint-disable @typescript-eslint/no-unsafe-member-access, max-depth --
       we need to validate priceData.PriceData.AssetPrice value */
-      if ('AssetPrice' in priceData.PriceData) {
-        if (!isNumber(priceData.PriceData.AssetPrice)) {
-          if (typeof priceData.PriceData.AssetPrice !== 'string') {
-            throw new ValidationError(
-              'OracleSet: Field AssetPrice must be a string or a number',
-            )
-          }
-          if (!isHex(priceData.PriceData.AssetPrice)) {
-            throw new ValidationError(
-              'OracleSet: Field AssetPrice must be a valid hex string',
-            )
-          }
-          if (
-            priceData.PriceData.AssetPrice.length <
-              MINIMUM_ASSET_PRICE_LENGTH ||
-            priceData.PriceData.AssetPrice.length > MAXIMUM_ASSET_PRICE_LENGTH
-          ) {
-            throw new ValidationError(
-              `OracleSet: Length of AssetPrice field must be between ${MINIMUM_ASSET_PRICE_LENGTH} and ${MAXIMUM_ASSET_PRICE_LENGTH} characters long`,
-            )
+        if ('AssetPrice' in priceData.PriceData) {
+          if (!isNumber(priceData.PriceData.AssetPrice)) {
+            if (typeof priceData.PriceData.AssetPrice !== 'string') {
+              throw new ValidationError(
+                'OracleSet: Field AssetPrice must be a string or a number',
+              )
+            }
+            if (!isHex(priceData.PriceData.AssetPrice)) {
+              throw new ValidationError(
+                'OracleSet: Field AssetPrice must be a valid hex string',
+              )
+            }
+            if (
+              priceData.PriceData.AssetPrice.length <
+                MINIMUM_ASSET_PRICE_LENGTH ||
+              priceData.PriceData.AssetPrice.length > MAXIMUM_ASSET_PRICE_LENGTH
+            ) {
+              throw new ValidationError(
+                `OracleSet: Length of AssetPrice field must be between ${MINIMUM_ASSET_PRICE_LENGTH} and ${MAXIMUM_ASSET_PRICE_LENGTH} characters long`,
+              )
+            }
           }
         }
-      }
-      /* eslint-enable @typescript-eslint/no-unsafe-member-access, max-depth */
-
-      if (
-        // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access -- we are validating the type
-        'Scale' in priceData.PriceData &&
-        // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access -- we are validating the type
-        !isNumber(priceData.PriceData.Scale)
-      ) {
-        throw new ValidationError('OracleSet: invalid field Scale')
-      }
+        /* eslint-enable @typescript-eslint/no-unsafe-member-access, max-depth */
+
+        if (
+          // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access -- we are validating the type
+          'Scale' in priceData.PriceData &&
+          // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access -- we are validating the type
+          !isNumber(priceData.PriceData.Scale)
+        ) {
+          throw new ValidationError('OracleSet: invalid field Scale')
+        }
 
-      if (
-        // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access -- we are validating the type
-        priceData.PriceData.Scale < 0 ||
-        // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access -- we are validating the type
-        priceData.PriceData.Scale > SCALE_MAX
-      ) {
-        throw new ValidationError(
-          `OracleSet: Scale must be in range 0-${SCALE_MAX}`,
-        )
+        if (
+          // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access -- we are validating the type
+          priceData.PriceData.Scale < 0 ||
+          // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access -- we are validating the type
+          priceData.PriceData.Scale > SCALE_MAX
+        ) {
+          throw new ValidationError(
+            `OracleSet: Scale must be in range 0-${SCALE_MAX}`,
+          )
+        }
       }
-    }
-    return true
-  })
+      return true
+    },
+  )
   /* eslint-enable max-statements, max-lines-per-function */
 }

package/src/models/transactions/payment.ts

@@ -5,7 +5,7 @@ import { isFlagEnabled } from '../utils'
 import {
   BaseTransaction,
   isAmount,
-  GlobalFlags,
+  GlobalFlagsInterface,
   validateBaseTransaction,
   isAccount,
   validateRequiredField,
@@ -84,7 +84,7 @@ export enum PaymentFlags {
  * // }
  * ```
  */
-export interface PaymentFlagsInterface extends GlobalFlags {
+export interface PaymentFlagsInterface extends GlobalFlagsInterface {
   /**
    * Do not use the default path; only use paths included in the Paths field.
    * This is intended to force the transaction to take arbitrage opportunities.
@@ -186,8 +186,7 @@ export function validatePayment(tx: Record<string, unknown>): void {
 
   validateCredentialsList(
     tx.CredentialIDs,
-    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions -- known from base check
-    tx.TransactionType as string,
+    tx.TransactionType,
     true,
     MAX_AUTHORIZED_CREDENTIALS,
   )
@@ -264,7 +263,10 @@ function isPathStep(pathStep: Record<string, unknown>): boolean {
   return false
 }
 
-function isPath(path: Array<Record<string, unknown>>): boolean {
+function isPath(path: unknown): path is Path {
+  if (!Array.isArray(path) || path.length === 0) {
+    return false
+  }
   for (const pathStep of path) {
     if (!isPathStep(pathStep)) {
       return false
@@ -273,7 +275,7 @@ function isPath(path: Array<Record<string, unknown>>): boolean {
   return true
 }
 
-function isPaths(paths: Array<Array<Record<string, unknown>>>): boolean {
+function isPaths(paths: unknown): paths is Path[] {
   if (!Array.isArray(paths) || paths.length === 0) {
     return false
   }

package/src/models/transactions/paymentChannelClaim.ts

@@ -2,7 +2,7 @@ import { ValidationError } from '../../errors'
 
 import {
   BaseTransaction,
-  GlobalFlags,
+  GlobalFlagsInterface,
   validateBaseTransaction,
   validateCredentialsList,
   MAX_AUTHORIZED_CREDENTIALS,
@@ -73,7 +73,8 @@ export enum PaymentChannelClaimFlags {
  * // }
  * ```
  */
-export interface PaymentChannelClaimFlagsInterface extends GlobalFlags {
+export interface PaymentChannelClaimFlagsInterface
+  extends GlobalFlagsInterface {
   /**
    * Clear the channel's Expiration time. (Expiration is different from the
    * channel's immutable CancelAfter time.) Only the source address of the
@@ -151,8 +152,7 @@ export function validatePaymentChannelClaim(tx: Record<string, unknown>): void {
 
   validateCredentialsList(
     tx.CredentialIDs,
-    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions -- known from base check
-    tx.TransactionType as string,
+    tx.TransactionType,
     true,
     MAX_AUTHORIZED_CREDENTIALS,
   )

package/src/models/transactions/permissionedDomainSet.ts

@@ -7,6 +7,7 @@ import {
   validateOptionalField,
   validateRequiredField,
   validateCredentialsList,
+  isArray,
 } from './common'
 
 const MAX_ACCEPTED_CREDENTIALS = 10
@@ -36,16 +37,11 @@ export function validatePermissionedDomainSet(
   validateBaseTransaction(tx)
 
   validateOptionalField(tx, 'DomainID', isString)
-  validateRequiredField(
-    tx,
-    'AcceptedCredentials',
-    () => tx.AcceptedCredentials instanceof Array,
-  )
+  validateRequiredField(tx, 'AcceptedCredentials', isArray)
 
   validateCredentialsList(
     tx.AcceptedCredentials,
-    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions -- known from base check
-    tx.TransactionType as string,
+    tx.TransactionType,
     // PermissionedDomainSet uses AuthorizeCredential nested objects only, strings are not allowed
     false,
     // PermissionedDomainSet uses at most 10 accepted credentials. This is different from Credential-feature transactions.

package/src/models/transactions/signerListSet.ts

@@ -1,7 +1,7 @@
 import { ValidationError } from '../../errors'
 import { SignerEntry } from '../common'
 
-import { BaseTransaction, validateBaseTransaction } from './common'
+import { BaseTransaction, isArray, validateBaseTransaction } from './common'
 
 /**
  * The SignerListSet transaction creates, replaces, or removes a list of
@@ -56,7 +56,7 @@ export function validateSignerListSet(tx: Record<string, unknown>): void {
     throw new ValidationError('SignerListSet: missing field SignerEntries')
   }
 
-  if (!Array.isArray(tx.SignerEntries)) {
+  if (!isArray(tx.SignerEntries)) {
     throw new ValidationError('SignerListSet: invalid SignerEntries')
   }
 

package/src/models/transactions/transaction.ts

@@ -15,6 +15,7 @@ import { AMMDelete, validateAMMDelete } from './AMMDelete'
 import { AMMDeposit, validateAMMDeposit } from './AMMDeposit'
 import { AMMVote, validateAMMVote } from './AMMVote'
 import { AMMWithdraw, validateAMMWithdraw } from './AMMWithdraw'
+import { Batch, validateBatch } from './batch'
 import { CheckCancel, validateCheckCancel } from './checkCancel'
 import { CheckCash, validateCheckCash } from './checkCash'
 import { CheckCreate, validateCheckCreate } from './checkCreate'
@@ -23,6 +24,7 @@ import { BaseTransaction, isIssuedCurrency } from './common'
 import { CredentialAccept, validateCredentialAccept } from './CredentialAccept'
 import { CredentialCreate, validateCredentialCreate } from './CredentialCreate'
 import { CredentialDelete, validateCredentialDelete } from './CredentialDelete'
+import { DelegateSet, validateDelegateSet } from './delegateSet'
 import { DepositPreauth, validateDepositPreauth } from './depositPreauth'
 import { DIDDelete, validateDIDDelete } from './DIDDelete'
 import { DIDSet, validateDIDSet } from './DIDSet'
@@ -132,6 +134,7 @@ export type SubmittableTransaction =
   | AMMWithdraw
   | AccountDelete
   | AccountSet
+  | Batch
   | CheckCancel
   | CheckCash
   | CheckCreate
@@ -141,6 +144,7 @@ export type SubmittableTransaction =
   | CredentialDelete
   | DIDDelete
   | DIDSet
+  | DelegateSet
   | DepositPreauth
   | EscrowCancel
   | EscrowCreate
@@ -307,6 +311,19 @@ export function validate(transaction: Record<string, unknown>): void {
       validateAccountSet(tx)
       break
 
+    case 'Batch':
+      validateBatch(tx)
+      // This is done here to avoid issues with dependency cycles
+
+      // eslint-disable-next-line @typescript-eslint/ban-ts-comment -- okay here
+      // @ts-expect-error -- already checked
+      // eslint-disable-next-line @typescript-eslint/no-unsafe-call -- already checked above
+      tx.RawTransactions.forEach((innerTx: Record<string, unknown>) => {
+        // eslint-disable-next-line @typescript-eslint/consistent-type-assertions -- already checked above
+        validate(innerTx.RawTransaction as Record<string, unknown>)
+      })
+      break
+
     case 'CheckCancel':
       validateCheckCancel(tx)
       break
@@ -343,6 +360,10 @@ export function validate(transaction: Record<string, unknown>): void {
       validateDIDSet(tx)
       break
 
+    case 'DelegateSet':
+      validateDelegateSet(tx)
+      break
+
     case 'DepositPreauth':
       validateDepositPreauth(tx)
       break

package/src/models/transactions/trustSet.ts

@@ -3,7 +3,7 @@ import { IssuedCurrencyAmount } from '../common'
 
 import {
   BaseTransaction,
-  GlobalFlags,
+  GlobalFlagsInterface,
   isAmount,
   validateBaseTransaction,
 } from './common'
@@ -77,7 +77,7 @@ export enum TrustSetFlags {
  * // }
  * ```
  */
-export interface TrustSetFlagsInterface extends GlobalFlags {
+export interface TrustSetFlagsInterface extends GlobalFlagsInterface {
   /**
    * Authorize the other party to hold currency issued by this account. (No
    * effect unless using the asfRequireAuth AccountSet flag.) Cannot be unset.

package/src/models/utils/flags.ts

@@ -8,6 +8,8 @@ import { AccountSetTfFlags } from '../transactions/accountSet'
 import { AMMClawbackFlags } from '../transactions/AMMClawback'
 import { AMMDepositFlags } from '../transactions/AMMDeposit'
 import { AMMWithdrawFlags } from '../transactions/AMMWithdraw'
+import { BatchFlags } from '../transactions/batch'
+import { GlobalFlags } from '../transactions/common'
 import { MPTokenAuthorizeFlags } from '../transactions/MPTokenAuthorize'
 import { MPTokenIssuanceCreateFlags } from '../transactions/MPTokenIssuanceCreate'
 import { MPTokenIssuanceSetFlags } from '../transactions/MPTokenIssuanceSet'
@@ -51,6 +53,7 @@ const txToFlag = {
   AMMClawback: AMMClawbackFlags,
   AMMDeposit: AMMDepositFlags,
   AMMWithdraw: AMMWithdrawFlags,
+  Batch: BatchFlags,
   MPTokenAuthorize: MPTokenAuthorizeFlags,
   MPTokenIssuanceCreate: MPTokenIssuanceCreateFlags,
   MPTokenIssuanceSet: MPTokenIssuanceSetFlags,
@@ -97,27 +100,36 @@ export function setTransactionFlagsToNumber(tx: Transaction): void {
  * @returns A numerical representation of a Transaction's Flags
  */
 export function convertTxFlagsToNumber(tx: Transaction): number {
-  if (!tx.Flags) {
+  const txFlags = tx.Flags
+  if (txFlags == null) {
     return 0
   }
-  if (typeof tx.Flags === 'number') {
-    return tx.Flags
+  if (typeof txFlags === 'number') {
+    return txFlags
   }
 
   if (isTxToFlagKey(tx.TransactionType)) {
     const flagEnum = txToFlag[tx.TransactionType]
-    return Object.keys(tx.Flags).reduce((resultFlags, flag) => {
-      if (flagEnum[flag] == null) {
-        throw new ValidationError(
-          `Invalid flag ${flag}. Valid flags are ${JSON.stringify(flagEnum)}`,
-        )
+    return Object.keys(txFlags).reduce((resultFlags, flag) => {
+      if (flagEnum[flag] == null && GlobalFlags[flag] == null) {
+        throw new ValidationError(`Invalid flag ${flag}.`)
       }
 
-      return tx.Flags?.[flag] ? resultFlags | flagEnum[flag] : resultFlags
+      return txFlags[flag]
+        ? resultFlags | (flagEnum[flag] || GlobalFlags[flag])
+        : resultFlags
     }, 0)
   }
 
-  return 0
+  return Object.keys(txFlags).reduce((resultFlags, flag) => {
+    if (GlobalFlags[flag] == null) {
+      throw new ValidationError(
+        `Invalid flag ${flag}. Valid flags are ${JSON.stringify(GlobalFlags)}`,
+      )
+    }
+
+    return txFlags[flag] ? resultFlags | GlobalFlags[flag] : resultFlags
+  }, 0)
 }
 
 /**
@@ -146,5 +158,11 @@ export function parseTransactionFlags(tx: Transaction): object {
     })
   }
 
+  Object.values(GlobalFlags).forEach((flag) => {
+    if (typeof flag === 'string' && isFlagEnabled(flags, GlobalFlags[flag])) {
+      booleanFlagMap[flag] = true
+    }
+  })
+
   return booleanFlagMap
 }

package/src/models/utils/index.ts

@@ -1,3 +1,5 @@
+import type { Transaction } from '../transactions'
+
 const HEX_REGEX = /^[0-9A-Fa-f]+$/u
 export const INTEGER_SANITY_CHECK = /^[0-9]+$/u
 
@@ -27,6 +29,28 @@ export function isFlagEnabled(Flags: number, checkFlag: number): boolean {
   return (BigInt(checkFlag) & BigInt(Flags)) === BigInt(checkFlag)
 }
 
+/**
+ * Determines whether a transaction has a certain flag enabled.
+ *
+ * @param tx The transaction to check for the flag.
+ * @param flag The flag to check.
+ * @param flagName The name of the flag to check, used for object flags.
+ * @returns Whether `flag` is enabled on `tx`.
+ */
+export function hasFlag(
+  tx: Transaction | Record<string, unknown>,
+  flag: number,
+  flagName: string,
+): boolean {
+  if (tx.Flags == null) {
+    return false
+  }
+  if (typeof tx.Flags === 'number') {
+    return isFlagEnabled(tx.Flags, flag)
+  }
+  return tx.Flags[flagName] === true
+}
+
 /**
  * Check if string is in hex format.
  *