xrpl 4.3.0-smartescrow.3 → 4.3.0

package/src/Wallet/batchSigner.ts

@@ -0,0 +1,198 @@
+import { encode, encodeForSigningBatch } from 'ripple-binary-codec'
+import { sign } from 'ripple-keypairs'
+
+import { ValidationError } from '../errors'
+import { Batch, Transaction, validate } from '../models'
+import { BatchSigner, validateBatch } from '../models/transactions/batch'
+import { hashSignedTx } from '../utils/hashes'
+
+import { compareSigners, getDecodedTransaction } from './utils'
+
+import { Wallet } from '.'
+
+// eslint-disable-next-line max-params -- okay for helper function
+function constructBatchSignerObject(
+  batchAccount: string,
+  wallet: Wallet,
+  signature: string,
+  multisignAddress: string | false = false,
+): BatchSigner {
+  let batchSigner: BatchSigner
+  if (multisignAddress) {
+    batchSigner = {
+      BatchSigner: {
+        Account: batchAccount,
+        Signers: [
+          {
+            Signer: {
+              Account: multisignAddress,
+              SigningPubKey: wallet.publicKey,
+              TxnSignature: signature,
+            },
+          },
+        ],
+      },
+    }
+  } else {
+    batchSigner = {
+      BatchSigner: {
+        Account: batchAccount,
+        SigningPubKey: wallet.publicKey,
+        TxnSignature: signature,
+      },
+    }
+  }
+  return batchSigner
+}
+
+/**
+ * Sign a multi-account Batch transaction.
+ *
+ * @param wallet - Wallet instance.
+ * @param transaction - The Batch transaction to sign.
+ * @param opts - Additional options for regular key and multi-signing complexity.
+ * @param opts.batchAccount - The account submitting the inner Batch transaction, on behalf of which is this signature.
+ * @param opts.multisign - Specify true/false to use multisign or actual address (classic/x-address) to make multisign tx request.
+ *                       The actual address is only needed in the case of regular key usage.
+ * @throws ValidationError if the transaction is malformed.
+ */
+export function signMultiBatch(
+  wallet: Wallet,
+  transaction: Batch,
+  opts: { batchAccount?: string; multisign?: boolean | string } = {},
+): void {
+  const batchAccount = opts.batchAccount ?? wallet.classicAddress
+  let multisignAddress: boolean | string = false
+  if (typeof opts.multisign === 'string') {
+    multisignAddress = opts.multisign
+  } else if (opts.multisign) {
+    multisignAddress = wallet.classicAddress
+  }
+
+  // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition -- for JS purposes
+  if (transaction.TransactionType !== 'Batch') {
+    throw new ValidationError('Must be a Batch transaction.')
+  }
+  /*
+   * This will throw a more clear error for JS users if the supplied transaction has incorrect formatting
+   */
+  // eslint-disable-next-line @typescript-eslint/consistent-type-assertions -- validate does not accept Transaction type
+  validate(transaction as unknown as Record<string, unknown>)
+
+  const involvedAccounts = new Set(
+    transaction.RawTransactions.map((raw) => raw.RawTransaction.Account),
+  )
+  if (!involvedAccounts.has(batchAccount)) {
+    throw new ValidationError(
+      'Must be signing for an address submitting a transaction in the Batch.',
+    )
+  }
+  const fieldsToSign = {
+    flags: transaction.Flags,
+    txIDs: transaction.RawTransactions.map((rawTx) =>
+      hashSignedTx(rawTx.RawTransaction),
+    ),
+  }
+  const signature = sign(encodeForSigningBatch(fieldsToSign), wallet.privateKey)
+
+  // eslint-disable-next-line no-param-reassign -- okay for signing
+  transaction.BatchSigners = [
+    constructBatchSignerObject(
+      batchAccount,
+      wallet,
+      signature,
+      multisignAddress,
+    ),
+  ]
+}
+
+/**
+ * Takes several transactions with BatchSigners fields (in object or blob form) and creates a
+ * single transaction with all BatchSigners that then gets signed and returned.
+ *
+ * @param transactions The transactions to combine `BatchSigners` values on.
+ * @returns A single signed Transaction which has all BatchSigners from transactions within it.
+ * @throws ValidationError if:
+ * - There were no transactions given to sign
+ * @category Signing
+ */
+export function combineBatchSigners(
+  transactions: Array<Batch | string>,
+): string {
+  if (transactions.length === 0) {
+    throw new ValidationError('There are 0 transactions to combine.')
+  }
+
+  const decodedTransactions: Transaction[] = transactions.map((txOrBlob) => {
+    return getDecodedTransaction(txOrBlob)
+  })
+
+  decodedTransactions.forEach((tx) => {
+    if (tx.TransactionType !== 'Batch') {
+      throw new ValidationError('TransactionType must be `Batch`.')
+    }
+    /*
+     * This will throw a more clear error for JS users if any of the supplied transactions has incorrect formatting
+     */
+    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions -- validate does not accept Transaction type
+    validateBatch(tx as unknown as Record<string, unknown>)
+    if (tx.BatchSigners == null || tx.BatchSigners.length === 0) {
+      throw new ValidationError(
+        'For combining Batch transaction signatures, all transactions must include a BatchSigners field containing an array of signatures.',
+      )
+    }
+
+    if (tx.TxnSignature != null || tx.Signers != null) {
+      throw new ValidationError('Batch transaction must be unsigned.')
+    }
+  })
+
+  // eslint-disable-next-line @typescript-eslint/consistent-type-assertions -- checked above
+  const batchTransactions = decodedTransactions as Batch[]
+
+  validateBatchTransactionEquivalence(batchTransactions)
+
+  return encode(getTransactionWithAllBatchSigners(batchTransactions))
+}
+
+/**
+ * The transactions should all be equal except for the 'Signers' field.
+ *
+ * @param transactions - An array of Transactions which are expected to be equal other than 'Signers'.
+ * @throws ValidationError if the transactions are not equal in any field other than 'Signers'.
+ */
+function validateBatchTransactionEquivalence(transactions: Batch[]): void {
+  const exampleTransaction = JSON.stringify({
+    flags: transactions[0].Flags,
+    transactionIDs: transactions[0].RawTransactions.map((rawTx) =>
+      hashSignedTx(rawTx.RawTransaction),
+    ),
+  })
+  if (
+    transactions.slice(1).some(
+      (tx) =>
+        JSON.stringify({
+          flags: tx.Flags,
+          transactionIDs: tx.RawTransactions.map((rawTx) =>
+            hashSignedTx(rawTx.RawTransaction),
+          ),
+        }) !== exampleTransaction,
+    )
+  ) {
+    throw new ValidationError(
+      'Flags and transaction hashes are not the same for all provided transactions.',
+    )
+  }
+}
+
+function getTransactionWithAllBatchSigners(transactions: Batch[]): Batch {
+  // Signers must be sorted in the combined transaction - See compareSigners' documentation for more details
+  const sortedSigners: BatchSigner[] = transactions
+    .flatMap((tx) => tx.BatchSigners ?? [])
+    .filter((signer) => signer.BatchSigner.Account !== transactions[0].Account)
+    .sort((signer1, signer2) =>
+      compareSigners(signer1.BatchSigner, signer2.BatchSigner),
+    )
+
+  return { ...transactions[0], BatchSigners: sortedSigners }
+}

