xrpl 4.3.0 → 4.4.0-smartescrow.0

package/src/models/transactions/common.ts

@@ -7,31 +7,42 @@ import { ValidationError } from '../../errors'
 import {
   Amount,
   AuthorizeCredential,
+  ClawbackAmount,
   Currency,
+  IssuedCurrency,
   IssuedCurrencyAmount,
   MPTAmount,
   Memo,
   Signer,
   XChainBridge,
 } from '../common'
-import { onlyHasFields } from '../utils'
+import { isHex, onlyHasFields } from '../utils'
 
 const MEMO_SIZE = 3
 export const MAX_AUTHORIZED_CREDENTIALS = 8
 const MAX_CREDENTIAL_BYTE_LENGTH = 64
 const MAX_CREDENTIAL_TYPE_LENGTH = MAX_CREDENTIAL_BYTE_LENGTH * 2
 
-function isMemo(obj: { Memo?: unknown }): boolean {
-  if (obj.Memo == null) {
+// Used for Vault transactions
+export const VAULT_DATA_MAX_BYTE_LENGTH = 256
+
+function isMemo(obj: unknown): obj is Memo {
+  if (!isRecord(obj)) {
+    return false
+  }
+
+  const memo = obj.Memo
+  if (!isRecord(memo)) {
     return false
   }
-  // eslint-disable-next-line @typescript-eslint/consistent-type-assertions -- Only used by JS
-  const memo = obj.Memo as Record<string, unknown>
   const size = Object.keys(memo).length
-  const validData = memo.MemoData == null || typeof memo.MemoData === 'string'
+  const validData =
+    memo.MemoData == null || (isString(memo.MemoData) && isHex(memo.MemoData))
   const validFormat =
-    memo.MemoFormat == null || typeof memo.MemoFormat === 'string'
-  const validType = memo.MemoType == null || typeof memo.MemoType === 'string'
+    memo.MemoFormat == null ||
+    (isString(memo.MemoFormat) && isHex(memo.MemoFormat))
+  const validType =
+    memo.MemoType == null || (isString(memo.MemoType) && isHex(memo.MemoType))
 
   return (
     size >= 1 &&
@@ -45,20 +56,21 @@ function isMemo(obj: { Memo?: unknown }): boolean {
 
 const SIGNER_SIZE = 3
 
-function isSigner(obj: unknown): boolean {
-  // eslint-disable-next-line @typescript-eslint/consistent-type-assertions -- Only used by JS
-  const signerWrapper = obj as Record<string, unknown>
+function isSigner(obj: unknown): obj is Signer {
+  if (!isRecord(obj)) {
+    return false
+  }
 
-  if (signerWrapper.Signer == null) {
+  const signer = obj.Signer
+  if (!isRecord(signer)) {
     return false
   }
-  // eslint-disable-next-line @typescript-eslint/consistent-type-assertions -- Only used by JS and Signer is previously unknown
-  const signer = signerWrapper.Signer as Record<string, unknown>
+
   return (
     Object.keys(signer).length === SIGNER_SIZE &&
-    typeof signer.Account === 'string' &&
-    typeof signer.TxnSignature === 'string' &&
-    typeof signer.SigningPubKey === 'string'
+    isString(signer.Account) &&
+    isString(signer.TxnSignature) &&
+    isString(signer.SigningPubKey)
   )
 }
 
@@ -76,7 +88,7 @@ const AUTHORIZE_CREDENTIAL_SIZE = 1
  * @returns Whether the Record/Object is properly formed.
  */
 export function isRecord(value: unknown): value is Record<string, unknown> {
-  return value !== null && typeof value === 'object'
+  return value !== null && typeof value === 'object' && !Array.isArray(value)
 }
 
 /**
@@ -99,18 +111,50 @@ export function isNumber(num: unknown): num is number {
   return typeof num === 'number'
 }
 
+/**
+ * Checks whether the given value is a valid XRPL number string.
+ * Accepts integer, decimal, or scientific notation strings.
+ *
+ * Examples of valid input:
+ *   - "123"
+ *   - "-987.654"
+ *   - "+3.14e10"
+ *   - "-7.2e-9"
+ *
+ * @param value - The value to check.
+ * @returns True if value is a string that matches the XRPL number format, false otherwise.
+ */
+export function isXRPLNumber(value: unknown): value is XRPLNumber {
+  // Matches optional sign, digits, optional decimal, optional exponent (scientific)
+  // Allows leading zeros, but not empty string, lone sign, or missing digits
+  return (
+    typeof value === 'string' &&
+    /^[-+]?(?:\d+(?:\.\d*)?|\.\d+)(?:[eE][-+]?\d+)?$/u.test(value.trim())
+  )
+}
+
+/**
+ * Verify the form and type of a Currency at runtime.
+ *
+ * @param input - The input to check the form and type of.
+ * @returns Whether the Currency is properly formed.
+ */
+export function isCurrency(input: unknown): input is Currency {
+  return isString(input) || isIssuedCurrency(input)
+}
+
 /**
  * Verify the form and type of an IssuedCurrency at runtime.
  *
  * @param input - The input to check the form and type of.
  * @returns Whether the IssuedCurrency is properly formed.
  */
-export function isCurrency(input: unknown): input is Currency {
+export function isIssuedCurrency(input: unknown): input is IssuedCurrency {
   return (
     isRecord(input) &&
     ((Object.keys(input).length === ISSUE_SIZE &&
-      typeof input.issuer === 'string' &&
-      typeof input.currency === 'string') ||
+      isString(input.issuer) &&
+      isString(input.currency)) ||
       (Object.keys(input).length === XRP_CURRENCY_SIZE &&
         input.currency === 'XRP'))
   )
@@ -122,15 +166,15 @@ export function isCurrency(input: unknown): input is Currency {
  * @param input - The input to check the form and type of.
  * @returns Whether the IssuedCurrencyAmount is properly formed.
  */
-export function isIssuedCurrency(
+export function isIssuedCurrencyAmount(
   input: unknown,
 ): input is IssuedCurrencyAmount {
   return (
     isRecord(input) &&
     Object.keys(input).length === ISSUED_CURRENCY_SIZE &&
-    typeof input.value === 'string' &&
-    typeof input.issuer === 'string' &&
-    typeof input.currency === 'string'
+    isString(input.value) &&
+    isString(input.issuer) &&
+    isString(input.currency)
   )
 }
 
@@ -167,11 +211,33 @@ export function isMPTAmount(input: unknown): input is MPTAmount {
   )
 }
 
+/**
+ * Type guard to verify if the input is a valid ClawbackAmount.
+ *
+ * A ClawbackAmount can be either an {@link IssuedCurrencyAmount} or an {@link MPTAmount}.
+ * This function checks if the input matches either type.
+ *
+ * @param input - The value to check for ClawbackAmount structure.
+ * @returns True if the input is an IssuedCurrencyAmount or MPTAmount, otherwise false.
+ */
+export function isClawbackAmount(input: unknown): input is ClawbackAmount {
+  return isIssuedCurrencyAmount(input) || isMPTAmount(input)
+}
+
 /**
  * Must be a valid account address
  */
 export type Account = string
 
+/**
+ * XRPL Number type represented as a string.
+ *
+ * This string can be an integer (e.g., "123"), a decimal (e.g., "123.45"),
+ * or in scientific notation (e.g., "1.23e5", "-4.56e-7").
+ * Used for fields that accept arbitrary-precision numbers in XRPL transactions and ledger objects.
+ */
+export type XRPLNumber = string
+
 /**
  * Verify a string is in fact a valid account address.
  *
@@ -194,7 +260,7 @@ export function isAccount(account: unknown): account is Account {
 export function isAmount(amount: unknown): amount is Amount {
   return (
     typeof amount === 'string' ||
-    isIssuedCurrency(amount) ||
+    isIssuedCurrencyAmount(amount) ||
     isMPTAmount(amount)
   )
 }
@@ -210,9 +276,9 @@ export function isXChainBridge(input: unknown): input is XChainBridge {
     isRecord(input) &&
     Object.keys(input).length === XCHAIN_BRIDGE_SIZE &&
     typeof input.LockingChainDoor === 'string' &&
-    isCurrency(input.LockingChainIssue) &&
+    isIssuedCurrency(input.LockingChainIssue) &&
     typeof input.IssuingChainDoor === 'string' &&
-    isCurrency(input.IssuingChainIssue)
+    isIssuedCurrency(input.IssuingChainIssue)
   )
 }
 
@@ -223,7 +289,7 @@ export function isXChainBridge(input: unknown): input is XChainBridge {
  * @returns Whether the Array is properly formed.
  */
 export function isArray<T = unknown>(input: unknown): input is T[] {
-  return Array.isArray(input)
+  return input != null && Array.isArray(input)
 }
 
 /* eslint-disable @typescript-eslint/restrict-template-expressions -- tx.TransactionType is checked before any calls */
@@ -402,8 +468,14 @@ export interface BaseTransaction extends Record<string, unknown> {
  */
 // eslint-disable-next-line max-statements, max-lines-per-function -- lines required for validation
 export function validateBaseTransaction(
-  common: Record<string, unknown>,
+  common: unknown,
 ): asserts common is BaseTransaction {
+  if (!isRecord(common)) {
+    throw new ValidationError(
+      'BaseTransaction: invalid, expected a valid object',
+    )
+  }
+
   if (common.TransactionType === undefined) {
     throw new ValidationError('BaseTransaction: missing field TransactionType')
   }
@@ -428,18 +500,16 @@ export function validateBaseTransaction(
 
   validateOptionalField(common, 'LastLedgerSequence', isNumber)
 
-  // eslint-disable-next-line @typescript-eslint/consistent-type-assertions -- Only used by JS
-  const memos = common.Memos as Array<{ Memo?: unknown }> | undefined
-  if (memos !== undefined && !memos.every(isMemo)) {
+  const memos = common.Memos
+  if (memos != null && (!isArray(memos) || !memos.every(isMemo))) {
     throw new ValidationError('BaseTransaction: invalid Memos')
   }
 
-  // eslint-disable-next-line @typescript-eslint/consistent-type-assertions -- Only used by JS
-  const signers = common.Signers as Array<Record<string, unknown>> | undefined
+  const signers = common.Signers
 
   if (
-    signers !== undefined &&
-    (signers.length === 0 || !signers.every(isSigner))
+    signers != null &&
+    (!isArray(signers) || signers.length === 0 || !signers.every(isSigner))
   ) {
     throw new ValidationError('BaseTransaction: invalid Signers')
   }
@@ -486,7 +556,9 @@ export function parseAmountValue(amount: unknown): number {
  * @param tx A CredentialType Transaction.
  * @throws when the CredentialType is malformed.
  */
-export function validateCredentialType(tx: Record<string, unknown>): void {
+export function validateCredentialType<
+  T extends BaseTransaction & Record<string, unknown>,
+>(tx: T): void {
   if (typeof tx.TransactionType !== 'string') {
     throw new ValidationError('Invalid TransactionType')
   }
@@ -528,7 +600,7 @@ export function validateCredentialType(tx: Record<string, unknown>): void {
  *        PermissionedDomainSet transaction uses 10, other transactions use 8.
  * @throws Validation Error if the formatting is incorrect
  */
-// eslint-disable-next-line max-lines-per-function, max-params -- separating logic further will add unnecessary complexity
+// eslint-disable-next-line max-params, max-lines-per-function -- separating logic further will add unnecessary complexity
 export function validateCredentialsList(
   credentials: unknown,
   transactionType: string,
@@ -538,7 +610,7 @@ export function validateCredentialsList(
   if (credentials == null) {
     return
   }
-  if (!Array.isArray(credentials)) {
+  if (!isArray(credentials)) {
     throw new ValidationError(
       `${transactionType}: Credentials must be an array`,
     )
@@ -565,7 +637,8 @@ export function validateCredentialsList(
       )
     }
   })
-  if (containsDuplicates(credentials)) {
+  // eslint-disable-next-line @typescript-eslint/consistent-type-assertions -- checked above
+  if (containsDuplicates(credentials as string[] | AuthorizeCredential[])) {
     throw new ValidationError(
       `${transactionType}: Credentials cannot contain duplicate elements`,
     )

package/src/models/transactions/escrowCreate.ts

@@ -47,6 +47,10 @@ export interface EscrowCreate extends BaseTransaction {
    * payment, such as a hosted recipient at the destination address.
    */
   DestinationTag?: number
+
+  FinishFunction?: string
+
+  Data?: string
 }
 
 /**
@@ -75,9 +79,13 @@ export function validateEscrowCreate(tx: Record<string, unknown>): void {
     )
   }
 
-  if (tx.FinishAfter === undefined && tx.Condition === undefined) {
+  if (
+    tx.FinishAfter === undefined &&
+    tx.Condition === undefined &&
+    tx.FinishFunction === undefined
+  ) {
     throw new ValidationError(
-      'EscrowCreate: Either Condition or FinishAfter must be specified',
+      'EscrowCreate: Either FinishAfter, Condition, or FinishFunction must be specified',
     )
   }
 

package/src/models/transactions/escrowFinish.ts

@@ -38,6 +38,8 @@ export interface EscrowFinish extends BaseTransaction {
    * The credentials included must not be expired.
    */
   CredentialIDs?: string[]
+
+  ComputationAllowance?: number
 }
 
 /**

package/src/models/transactions/index.ts

@@ -95,14 +95,25 @@ export {
 } from './paymentChannelClaim'
 export { PaymentChannelCreate } from './paymentChannelCreate'
 export { PaymentChannelFund } from './paymentChannelFund'
+export { PermissionedDomainSet } from './permissionedDomainSet'
+export { PermissionedDomainDelete } from './permissionedDomainDelete'
 export { SetFee, SetFeePreAmendment, SetFeePostAmendment } from './setFee'
 export { SetRegularKey } from './setRegularKey'
 export { SignerListSet } from './signerListSet'
 export { TicketCreate } from './ticketCreate'
 export { TrustSetFlagsInterface, TrustSetFlags, TrustSet } from './trustSet'
 export { UNLModify } from './UNLModify'
-export { PermissionedDomainSet } from './permissionedDomainSet'
-export { PermissionedDomainDelete } from './permissionedDomainDelete'
+export { VaultClawback } from './vaultClawback'
+export {
+  VaultCreate,
+  VaultCreateFlags,
+  VaultCreateFlagsInterface,
+  VaultWithdrawalPolicy,
+} from './vaultCreate'
+export { VaultDelete } from './vaultDelete'
+export { VaultDeposit } from './vaultDeposit'
+export { VaultSet } from './vaultSet'
+export { VaultWithdraw } from './vaultWithdraw'
 export { XChainAddAccountCreateAttestation } from './XChainAddAccountCreateAttestation'
 export { XChainAddClaimAttestation } from './XChainAddClaimAttestation'
 export { XChainClaim } from './XChainClaim'

package/src/models/transactions/oracleSet.ts

@@ -4,7 +4,9 @@ import { isHex } from '../utils'
 
 import {
   BaseTransaction,
+  isArray,
   isNumber,
+  isRecord,
   isString,
   validateBaseTransaction,
   validateOptionalField,
@@ -90,7 +92,7 @@ export function validateOracleSet(tx: Record<string, unknown>): void {
     tx,
     'PriceDataSeries',
     (value: unknown): value is PriceData => {
-      if (!Array.isArray(value)) {
+      if (!isArray(value)) {
         throw new ValidationError('OracleSet: PriceDataSeries must be an array')
       }
 
@@ -102,14 +104,15 @@ export function validateOracleSet(tx: Record<string, unknown>): void {
 
       // TODO: add support for handling inner objects easier (similar to validateRequiredField/validateOptionalField)
       for (const priceData of value) {
-        if (typeof priceData !== 'object') {
+        if (!isRecord(priceData)) {
           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 (priceData.PriceData == null) {
+        const priceDataInner = priceData.PriceData
+
+        if (!isRecord(priceDataInner)) {
           throw new ValidationError(
             'OracleSet: PriceDataSeries must have a `PriceData` object',
           )
@@ -122,15 +125,16 @@ export function validateOracleSet(tx: Record<string, unknown>): void {
           )
         }
 
-        // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access -- we are validating the type
-        if (typeof priceData.PriceData.BaseAsset !== 'string') {
+        if (
+          priceDataInner.BaseAsset == null ||
+          typeof priceDataInner.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 (typeof priceData.PriceData.QuoteAsset !== 'string') {
+        if (typeof priceDataInner.QuoteAsset !== 'string') {
           throw new ValidationError(
             'OracleSet: PriceDataSeries must have a `QuoteAsset` string',
           )
@@ -138,34 +142,31 @@ export function validateOracleSet(tx: Record<string, unknown>): void {
 
         // 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)
+          (priceDataInner.AssetPrice == null) !==
+          (priceDataInner.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 --
-      we need to validate priceData.PriceData.AssetPrice value */
-        if ('AssetPrice' in priceData.PriceData) {
-          if (!isNumber(priceData.PriceData.AssetPrice)) {
-            if (typeof priceData.PriceData.AssetPrice !== 'string') {
+        /* eslint-disable max-depth --
+      we need to validate priceDataInner.AssetPrice value */
+        if ('AssetPrice' in priceDataInner) {
+          if (!isNumber(priceDataInner.AssetPrice)) {
+            if (typeof priceDataInner.AssetPrice !== 'string') {
               throw new ValidationError(
                 'OracleSet: Field AssetPrice must be a string or a number',
               )
             }
-            if (!isHex(priceData.PriceData.AssetPrice)) {
+            if (!isHex(priceDataInner.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
+              priceDataInner.AssetPrice.length < MINIMUM_ASSET_PRICE_LENGTH ||
+              priceDataInner.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`,
@@ -173,26 +174,18 @@ export function validateOracleSet(tx: Record<string, unknown>): void {
             }
           }
         }
-        /* 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 ('Scale' in priceDataInner) {
+          if (!isNumber(priceDataInner.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 (priceDataInner.Scale < 0 || priceDataInner.Scale > SCALE_MAX) {
+            throw new ValidationError(
+              `OracleSet: Scale must be in range 0-${SCALE_MAX}`,
+            )
+          }
+          /* eslint-enable max-depth */
         }
       }
       return true

package/src/models/transactions/payment.ts

@@ -14,6 +14,7 @@ import {
   Account,
   validateCredentialsList,
   MAX_AUTHORIZED_CREDENTIALS,
+  isArray,
 } from './common'
 import type { TransactionMetadataBase } from './metadata'
 
@@ -119,6 +120,9 @@ export interface Payment extends BaseTransaction {
    * to this amount instead.
    */
   Amount: Amount | MPTAmount
+
+  DeliverMax?: Amount | MPTAmount
+
   /** The unique address of the account receiving the payment. */
   Destination: Account
   /**
@@ -195,11 +199,7 @@ export function validatePayment(tx: Record<string, unknown>): void {
     throw new ValidationError('PaymentTransaction: InvoiceID must be a string')
   }
 
-  if (
-    tx.Paths !== undefined &&
-    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions -- Only used by JS
-    !isPaths(tx.Paths as Array<Array<Record<string, unknown>>>)
-  ) {
+  if (tx.Paths !== undefined && !isPaths(tx.Paths)) {
     throw new ValidationError('PaymentTransaction: invalid Paths')
   }
 
@@ -208,6 +208,12 @@ export function validatePayment(tx: Record<string, unknown>): void {
   }
 
   checkPartialPayment(tx)
+
+  if (tx.DeliverMax != null) {
+    throw new ValidationError(
+      'PaymentTransaction: Cannot have DeliverMax in a submitted transaction',
+    )
+  }
 }
 
 function checkPartialPayment(tx: Record<string, unknown>): void {
@@ -276,12 +282,12 @@ function isPath(path: unknown): path is Path {
 }
 
 function isPaths(paths: unknown): paths is Path[] {
-  if (!Array.isArray(paths) || paths.length === 0) {
+  if (!isArray(paths) || paths.length === 0) {
     return false
   }
 
   for (const path of paths) {
-    if (!Array.isArray(path) || path.length === 0) {
+    if (!isArray(path) || path.length === 0) {
       return false
     }
 

package/src/models/transactions/signerListSet.ts

@@ -1,7 +1,15 @@
 import { ValidationError } from '../../errors'
 import { SignerEntry } from '../common'
 
-import { BaseTransaction, isArray, validateBaseTransaction } from './common'
+import {
+  BaseTransaction,
+  isArray,
+  isNumber,
+  isRecord,
+  isString,
+  validateBaseTransaction,
+  validateRequiredField,
+} from './common'
 
 /**
  * The SignerListSet transaction creates, replaces, or removes a list of
@@ -39,27 +47,14 @@ const HEX_WALLET_LOCATOR_REGEX = /^[0-9A-Fa-f]{64}$/u
 export function validateSignerListSet(tx: Record<string, unknown>): void {
   validateBaseTransaction(tx)
 
-  if (tx.SignerQuorum === undefined) {
-    throw new ValidationError('SignerListSet: missing field SignerQuorum')
-  }
-
-  if (typeof tx.SignerQuorum !== 'number') {
-    throw new ValidationError('SignerListSet: invalid SignerQuorum')
-  }
+  validateRequiredField(tx, 'SignerQuorum', isNumber)
 
   // All other checks are for if SignerQuorum is greater than 0
   if (tx.SignerQuorum === 0) {
     return
   }
 
-  if (tx.SignerEntries === undefined) {
-    throw new ValidationError('SignerListSet: missing field SignerEntries')
-  }
-
-  if (!isArray(tx.SignerEntries)) {
-    throw new ValidationError('SignerListSet: invalid SignerEntries')
-  }
-
+  validateRequiredField(tx, 'SignerEntries', isArray)
   if (tx.SignerEntries.length === 0) {
     throw new ValidationError(
       'SignerListSet: need at least 1 member in SignerEntries',
@@ -73,12 +68,17 @@ export function validateSignerListSet(tx: Record<string, unknown>): void {
   }
 
   for (const entry of tx.SignerEntries) {
-    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions -- Should be a SignerEntry
-    const signerEntry = entry as SignerEntry
-    const { WalletLocator } = signerEntry.SignerEntry
+    if (!isRecord(entry) || !isRecord(entry.SignerEntry)) {
+      throw new ValidationError(
+        'SignerListSet: SignerEntries must be an array of SignerEntry objects',
+      )
+    }
+    const signerEntry = entry.SignerEntry
+    const { WalletLocator } = signerEntry
     if (
-      WalletLocator !== undefined &&
-      !HEX_WALLET_LOCATOR_REGEX.test(WalletLocator)
+      WalletLocator != null &&
+      (!isString(WalletLocator) ||
+        !HEX_WALLET_LOCATOR_REGEX.test(WalletLocator))
     ) {
       throw new ValidationError(
         `SignerListSet: WalletLocator in SignerEntry must be a 256-bit (32-byte) hexadecimal value`,