xrpl 4.3.0-smartescrow.3 → 4.3.0

package/src/models/methods/serverInfo.ts

@@ -85,11 +85,6 @@ export interface ServerInfoResponse extends BaseResponse {
         hash: string
         reserve_base_xrp: number
         reserve_inc_xrp: number
-
-        extension_compute: number
-        extension_size: number
-        gas_price: number
-
         seq: number
       }
       /**
@@ -257,10 +252,6 @@ export interface ServerInfoResponse extends BaseResponse {
          * object an account owns in the ledger.
          */
         reserve_inc_xrp: number
-
-        extension_compute: number
-        extension_size: number
-        gas_price: number
         /** The ledger index of the latest validated ledger. */
         seq: number
       }

package/src/models/methods/serverState.ts

@@ -30,11 +30,6 @@ export interface ServerStateResponse extends BaseResponse {
         hash: string
         reserve_base: number
         reserve_inc: number
-
-        extension_compute: number
-        extension_size: number
-        gas_price: number
-
         seq: number
       }
       io_latency_ms: number
@@ -74,11 +69,6 @@ export interface ServerStateResponse extends BaseResponse {
         hash: string
         reserve_base: number
         reserve_inc: number
-
-        extension_compute: number
-        extension_size: number
-        gas_price: number
-
         seq: number
       }
       validation_quorum: number

package/src/models/transactions/AMMBid.ts

@@ -97,8 +97,7 @@ export function validateAMMBid(tx: Record<string, unknown>): void {
       )
     }
     validateAuthAccounts(
-      // eslint-disable-next-line @typescript-eslint/consistent-type-assertions -- Only used by JS
-      tx.Account as string,
+      tx.Account,
       // eslint-disable-next-line @typescript-eslint/consistent-type-assertions -- Only used by JS
       tx.AuthAccounts as Array<Record<string, unknown>>,
     )

package/src/models/transactions/AMMClawback.ts