package/src/Wallet/defaultFaucets.ts

@@ -14,42 +14,39 @@ export interface FaucetWallet {
 export enum FaucetNetwork {
   Testnet = 'faucet.altnet.rippletest.net',
   Devnet = 'faucet.devnet.rippletest.net',
-  WasmDevnet = 'wasmfaucet.devnet.rippletest.net',
 }
 
-export const FaucetNetworkPaths: Record<string, string> = {
+export const faucetNetworkPaths: Record<string, string> = {
   [FaucetNetwork.Testnet]: '/accounts',
   [FaucetNetwork.Devnet]: '/accounts',
-  [FaucetNetwork.WasmDevnet]: '/accounts',
 }
 
+export const faucetNetworkIDs: Map<number, FaucetNetwork> = new Map([
+  [1, FaucetNetwork.Testnet],
+  [2, FaucetNetwork.Devnet],
+])
+
 /**
  * Get the faucet host based on the Client connection.
  *
  * @param client - Client.
  * @returns A {@link FaucetNetwork}.
- * @throws When the client url is not on altnet or devnet.
+ * @throws When there is no known faucet for the client's network ID.
  */
 export function getFaucetHost(client: Client): FaucetNetwork | undefined {
-  const connectionUrl = client.url
-
-  // 'altnet' for Ripple Testnet server and 'testnet' for XRPL Labs Testnet server
-  if (connectionUrl.includes('altnet') || connectionUrl.includes('testnet')) {
-    return FaucetNetwork.Testnet
-  }
-
-  if (connectionUrl.includes('sidechain-net2')) {
+  if (client.networkID == null) {
     throw new XRPLFaucetError(
-      'Cannot fund an account on an issuing chain. Accounts must be created via the bridge.',
+      'Cannot create faucet URL without networkID or the faucetHost information',
     )
   }
 
-  if (connectionUrl.includes('wasm')) {
-    return FaucetNetwork.WasmDevnet
+  if (faucetNetworkIDs.has(client.networkID)) {
+    return faucetNetworkIDs.get(client.networkID)
   }
 
-  if (connectionUrl.includes('devnet')) {
-    return FaucetNetwork.Devnet
+  if (client.networkID === 0) {
+    // mainnet does not have a faucet
+    throw new XRPLFaucetError('Faucet is not available for mainnet.')
   }
 
   throw new XRPLFaucetError('Faucet URL is not defined or inferrable.')
@@ -60,11 +57,11 @@ export function getFaucetHost(client: Client): FaucetNetwork | undefined {
  *
  * @param hostname - hostname.
  * @returns A String with the correct path for the input hostname.
- * If hostname undefined or cannot find (key, value) pair in {@link FaucetNetworkPaths}, defaults to '/accounts'
+ * If hostname undefined or cannot find (key, value) pair in {@link faucetNetworkPaths}, defaults to '/accounts'
  */
-export function getDefaultFaucetPath(hostname: string | undefined): string {
+export function getFaucetPath(hostname: string | undefined): string {
   if (hostname === undefined) {
     return '/accounts'
   }
-  return FaucetNetworkPaths[hostname] || '/accounts'
+  return faucetNetworkPaths[hostname] || '/accounts'
 }

package/src/Wallet/fundWallet.ts

@@ -3,11 +3,7 @@ import { isValidClassicAddress } from 'ripple-address-codec'
 import type { Client } from '../client'
 import { XRPLFaucetError } from '../errors'
 
-import {
-  FaucetWallet,
-  getFaucetHost,
-  getDefaultFaucetPath,
-} from './defaultFaucets'
+import { FaucetWallet, getFaucetHost, getFaucetPath } from './defaultFaucets'
 
 import { Wallet } from '.'
 
@@ -148,7 +144,7 @@ export async function requestFunding(
   if (!hostname) {
     throw new XRPLFaucetError('No faucet hostname could be derived')
   }
-  const pathname = options.faucetPath ?? getDefaultFaucetPath(hostname)
+  const pathname = options.faucetPath ?? getFaucetPath(hostname)
   const response = await fetch(`https://${hostname}${pathname}`, {
     method: 'POST',
     headers: {
@@ -190,31 +186,24 @@ async function processSuccessfulResponse(
       new XRPLFaucetError(`The faucet account is undefined`),
     )
   }
-  try {
-    // Check at regular interval if the address is enabled on the XRPL and funded
-    const updatedBalance = await getUpdatedBalance(
-      client,
-      classicAddress,
-      startingBalance,
-    )
+  // Check at regular interval if the address is enabled on the XRPL and funded
+  const updatedBalance = await getUpdatedBalance(
+    client,
+    classicAddress,
+    startingBalance,
+  )
 
-    if (updatedBalance > startingBalance) {
-      return {
-        wallet: walletToFund,
-        balance: updatedBalance,
-      }
+  if (updatedBalance > startingBalance) {
+    return {
+      wallet: walletToFund,
+      balance: updatedBalance,
     }
-    throw new XRPLFaucetError(
-      `Unable to fund address with faucet after waiting ${
-        INTERVAL_SECONDS * MAX_ATTEMPTS
-      } seconds`,
-    )
-  } catch (err) {
-    if (err instanceof Error) {
-      throw new XRPLFaucetError(err.message)
-    }
-    throw err
   }
+  throw new XRPLFaucetError(
+    `Unable to fund address with faucet after waiting ${
+      INTERVAL_SECONDS * MAX_ATTEMPTS
+    } seconds`,
+  )
 }
 
 async function processError(response: Response, body): Promise<never> {

package/src/Wallet/index.ts

@@ -24,6 +24,8 @@ import {
 import ECDSA from '../ECDSA'
 import { ValidationError } from '../errors'
 import { Transaction, validate } from '../models/transactions'
+import { GlobalFlags } from '../models/transactions/common'
+import { hasFlag } from '../models/utils'
 import { ensureClassicAddress } from '../sugar/utils'
 import { omitBy } from '../utils/collections'
 import { hashSignedTx } from '../utils/hashes/hashLedger'
@@ -367,6 +369,7 @@ export class Wallet {
    * @param this - Wallet instance.
    * @param transaction - A transaction to be signed offline.
    * @param multisign - Specify true/false to use multisign or actual address (classic/x-address) to make multisign tx request.
+   *                    The actual address is only needed in the case of regular key usage.
    * @returns A signed transaction.
    * @throws ValidationError if the transaction is already signed or does not encode/decode to same result.
    * @throws XrplError if the issued currency being signed is XRP ignoring case.
@@ -381,7 +384,7 @@ export class Wallet {
     hash: string
   } {
     let multisignAddress: boolean | string = false
-    if (typeof multisign === 'string' && multisign.startsWith('X')) {
+    if (typeof multisign === 'string') {
       multisignAddress = multisign
     } else if (multisign) {
       multisignAddress = this.classicAddress
@@ -407,12 +410,14 @@ export class Wallet {
      */
     // eslint-disable-next-line @typescript-eslint/consistent-type-assertions -- validate does not accept Transaction type
     validate(tx as unknown as Record<string, unknown>)
+    if (hasFlag(tx, GlobalFlags.tfInnerBatchTxn, 'tfInnerBatchTxn')) {
+      throw new ValidationError('Cannot sign a Batch inner transaction.')
+    }
 
     const txToSignAndEncode = { ...tx }
 
-    txToSignAndEncode.SigningPubKey = multisignAddress ? '' : this.publicKey
-
     if (multisignAddress) {
+      txToSignAndEncode.SigningPubKey = ''
       const signer = {
         Account: multisignAddress,
         SigningPubKey: this.publicKey,
@@ -424,6 +429,7 @@ export class Wallet {
       }
       txToSignAndEncode.Signers = [{ Signer: signer }]
     } else {
+      txToSignAndEncode.SigningPubKey = this.publicKey
       txToSignAndEncode.TxnSignature = computeSignature(
         txToSignAndEncode,
         this.privateKey,

package/src/Wallet/signer.ts

@@ -1,13 +1,12 @@
-import { bytesToHex } from '@xrplf/isomorphic/utils'
-import { BigNumber } from 'bignumber.js'
-import { decodeAccountID } from 'ripple-address-codec'
-import { decode, encode, encodeForSigning } from 'ripple-binary-codec'
+import { encode, encodeForSigning } from 'ripple-binary-codec'
 import { verify } from 'ripple-keypairs'
 
 import { ValidationError } from '../errors'
 import { Signer } from '../models/common'
 import { Transaction, validate } from '../models/transactions'
 
+import { compareSigners, getDecodedTransaction } from './utils'
+
 /**
  * Takes several transactions with Signer fields (in object or blob form) and creates a
  * single transaction with all Signers that then gets signed and returned.
@@ -121,43 +120,9 @@ function getTransactionWithAllSigners(
   // Signers must be sorted in the combined transaction - See compareSigners' documentation for more details
   const sortedSigners: Signer[] = transactions
     .flatMap((tx) => tx.Signers ?? [])
-    .sort(compareSigners)
+    .sort((signer1, signer2) => compareSigners(signer1.Signer, signer2.Signer))
 
   return { ...transactions[0], Signers: sortedSigners }
 }
 
-/**
- * If presented in binary form, the Signers array must be sorted based on
- * the numeric value of the signer addresses, with the lowest value first.
- * (If submitted as JSON, the submit_multisigned method handles this automatically.)
- * https://xrpl.org/multi-signing.html.
- *
- * @param left - A Signer to compare with.
- * @param right - A second Signer to compare with.
- * @returns 1 if left \> right, 0 if left = right, -1 if left \< right, and null if left or right are NaN.
- */
-function compareSigners(left: Signer, right: Signer): number {
-  return addressToBigNumber(left.Signer.Account).comparedTo(
-    addressToBigNumber(right.Signer.Account),
-  )
-}
-
-const NUM_BITS_IN_HEX = 16
-
-function addressToBigNumber(address: string): BigNumber {
-  const hex = bytesToHex(decodeAccountID(address))
-  return new BigNumber(hex, NUM_BITS_IN_HEX)
-}
-
-function getDecodedTransaction(txOrBlob: Transaction | string): Transaction {
-  if (typeof txOrBlob === 'object') {
-    // We need this to handle X-addresses in multisigning
-    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions -- We are casting here to get strong typing
-    return decode(encode(txOrBlob)) as unknown as Transaction
-  }
-
-  // eslint-disable-next-line @typescript-eslint/consistent-type-assertions -- We are casting here to get strong typing
-  return decode(txOrBlob) as unknown as Transaction
-}
-
 export { verifySignature, multisign }

package/src/Wallet/utils.ts

@@ -0,0 +1,58 @@
+import { bytesToHex } from '@xrplf/isomorphic/utils'
+import BigNumber from 'bignumber.js'
+import { decodeAccountID } from 'ripple-address-codec'
+import { decode, encode } from 'ripple-binary-codec'
+
+import { Transaction } from '../models'
+
+/**
+ * If presented in binary form, the Signers array must be sorted based on
+ * the numeric value of the signer addresses, with the lowest value first.
+ * (If submitted as JSON, the submit_multisigned method handles this automatically.)
+ * https://xrpl.org/multi-signing.html.
+ *
+ * @param left - A Signer to compare with.
+ * @param right - A second Signer to compare with.
+ * @returns 1 if left \> right, 0 if left = right, -1 if left \< right, and null if left or right are NaN.
+ */
+export function compareSigners<T extends { Account: string }>(
+  left: T,
+  right: T,
+): number {
+  return addressToBigNumber(left.Account).comparedTo(
+    addressToBigNumber(right.Account),
+  )
+}
+
+export const NUM_BITS_IN_HEX = 16
+
+/**
+ * Converts an address to a BigNumber.
+ *
+ * @param address - The address to convert.
+ * @returns A BigNumber representing the address.
+ */
+export function addressToBigNumber(address: string): BigNumber {
+  const hex = bytesToHex(decodeAccountID(address))
+  return new BigNumber(hex, NUM_BITS_IN_HEX)
+}
+
+/**
+ * Decodes a transaction or transaction blob into a Transaction object.
+ *
+ * @param txOrBlob - A Transaction object or a hex string representing a transaction blob.
+ * @returns A Transaction object.
+ * @throws If the input is not a valid Transaction or transaction blob.
+ */
+export function getDecodedTransaction(
+  txOrBlob: Transaction | string,
+): Transaction {
+  if (typeof txOrBlob === 'object') {
+    // We need this to handle X-addresses in multisigning
+    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions -- We are casting here to get strong typing
+    return decode(encode(txOrBlob)) as unknown as Transaction
+  }
+
+  // eslint-disable-next-line @typescript-eslint/consistent-type-assertions -- We are casting here to get strong typing
+  return decode(txOrBlob) as unknown as Transaction
+}

package/src/client/RequestManager.ts

@@ -175,6 +175,7 @@ export default class RequestManager {
    * @param response - The response to handle.
    * @throws ResponseFormatError if the response format is invalid, RippledError if rippled returns an error.
    */
+  // eslint-disable-next-line complexity -- handling a response is complex
   public handleResponse(
     response: Partial<Response<APIVersion> | ErrorResponse>,
   ): void {
@@ -195,7 +196,9 @@ export default class RequestManager {
       // eslint-disable-next-line @typescript-eslint/consistent-type-assertions -- We know this must be true
       const errorResponse = response as Partial<ErrorResponse>
       const error = new RippledError(
-        errorResponse.error_message ?? errorResponse.error,
+        errorResponse.error_message ??
+          errorResponse.error_exception ??
+          errorResponse.error,
         errorResponse,
       )
       this.reject(response.id, error)

package/src/client/connection.ts

@@ -349,7 +349,6 @@ export class Connection extends EventEmitter {
       try {
         this.requestManager.handleResponse(data)
       } catch (error) {
-        // eslint-disable-next-line max-depth -- okay here
         if (error instanceof Error) {
           this.emit('error', 'badMessage', error.message, message)
         } else {

package/src/client/index.ts

@@ -63,10 +63,12 @@ import {
 import {
   setValidAddresses,
   setNextValidSequenceNumber,
-  calculateFeePerTransactionType,
   setLatestValidatedLedgerSequence,
   checkAccountDeleteBlockers,
   txNeedsNetworkID,
+  autofillBatchTxn,
+  handleDeliverMax,
+  getTransactionFee,
 } from '../sugar/autofill'
 import { formatBalances } from '../sugar/balances'
 import {
@@ -662,7 +664,6 @@ class Client extends EventEmitter<EventTypes> {
    * @throws ValidationError If Amount and DeliverMax fields are not identical in a Payment Transaction
    */
 
-  // eslint-disable-next-line complexity -- handling Payment transaction API v2 requires more logic
   public async autofill<T extends SubmittableTransaction>(
     transaction: T,
     signersCount?: number,
@@ -680,7 +681,7 @@ class Client extends EventEmitter<EventTypes> {
       promises.push(setNextValidSequenceNumber(this, tx))
     }
     if (tx.Fee == null) {
-      promises.push(calculateFeePerTransactionType(this, tx, signersCount))
+      promises.push(getTransactionFee(this, tx, signersCount))
     }
     if (tx.LastLedgerSequence == null) {
       promises.push(setLatestValidatedLedgerSequence(this, tx))
@@ -688,33 +689,11 @@ class Client extends EventEmitter<EventTypes> {
     if (tx.TransactionType === 'AccountDelete') {
       promises.push(checkAccountDeleteBlockers(this, tx))
     }
-
-    // eslint-disable-next-line @typescript-eslint/ban-ts-comment -- ignore type-assertions on the DeliverMax property
-    // @ts-expect-error -- DeliverMax property exists only at the RPC level, not at the protocol level
-    if (tx.TransactionType === 'Payment' && tx.DeliverMax != null) {
-      // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition -- This is a valid null check for Amount
-      if (tx.Amount == null) {
-        // If only DeliverMax is provided, use it to populate the Amount field
-        // eslint-disable-next-line @typescript-eslint/ban-ts-comment -- ignore type-assertions on the DeliverMax property
-        // @ts-expect-error -- DeliverMax property exists only at the RPC level, not at the protocol level
-        // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment -- DeliverMax is a known RPC-level property
-        tx.Amount = tx.DeliverMax
-      }
-
-      // eslint-disable-next-line @typescript-eslint/ban-ts-comment -- ignore type-assertions on the DeliverMax property
-      // @ts-expect-error -- DeliverMax property exists only at the RPC level, not at the protocol level
-      // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition -- This is a valid null check for Amount
-      if (tx.Amount != null && tx.Amount !== tx.DeliverMax) {
-        return Promise.reject(
-          new ValidationError(
-            'PaymentTransaction: Amount and DeliverMax fields must be identical when both are provided',
-          ),
-        )
-      }
-
-      // eslint-disable-next-line @typescript-eslint/ban-ts-comment -- ignore type-assertions on the DeliverMax property
-      // @ts-expect-error -- DeliverMax property exists only at the RPC level, not at the protocol level
-      delete tx.DeliverMax
+    if (tx.TransactionType === 'Batch') {
+      promises.push(autofillBatchTxn(this, tx))
+    }
+    if (tx.TransactionType === 'Payment') {
+      handleDeliverMax(tx)
     }
 
     return Promise.all(promises).then(() => tx)

package/src/client/partialPayment.ts

@@ -96,10 +96,9 @@ function isPartialPayment(
   }
 
   const delivered = meta.delivered_amount
-  // eslint-disable-next-line @typescript-eslint/ban-ts-comment -- DeliverMax is a valid field on Payment response
-  // @ts-expect-error -- DeliverMax is a valid field on Payment response
-  // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment -- DeliverMax is a valid field on Payment response
-  const amount = tx.DeliverMax
+
+  // eslint-disable-next-line @typescript-eslint/consistent-type-assertions -- needed here
+  const amount = tx.DeliverMax as Amount | MPTAmount
 
   if (delivered === undefined) {
     return false

package/src/models/ledger/Credential.ts

@@ -1,8 +1,8 @@
-import { GlobalFlags } from '../transactions/common'
+import { GlobalFlagsInterface } from '../transactions/common'
 
 import { BaseLedgerEntry, HasPreviousTxnID } from './BaseLedgerEntry'
 
-export interface CredentialFlags extends GlobalFlags {
+export interface CredentialFlags extends GlobalFlagsInterface {
   lsfAccepted?: boolean
 }
 

package/src/models/ledger/Escrow.ts

@@ -61,8 +61,4 @@ export default interface Escrow extends BaseLedgerEntry, HasPreviousTxnID {
    * this object, in case the directory consists of multiple pages.
    */
   DestinationNode?: string
-
-  FinishFunction?: string
-
-  Data?: string
 }

package/src/models/ledger/FeeSettings.ts

@@ -24,10 +24,6 @@ export interface FeeSettingsPostAmendmentFields {
   ReserveBaseDrops: string
   /** The incremental owner reserve for owning objects, as drops of XRP. */
   ReserveIncrementDrops: string
-
-  ExtensionComputeLimit: number
-
-  ExtensionSizeLimit: number
 }
 
 export interface FeeSettingsBase

package/src/models/ledger/XChainOwnedClaimID.ts

@@ -1,6 +1,4 @@
-import { Amount } from 'ripple-binary-codec/dist/types'
-
-import { XChainBridge } from '../common'
+import { Amount, XChainBridge } from '../common'
 
 import { BaseLedgerEntry, HasPreviousTxnID } from './BaseLedgerEntry'
 

package/src/models/methods/baseMethod.ts

@@ -53,6 +53,7 @@ export interface ErrorResponse {
   error: string
   error_code?: string
   error_message?: string
+  error_exception?: string
   request: Request
   api_version?: number
 }