@@ -4,7 +4,7 @@ import { Currency, IssuedCurrency, IssuedCurrencyAmount } from '../common'
 import {
   Account,
   BaseTransaction,
-  GlobalFlags,
+  GlobalFlagsInterface,
   isAccount,
   isAmount,
   isCurrency,
@@ -28,7 +28,7 @@ export enum AMMClawbackFlags {
  *
  * @category Transaction Flags
  */
-export interface AMMClawbackFlagsInterface extends GlobalFlags {
+export interface AMMClawbackFlagsInterface extends GlobalFlagsInterface {
   tfClawTwoAssets?: boolean
 }
 

package/src/models/transactions/AMMDeposit.ts

@@ -3,7 +3,7 @@ import { Amount, Currency, IssuedCurrencyAmount } from '../common'
 
 import {
   BaseTransaction,
-  GlobalFlags,
+  GlobalFlagsInterface,
   isAmount,
   isCurrency,
   isIssuedCurrency,
@@ -24,7 +24,7 @@ export enum AMMDepositFlags {
   tfTwoAssetIfEmpty = 0x00800000,
 }
 
-export interface AMMDepositFlagsInterface extends GlobalFlags {
+export interface AMMDepositFlagsInterface extends GlobalFlagsInterface {
   tfLPToken?: boolean
   tfSingleAsset?: boolean
   tfTwoAsset?: boolean

package/src/models/transactions/AMMWithdraw.ts

@@ -3,7 +3,7 @@ import { Amount, Currency, IssuedCurrencyAmount } from '../common'
 
 import {
   BaseTransaction,
-  GlobalFlags,
+  GlobalFlagsInterface,
   isAmount,
   isCurrency,
   isIssuedCurrency,
@@ -25,7 +25,7 @@ export enum AMMWithdrawFlags {
   tfLimitLPToken = 0x00400000,
 }
 
-export interface AMMWithdrawFlagsInterface extends GlobalFlags {
+export interface AMMWithdrawFlagsInterface extends GlobalFlagsInterface {
   tfLPToken?: boolean
   tfWithdrawAll?: boolean
   tfOneAssetWithdrawAll?: boolean

package/src/models/transactions/MPTokenAuthorize.ts

@@ -6,7 +6,7 @@ import {
   Account,
   validateOptionalField,
   isAccount,
-  GlobalFlags,
+  GlobalFlagsInterface,
 } from './common'
 
 /**
@@ -32,7 +32,7 @@ export enum MPTokenAuthorizeFlags {
  *
  * @category Transaction Flags
  */
-export interface MPTokenAuthorizeFlagsInterface extends GlobalFlags {
+export interface MPTokenAuthorizeFlagsInterface extends GlobalFlagsInterface {
   tfMPTUnauthorize?: boolean
 }
 

package/src/models/transactions/MPTokenIssuanceCreate.ts

@@ -3,7 +3,7 @@ import { isHex, INTEGER_SANITY_CHECK, isFlagEnabled } from '../utils'
 
 import {
   BaseTransaction,
-  GlobalFlags,
+  GlobalFlagsInterface,
   validateBaseTransaction,
   validateOptionalField,
   isString,
@@ -58,7 +58,8 @@ export enum MPTokenIssuanceCreateFlags {
  *
  * @category Transaction Flags
  */
-export interface MPTokenIssuanceCreateFlagsInterface extends GlobalFlags {
+export interface MPTokenIssuanceCreateFlagsInterface
+  extends GlobalFlagsInterface {
   tfMPTCanLock?: boolean
   tfMPTRequireAuth?: boolean
   tfMPTCanEscrow?: boolean

package/src/models/transactions/MPTokenIssuanceSet.ts

@@ -9,7 +9,7 @@ import {
   Account,
   validateOptionalField,
   isAccount,
-  GlobalFlags,
+  GlobalFlagsInterface,
 } from './common'
 
 /**
@@ -34,7 +34,7 @@ export enum MPTokenIssuanceSetFlags {
  *
  * @category Transaction Flags
  */
-export interface MPTokenIssuanceSetFlagsInterface extends GlobalFlags {
+export interface MPTokenIssuanceSetFlagsInterface extends GlobalFlagsInterface {
   tfMPTLock?: boolean
   tfMPTUnlock?: boolean
 }

package/src/models/transactions/NFTokenCreateOffer.ts

@@ -4,7 +4,7 @@ import { isFlagEnabled } from '../utils'
 
 import {
   BaseTransaction,
-  GlobalFlags,
+  GlobalFlagsInterface,
   validateBaseTransaction,
   isAmount,
   parseAmountValue,
@@ -33,7 +33,7 @@ export enum NFTokenCreateOfferFlags {
  *
  * @category Transaction Flags
  */
-export interface NFTokenCreateOfferFlagsInterface extends GlobalFlags {
+export interface NFTokenCreateOfferFlagsInterface extends GlobalFlagsInterface {
   tfSellNFToken?: boolean
 }
 

package/src/models/transactions/NFTokenMint.ts

@@ -5,7 +5,7 @@ import { isHex } from '../utils'
 import {
   Account,
   BaseTransaction,
-  GlobalFlags,
+  GlobalFlagsInterface,
   isAccount,
   isAmount,
   isNumber,
@@ -53,7 +53,7 @@ export enum NFTokenMintFlags {
  *
  * @category Transaction Flags
  */
-export interface NFTokenMintFlagsInterface extends GlobalFlags {
+export interface NFTokenMintFlagsInterface extends GlobalFlagsInterface {
   tfBurnable?: boolean
   tfOnlyXRP?: boolean
   tfTrustLine?: boolean

package/src/models/transactions/XChainAddAccountCreateAttestation.ts

@@ -110,13 +110,13 @@ export function validateXChainAddAccountCreateAttestation(
   validateRequiredField(
     tx,
     'WasLockingChainSend',
-    (inp) => inp === 0 || inp === 1,
+    (inp: unknown): inp is 0 | 1 => inp === 0 || inp === 1,
   )
 
   validateRequiredField(
     tx,
     'XChainAccountCreateCount',
-    (inp) => isNumber(inp) || isString(inp),
+    (inp: unknown): inp is number | string => isNumber(inp) || isString(inp),
   )
 
   validateRequiredField(tx, 'XChainBridge', isXChainBridge)

package/src/models/transactions/XChainAddClaimAttestation.ts

@@ -104,7 +104,7 @@ export function validateXChainAddClaimAttestation(
   validateRequiredField(
     tx,
     'WasLockingChainSend',
-    (inp) => inp === 0 || inp === 1,
+    (inp: unknown): inp is 0 | 1 => inp === 0 || inp === 1,
   )
 
   validateRequiredField(tx, 'XChainBridge', isXChainBridge)
@@ -112,6 +112,6 @@ export function validateXChainAddClaimAttestation(
   validateRequiredField(
     tx,
     'XChainClaimID',
-    (inp) => isNumber(inp) || isString(inp),
+    (inp: unknown): inp is number | string => isNumber(inp) || isString(inp),
   )
 }

package/src/models/transactions/XChainClaim.ts

@@ -68,7 +68,7 @@ export function validateXChainClaim(tx: Record<string, unknown>): void {
   validateRequiredField(
     tx,
     'XChainClaimID',
-    (inp) => isNumber(inp) || isString(inp),
+    (inp: unknown): inp is number | string => isNumber(inp) || isString(inp),
   )
 
   validateRequiredField(tx, 'Destination', isAccount)

package/src/models/transactions/XChainCommit.ts

@@ -67,7 +67,7 @@ export function validateXChainCommit(tx: Record<string, unknown>): void {
   validateRequiredField(
     tx,
     'XChainClaimID',
-    (inp) => isNumber(inp) || isString(inp),
+    (inp: unknown): inp is number | string => isNumber(inp) || isString(inp),
   )
 
   validateOptionalField(tx, 'OtherChainDestination', isAccount)

package/src/models/transactions/XChainModifyBridge.ts

@@ -2,7 +2,7 @@ import { Amount, XChainBridge } from '../common'
 
 import {
   BaseTransaction,
-  GlobalFlags,
+  GlobalFlagsInterface,
   isAmount,
   isXChainBridge,
   validateBaseTransaction,
@@ -26,7 +26,7 @@ export enum XChainModifyBridgeFlags {
  *
  * @category Transaction Flags
  */
-export interface XChainModifyBridgeFlagsInterface extends GlobalFlags {
+export interface XChainModifyBridgeFlagsInterface extends GlobalFlagsInterface {
   /** Clears the MinAccountCreateAmount of the bridge. */
   tfClearAccountCreateAmount?: boolean
 }

package/src/models/transactions/accountDelete.ts

@@ -52,8 +52,7 @@ export function validateAccountDelete(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/accountSet.ts

@@ -3,6 +3,7 @@ import { ValidationError } from '../../errors'
 import {
   Account,
   BaseTransaction,
+  GlobalFlagsInterface,
   isAccount,
   validateBaseTransaction,
   validateOptionalField,
@@ -112,7 +113,7 @@ export enum AccountSetTfFlags {
  * // }
  * ```
  */
-export interface AccountSetFlagsInterface {
+export interface AccountSetFlagsInterface extends GlobalFlagsInterface {
   tfRequireDestTag?: boolean
   tfOptionalDestTag?: boolean
   tfRequireAuth?: boolean

package/src/models/transactions/batch.ts

@@ -0,0 +1,151 @@
+import { ValidationError } from '../../errors'
+import { Signer } from '../common'
+import { hasFlag } from '../utils'
+
+import {
+  BaseTransaction,
+  GlobalFlags,
+  GlobalFlagsInterface,
+  isArray,
+  isRecord,
+  isString,
+  validateBaseTransaction,
+  validateOptionalField,
+  validateRequiredField,
+} from './common'
+import type { SubmittableTransaction } from './transaction'
+
+/**
+ * Enum representing values of {@link Batch} transaction flags.
+ *
+ * @category Transaction Flags
+ */
+export enum BatchFlags {
+  tfAllOrNothing = 0x00010000,
+  tfOnlyOne = 0x00020000,
+  tfUntilFailure = 0x00040000,
+  tfIndependent = 0x00080000,
+}
+
+/**
+ * Map of flags to boolean values representing {@link Batch} transaction
+ * flags.
+ *
+ * @category Transaction Flags
+ */
+export interface BatchFlagsInterface extends GlobalFlagsInterface {
+  tfAllOrNothing?: boolean
+  tfOnlyOne?: boolean
+  tfUntilFailure?: boolean
+  tfIndependent?: boolean
+}
+
+export type BatchInnerTransaction = SubmittableTransaction & {
+  Fee?: '0'
+
+  SigningPubKey?: ''
+
+  TxnSignature?: never
+
+  Signers?: never
+
+  LastLedgerSequence?: never
+}
+
+export interface BatchSigner {
+  BatchSigner: {
+    Account: string
+
+    SigningPubKey?: string
+
+    TxnSignature?: string
+
+    Signers?: Signer[]
+  }
+}
+
+/**
+ * @category Transaction Models
+ */
+export interface Batch extends BaseTransaction {
+  TransactionType: 'Batch'
+
+  BatchSigners?: BatchSigner[]
+
+  RawTransactions: Array<{
+    RawTransaction: BatchInnerTransaction
+  }>
+}
+
+/**
+ * Verify the form and type of a Batch at runtime.
+ *
+ * @param tx - A Batch Transaction.
+ * @throws When the Batch is malformed.
+ */
+// eslint-disable-next-line max-lines-per-function -- needed here due to the complexity
+export function validateBatch(tx: Record<string, unknown>): void {
+  validateBaseTransaction(tx)
+
+  validateRequiredField(tx, 'RawTransactions', isArray)
+
+  tx.RawTransactions.forEach((rawTxObj, index) => {
+    if (!isRecord(rawTxObj)) {
+      throw new ValidationError(
+        `Batch: RawTransactions[${index}] is not object.`,
+      )
+    }
+    validateRequiredField(rawTxObj, 'RawTransaction', isRecord, {
+      paramName: `RawTransactions[${index}].RawTransaction`,
+      txType: 'Batch',
+    })
+
+    const rawTx = rawTxObj.RawTransaction
+    if (rawTx.TransactionType === 'Batch') {
+      throw new ValidationError(
+        `Batch: RawTransactions[${index}] is a Batch transaction. Cannot nest Batch transactions.`,
+      )
+    }
+
+    // Check for the `tfInnerBatchTxn` flag in the inner transactions
+    if (!hasFlag(rawTx, GlobalFlags.tfInnerBatchTxn, 'tfInnerBatchTxn')) {
+      throw new ValidationError(
+        `Batch: RawTransactions[${index}] must contain the \`tfInnerBatchTxn\` flag.`,
+      )
+    }
+
+    // Full validation of each `RawTransaction` object is done in `validate` to avoid dependency cycles
+  })
+
+  validateOptionalField(tx, 'BatchSigners', isArray)
+
+  tx.BatchSigners?.forEach((signerObj, index) => {
+    if (!isRecord(signerObj)) {
+      throw new ValidationError(`Batch: BatchSigners[${index}] is not object.`)
+    }
+
+    const signerRecord = signerObj
+    validateRequiredField(signerRecord, 'BatchSigner', isRecord, {
+      paramName: `BatchSigners[${index}].BatchSigner`,
+      txType: 'Batch',
+    })
+
+    const signer = signerRecord.BatchSigner
+    validateRequiredField(signer, 'Account', isString, {
+      paramName: `BatchSigners[${index}].Account`,
+      txType: 'Batch',
+    })
+    validateOptionalField(signer, 'SigningPubKey', isString, {
+      paramName: `BatchSigners[${index}].SigningPubKey`,
+      txType: 'Batch',
+    })
+    validateOptionalField(signer, 'TxnSignature', isString, {
+      paramName: `BatchSigners[${index}].TxnSignature`,
+      txType: 'Batch',
+    })
+    validateOptionalField(signer, 'Signers', isArray, {
+      paramName: `BatchSigners[${index}].Signers`,
+      txType: 'Batch',
+    })
+  })
+}

package/src/models/transactions/common.ts

@@ -69,7 +69,13 @@ const XCHAIN_BRIDGE_SIZE = 4
 const MPTOKEN_SIZE = 2
 const AUTHORIZE_CREDENTIAL_SIZE = 1
 
-function isRecord(value: unknown): value is Record<string, unknown> {
+/**
+ * Verify the form and type of a Record/Object at runtime.
+ *
+ * @param value - The object to check the form and type of.
+ * @returns Whether the Record/Object is properly formed.
+ */
+export function isRecord(value: unknown): value is Record<string, unknown> {
   return value !== null && typeof value === 'object'
 }
 
@@ -210,30 +216,54 @@ export function isXChainBridge(input: unknown): input is XChainBridge {
   )
 }
 
+/**
+ * Verify the form and type of an Array at runtime.
+ *
+ * @param input - The object to check the form and type of.
+ * @returns Whether the Array is properly formed.
+ */
+export function isArray<T = unknown>(input: unknown): input is T[] {
+  return Array.isArray(input)
+}
+
 /* eslint-disable @typescript-eslint/restrict-template-expressions -- tx.TransactionType is checked before any calls */
 
 /**
  * Verify the form and type of a required type for a transaction at runtime.
  *
- * @param tx - The transaction input to check the form and type of.
- * @param paramName - The name of the transaction parameter.
+ * @param tx - The object input to check the form and type of.
+ * @param param - The object parameter.
  * @param checkValidity - The function to use to check the type.
- * @throws
+ * @param errorOpts - Extra values to make the error message easier to understand.
+ * @param errorOpts.txType - The transaction type throwing the error.
+ * @param errorOpts.paramName - The name of the parameter in the transaction with the error.
+ * @throws ValidationError if the parameter is missing or invalid.
  */
-export function validateRequiredField(
-  tx: Record<string, unknown>,
-  paramName: string,
-  checkValidity: (inp: unknown) => boolean,
-): void {
-  if (tx[paramName] == null) {
+// eslint-disable-next-line max-params -- helper function
+export function validateRequiredField<
+  T extends Record<string, unknown>,
+  K extends keyof T,
+  V,
+>(
+  tx: T,
+  param: K,
+  checkValidity: (inp: unknown) => inp is V,
+  errorOpts: {
+    txType?: string
+    paramName?: string
+  } = {},
+): asserts tx is T & { [P in K]: V } {
+  const paramNameStr = errorOpts.paramName ?? param
+  const txType = errorOpts.txType ?? tx.TransactionType
+  if (tx[param] == null) {
     throw new ValidationError(
-      `${tx.TransactionType}: missing field ${paramName}`,
+      `${txType}: missing field ${String(paramNameStr)}`,
     )
   }
 
-  if (!checkValidity(tx[paramName])) {
+  if (!checkValidity(tx[param])) {
     throw new ValidationError(
-      `${tx.TransactionType}: invalid field ${paramName}`,
+      `${txType}: invalid field ${String(paramNameStr)}`,
     )
   }
 }
@@ -242,31 +272,50 @@ export function validateRequiredField(
  * Verify the form and type of an optional type for a transaction at runtime.
  *
  * @param tx - The transaction input to check the form and type of.
- * @param paramName - The name of the transaction parameter.
+ * @param param - The object parameter.
  * @param checkValidity - The function to use to check the type.
- * @throws
+ * @param errorOpts - Extra values to make the error message easier to understand.
+ * @param errorOpts.txType - The transaction type throwing the error.
+ * @param errorOpts.paramName - The name of the parameter in the transaction with the error.
+ * @throws ValidationError if the parameter is invalid.
  */
-export function validateOptionalField(
-  tx: Record<string, unknown>,
-  paramName: string,
-  checkValidity: (inp: unknown) => boolean,
-): void {
-  if (tx[paramName] !== undefined && !checkValidity(tx[paramName])) {
+// eslint-disable-next-line max-params -- helper function
+export function validateOptionalField<
+  T extends Record<string, unknown>,
+  K extends keyof T,
+  V,
+>(
+  tx: T,
+  param: K,
+  checkValidity: (inp: unknown) => inp is V,
+  errorOpts: {
+    txType?: string
+    paramName?: string
+  } = {},
+): asserts tx is T & { [P in K]: V | undefined } {
+  const paramNameStr = errorOpts.paramName ?? param
+  const txType = errorOpts.txType ?? tx.TransactionType
+  if (tx[param] !== undefined && !checkValidity(tx[param])) {
     throw new ValidationError(
-      `${tx.TransactionType}: invalid field ${paramName}`,
+      `${txType}: invalid field ${String(paramNameStr)}`,
     )
   }
 }
 
 /* eslint-enable @typescript-eslint/restrict-template-expressions -- checked before */
 
-// eslint-disable-next-line @typescript-eslint/no-empty-interface -- no global flags right now, so this is fine
-export interface GlobalFlags {}
+export enum GlobalFlags {
+  tfInnerBatchTxn = 0x40000000,
+}
+
+export interface GlobalFlagsInterface {
+  tfInnerBatchTxn?: boolean
+}
 
 /**
  * Every transaction has the same set of common fields.
  */
-export interface BaseTransaction {
+export interface BaseTransaction extends Record<string, unknown> {
   /** The unique address of the transaction sender. */
   Account: Account
   /**
@@ -294,7 +343,7 @@ export interface BaseTransaction {
    */
   AccountTxnID?: string
   /** Set of bit-flags for this transaction. */
-  Flags?: number | GlobalFlags
+  Flags?: number | GlobalFlagsInterface
   /**
    * Highest ledger index this transaction can appear in. Specifying this field
    * places a strict upper limit on how long the transaction can wait to be
@@ -351,8 +400,10 @@ export interface BaseTransaction {
  * @param common - An interface w/ common transaction fields.
  * @throws When the common param is malformed.
  */
-// eslint-disable-next-line max-statements -- lines required for validation
-export function validateBaseTransaction(common: Record<string, unknown>): void {
+// eslint-disable-next-line max-statements, max-lines-per-function -- lines required for validation
+export function validateBaseTransaction(
+  common: Record<string, unknown>,
+): asserts common is BaseTransaction {
   if (common.TransactionType === undefined) {
     throw new ValidationError('BaseTransaction: missing field TransactionType')
   }
@@ -362,7 +413,9 @@ export function validateBaseTransaction(common: Record<string, unknown>): void {
   }
 
   if (!TRANSACTION_TYPES.includes(common.TransactionType)) {
-    throw new ValidationError('BaseTransaction: Unknown TransactionType')
+    throw new ValidationError(
+      `BaseTransaction: Unknown TransactionType ${common.TransactionType}`,
+    )
   }
 
   validateRequiredField(common, 'Account', isString)
@@ -548,7 +601,6 @@ export function containsDuplicates(
   if (isAuthorizeCredentialArray(objectList)) {
     for (const item of objectList) {
       const key = `${item.Credential.Issuer}-${item.Credential.CredentialType}`
-      // eslint-disable-next-line max-depth -- necessary to check for type-guards
       if (seen.has(key)) {
         return true
       }

package/src/models/transactions/delegateSet.ts

@@ -15,6 +15,7 @@ const NON_DELEGATABLE_TRANSACTIONS = new Set([
   'SignerListSet',
   'DelegateSet',
   'AccountDelete',
+  'Batch',
   // Pseudo transactions below:
   'EnableAmendment',
   'SetFee',

package/src/models/transactions/depositPreauth.ts

@@ -70,16 +70,14 @@ export function validateDepositPreauth(tx: Record<string, unknown>): void {
   } else if (tx.AuthorizeCredentials !== undefined) {
     validateCredentialsList(
       tx.AuthorizeCredentials,
-      // eslint-disable-next-line @typescript-eslint/consistent-type-assertions -- confirmed in base transaction check
-      tx.TransactionType as string,
+      tx.TransactionType,
       false,
       MAX_AUTHORIZED_CREDENTIALS,
     )
   } else if (tx.UnauthorizeCredentials !== undefined) {
     validateCredentialsList(
       tx.UnauthorizeCredentials,
-      // eslint-disable-next-line @typescript-eslint/consistent-type-assertions -- confirmed in base transaction check
-      tx.TransactionType as string,
+      tx.TransactionType,
       false,
       MAX_AUTHORIZED_CREDENTIALS,
     )