xrpl 4.4.1 → 4.5.0-smartescrow.1

package/src/models/methods/subscribe.ts

@@ -158,9 +158,12 @@ export interface LedgerStreamResponse {
    * If this ledger version includes a SetFee pseudo-transaction the new.
    * Transaction cost applies starting with the following ledger version.
    */
+  extension_compute?: number
+  extension_size?: number
   fee_base: number
   /** The reference transaction cost in "fee units". This is not returned after the SetFees amendment is enabled. */
   fee_ref?: number
+  gas_price?: string
   /** The identifying hash of the ledger version that was closed. */
   ledger_hash: string
   /** The ledger index of the ledger that was closed. */
@@ -506,22 +509,22 @@ export type EventTypes =
 export type OnEventToListenerMap<T extends EventTypes> = T extends 'connected'
   ? () => void
   : T extends 'disconnected'
-  ? (code: number) => void
-  : T extends 'ledgerClosed'
-  ? (ledger: LedgerStream) => void
-  : T extends 'validationReceived'
-  ? (validation: ValidationStream) => void
-  : T extends 'transaction'
-  ? (transaction: TransactionStream) => void
-  : T extends 'peerStatusChange'
-  ? (peerStatus: PeerStatusStream) => void
-  : T extends 'consensusPhase'
-  ? (consensus: ConsensusStream) => void
-  : T extends 'manifestReceived'
-  ? (manifest: ManifestRequest) => void
-  : T extends 'path_find'
-  ? (path: PathFindStream) => void
-  : T extends 'error'
-  ? // eslint-disable-next-line @typescript-eslint/no-explicit-any -- needs to be any for overload
-    (...err: any[]) => void
-  : (...args: never[]) => void
+    ? (code: number) => void
+    : T extends 'ledgerClosed'
+      ? (ledger: LedgerStream) => void
+      : T extends 'validationReceived'
+        ? (validation: ValidationStream) => void
+        : T extends 'transaction'
+          ? (transaction: TransactionStream) => void
+          : T extends 'peerStatusChange'
+            ? (peerStatus: PeerStatusStream) => void
+            : T extends 'consensusPhase'
+              ? (consensus: ConsensusStream) => void
+              : T extends 'manifestReceived'
+                ? (manifest: ManifestRequest) => void
+                : T extends 'path_find'
+                  ? (path: PathFindStream) => void
+                  : T extends 'error'
+                    ? // eslint-disable-next-line @typescript-eslint/no-explicit-any -- needs to be any for overload
+                      (...err: any[]) => void
+                    : (...args: never[]) => void

package/src/models/transactions/MPTokenIssuanceCreate.ts

@@ -173,7 +173,7 @@ export function validateMPTokenIssuanceCreate(
     const isTfMPTCanTransfer =
       typeof flags === 'number'
         ? isFlagEnabled(flags, MPTokenIssuanceCreateFlags.tfMPTCanTransfer)
-        : flags.tfMPTCanTransfer ?? false
+        : (flags.tfMPTCanTransfer ?? false)
 
     if (tx.TransferFee < 0 || tx.TransferFee > MAX_TRANSFER_FEE) {
       throw new ValidationError(

package/src/models/transactions/MPTokenIssuanceSet.ts

@@ -73,12 +73,12 @@ export function validateMPTokenIssuanceSet(tx: Record<string, unknown>): void {
   const isTfMPTLock =
     typeof flags === 'number'
       ? isFlagEnabled(flags, MPTokenIssuanceSetFlags.tfMPTLock)
-      : flags.tfMPTLock ?? false
+      : (flags.tfMPTLock ?? false)
 
   const isTfMPTUnlock =
     typeof flags === 'number'
       ? isFlagEnabled(flags, MPTokenIssuanceSetFlags.tfMPTUnlock)
-      : flags.tfMPTUnlock ?? false
+      : (flags.tfMPTUnlock ?? false)
 
   if (isTfMPTLock && isTfMPTUnlock) {
     throw new ValidationError('MPTokenIssuanceSet: flag conflict')

package/src/models/transactions/NFTokenCreateOffer.ts

@@ -151,7 +151,7 @@ export function validateNFTokenCreateOffer(tx: Record<string, unknown>): void {
   const isTfSellNFToken =
     typeof flags === 'number'
       ? isFlagEnabled(flags, NFTokenCreateOfferFlags.tfSellNFToken)
-      : flags.tfSellNFToken ?? false
+      : (flags.tfSellNFToken ?? false)
 
   if (isTfSellNFToken) {
     validateNFTokenSellOfferCases(tx)

package/src/models/transactions/batch.ts

@@ -7,8 +7,10 @@ import {
   GlobalFlags,
   GlobalFlagsInterface,
   isArray,
+  isNull,
   isRecord,
   isString,
+  isValue,
   validateBaseTransaction,
   validateOptionalField,
   validateRequiredField,
@@ -40,18 +42,6 @@ export interface BatchFlagsInterface extends GlobalFlagsInterface {
   tfIndependent?: boolean
 }
 
-export type BatchInnerTransaction = SubmittableTransaction & {
-  Fee?: '0'
-
-  SigningPubKey?: ''
-
-  TxnSignature?: never
-
-  Signers?: never
-
-  LastLedgerSequence?: never
-}
-
 export interface BatchSigner {
   BatchSigner: {
     Account: string
@@ -73,10 +63,48 @@ export interface Batch extends BaseTransaction {
   BatchSigners?: BatchSigner[]
 
   RawTransactions: Array<{
-    RawTransaction: BatchInnerTransaction
+    RawTransaction: SubmittableTransaction
   }>
 }
 
+function validateBatchInnerTransaction(
+  tx: Record<string, unknown>,
+  index: number,
+): void {
+  if (tx.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(tx, GlobalFlags.tfInnerBatchTxn, 'tfInnerBatchTxn')) {
+    throw new ValidationError(
+      `Batch: RawTransactions[${index}] must contain the \`tfInnerBatchTxn\` flag.`,
+    )
+  }
+  validateOptionalField(tx, 'Fee', isValue('0'), {
+    paramName: `RawTransactions[${index}].RawTransaction.Fee`,
+    txType: 'Batch',
+  })
+  validateOptionalField(tx, 'SigningPubKey', isValue(''), {
+    paramName: `RawTransactions[${index}].RawTransaction.SigningPubKey`,
+    txType: 'Batch',
+  })
+  validateOptionalField(tx, 'TxnSignature', isNull, {
+    paramName: `RawTransactions[${index}].RawTransaction.TxnSignature`,
+    txType: 'Batch',
+  })
+  validateOptionalField(tx, 'Signers', isNull, {
+    paramName: `RawTransactions[${index}].RawTransaction.Signers`,
+    txType: 'Batch',
+  })
+  validateOptionalField(tx, 'LastLedgerSequence', isNull, {
+    paramName: `RawTransactions[${index}].RawTransaction.LastLedgerSequence`,
+    txType: 'Batch',
+  })
+}
+
 /**
  * Verify the form and type of a Batch at runtime.
  *
@@ -101,18 +129,7 @@ export function validateBatch(tx: Record<string, unknown>): void {
     })
 
     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.`,
-      )
-    }
+    validateBatchInnerTransaction(rawTx, index)
 
     // Full validation of each `RawTransaction` object is done in `validate` to avoid dependency cycles
   })
@@ -132,19 +149,19 @@ export function validateBatch(tx: Record<string, unknown>): void {
 
     const signer = signerRecord.BatchSigner
     validateRequiredField(signer, 'Account', isString, {
-      paramName: `BatchSigners[${index}].Account`,
+      paramName: `BatchSigners[${index}].BatchSigner.Account`,
       txType: 'Batch',
     })
     validateOptionalField(signer, 'SigningPubKey', isString, {
-      paramName: `BatchSigners[${index}].SigningPubKey`,
+      paramName: `BatchSigners[${index}].BatchSigner.SigningPubKey`,
       txType: 'Batch',
     })
     validateOptionalField(signer, 'TxnSignature', isString, {
-      paramName: `BatchSigners[${index}].TxnSignature`,
+      paramName: `BatchSigners[${index}].BatchSigner.TxnSignature`,
       txType: 'Batch',
     })
     validateOptionalField(signer, 'Signers', isArray, {
-      paramName: `BatchSigners[${index}].Signers`,
+      paramName: `BatchSigners[${index}].BatchSigner.Signers`,
       txType: 'Batch',
     })
   })

package/src/models/transactions/common.ts

@@ -152,6 +152,28 @@ export function isNumber(num: unknown): num is number {
   return typeof num === 'number'
 }
 
+/**
+ * Verify the form and type of a null value at runtime.
+ *
+ * @param inp - The value to check the form and type of.
+ * @returns Whether the value is properly formed.
+ */
+export function isNull(inp: unknown): inp is null {
+  return inp == null
+}
+
+/**
+ * Verify that a certain field has a certain exact value at runtime.
+ *
+ * @param value The value to compare against.
+ * @returns Whether the number is properly formed and within the bounds.
+ */
+export function isValue<V>(value: V): (inp: unknown) => inp is V {
+  // eslint-disable-next-line func-style -- returning a function
+  const isValueInternal = (inp: unknown): inp is V => inp === value
+  return isValueInternal
+}
+
 /**
  * Checks whether the given value is a valid XRPL number string.
  * Accepts integer, decimal, or scientific notation strings.

package/src/models/transactions/delegateSet.ts

@@ -9,7 +9,7 @@ import {
 } from './common'
 
 const PERMISSIONS_MAX_LENGTH = 10
-const NON_DELEGATABLE_TRANSACTIONS = new Set([
+const NON_DELEGABLE_TRANSACTIONS = new Set([
   'AccountSet',
   'SetRegularKey',
   'SignerListSet',
@@ -97,7 +97,7 @@ export function validateDelegateSet(tx: Record<string, unknown>): void {
     if (typeof permissionValue !== 'string') {
       throw new ValidationError('DelegateSet: PermissionValue must be a string')
     }
-    if (NON_DELEGATABLE_TRANSACTIONS.has(permissionValue)) {
+    if (NON_DELEGABLE_TRANSACTIONS.has(permissionValue)) {
       throw new ValidationError(
         `DelegateSet: PermissionValue contains a non-delegatable transaction ${permissionValue}`,
       )

package/src/models/transactions/escrowCreate.ts

@@ -50,6 +50,10 @@ export interface EscrowCreate extends BaseTransaction {
    * payment, such as a hosted recipient at the destination address.
    */
   DestinationTag?: number
+
+  FinishFunction?: string
+
+  Data?: string
 }
 
 /**
@@ -71,9 +75,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

@@ -9,6 +9,7 @@ import {
   validateRequiredField,
   MAX_AUTHORIZED_CREDENTIALS,
 } from './common'
+import type { TransactionMetadataBase } from './metadata'
 
 /**
  * Deliver XRP from a held payment to the recipient.
@@ -38,6 +39,14 @@ export interface EscrowFinish extends BaseTransaction {
    * The credentials included must not be expired.
    */
   CredentialIDs?: string[]
+
+  ComputationAllowance?: number
+}
+
+export interface EscrowFinishMetadata extends TransactionMetadataBase {
+  // if ComputationAllowance is present and the Smart Escrow runs
+  GasUsed?: number
+  WasmReturnCode?: number
 }
 
 /**

package/src/models/transactions/metadata.ts

@@ -1,6 +1,7 @@
 import { Amount, MPTAmount } from '../common'
 
 import { BaseTransaction } from './common'
+import { EscrowFinish, EscrowFinishMetadata } from './escrowFinish'
 import {
   MPTokenIssuanceCreate,
   MPTokenIssuanceCreateMetadata,
@@ -96,13 +97,15 @@ export type TransactionMetadata<T extends BaseTransaction = Transaction> =
   T extends Payment
     ? PaymentMetadata
     : T extends NFTokenMint
-    ? NFTokenMintMetadata
-    : T extends NFTokenCreateOffer
-    ? NFTokenCreateOfferMetadata
-    : T extends NFTokenAcceptOffer
-    ? NFTokenAcceptOfferMetadata
-    : T extends NFTokenCancelOffer
-    ? NFTokenCancelOfferMetadata
-    : T extends MPTokenIssuanceCreate
-    ? MPTokenIssuanceCreateMetadata
-    : TransactionMetadataBase
+      ? NFTokenMintMetadata
+      : T extends NFTokenCreateOffer
+        ? NFTokenCreateOfferMetadata
+        : T extends NFTokenAcceptOffer
+          ? NFTokenAcceptOfferMetadata
+          : T extends NFTokenCancelOffer
+            ? NFTokenCancelOfferMetadata
+            : T extends MPTokenIssuanceCreate
+              ? MPTokenIssuanceCreateMetadata
+              : T extends EscrowFinish
+                ? EscrowFinishMetadata
+                : TransactionMetadataBase

package/src/models/transactions/payment.ts

@@ -241,7 +241,7 @@ function checkPartialPayment(tx: Record<string, unknown>): void {
     const isTfPartialPayment =
       typeof flags === 'number'
         ? isFlagEnabled(flags, PaymentFlags.tfPartialPayment)
-        : flags.tfPartialPayment ?? false
+        : (flags.tfPartialPayment ?? false)
 
     if (!isTfPartialPayment) {
       throw new ValidationError(

package/src/models/transactions/setFee.ts

@@ -32,6 +32,12 @@ export interface SetFeePostAmendment extends BaseTransaction {
    * The incremental reserve, in drops
    */
   ReserveIncrementDrops: string
+
+  ExtensionComputeLimit?: number
+
+  ExtensionSizeLimit?: number
+
+  GasPrice?: number
 }
 
 /**

package/src/models/utils/flags.ts

@@ -118,7 +118,7 @@ export function convertTxFlagsToNumber(tx: Transaction): number {
       }
 
       return txFlags[flag]
-        ? resultFlags | (flagEnum[flag] || GlobalFlags[flag])
+        ? resultFlags | (flagEnum[flag] ?? GlobalFlags[flag])
         : resultFlags
     }, 0)
   }

package/src/sugar/autofill.ts

@@ -19,6 +19,11 @@ const LEDGER_OFFSET = 20
 const RESTRICTED_NETWORKS = 1024
 const REQUIRED_NETWORKID_VERSION = '1.11.0'
 
+const MICRO_DROPS_PER_DROP = 1_000_000
+
+const WASM_FIXED_UPLOAD_COST = 100
+const WASM_DROPS_PER_BYTE = 5
+
 /**
  * Determines whether the source rippled version is not later than the target rippled version.
  * Example usage: isNotLaterRippledVersion('1.10.0', '1.11.0') returns true.
@@ -258,6 +263,17 @@ async function fetchOwnerReserveFee(client: Client): Promise<BigNumber> {
   return new BigNumber(fee)
 }
 
+async function fetchGasPrice(client: Client): Promise<BigNumber> {
+  const response = await client.request({ command: 'server_state' })
+  const gasPrice = response.result.state.validated_ledger?.gas_price
+
+  if (gasPrice == null) {
+    return Promise.reject(new Error('Could not fetch Owner Reserve.'))
+  }
+
+  return new BigNumber(gasPrice)
+}
+
 /**
  * Calculates the fee per transaction type.
  *
@@ -266,40 +282,57 @@ async function fetchOwnerReserveFee(client: Client): Promise<BigNumber> {
  * @param [signersCount=0] - The number of signers (default is 0). Only used for multisigning.
  * @returns A promise that returns the fee.
  */
-
+// eslint-disable-next-line max-lines-per-function, complexity -- necessary to check for many transaction types.
 async function calculateFeePerTransactionType(
   client: Client,
   tx: Transaction,
   signersCount = 0,
 ): Promise<BigNumber> {
   const netFeeXRP = await getFeeXrp(client)
-  const netFeeDrops = xrpToDrops(netFeeXRP)
-  let baseFee = new BigNumber(netFeeDrops)
+  const netFeeDrops = new BigNumber(xrpToDrops(netFeeXRP))
+  let baseFee = netFeeDrops
 
   const isSpecialTxCost = ['AccountDelete', 'AMMCreate'].includes(
     tx.TransactionType,
   )
 
-  // EscrowFinish Transaction with Fulfillment
-  if (tx.TransactionType === 'EscrowFinish' && tx.Fulfillment != null) {
-    const fulfillmentBytesSize: number = Math.ceil(tx.Fulfillment.length / 2)
-    // BaseFee × (33 + (Fulfillment size in bytes / 16))
-    baseFee = new BigNumber(
-      // eslint-disable-next-line @typescript-eslint/no-magic-numbers -- expected use of magic numbers
-      scaleValue(netFeeDrops, 33 + fulfillmentBytesSize / 16),
+  // EscrowCreate transaction with FinishFunction
+  if (tx.TransactionType === 'EscrowCreate' && tx.FinishFunction != null) {
+    baseFee = baseFee
+      .plus(WASM_FIXED_UPLOAD_COST)
+      .plus((WASM_DROPS_PER_BYTE * tx.FinishFunction.length) / 2)
+  } else if (tx.TransactionType === 'EscrowFinish') {
+    // EscrowFinish Transaction with Fulfillment/ComputationAllowance
+    if (tx.Fulfillment != null) {
+      const fulfillmentBytesSize: number = Math.ceil(tx.Fulfillment.length / 2)
+      // BaseFee × (33 + (Fulfillment size in bytes / 16))
+      baseFee = netFeeDrops.multipliedBy(
+        // eslint-disable-next-line @typescript-eslint/no-magic-numbers -- expected use of magic numbers
+        33 + fulfillmentBytesSize / 16,
+      )
+    }
+    if (tx.ComputationAllowance != null) {
+      const gasPrice = await fetchGasPrice(client)
+      const extraFee: BigNumber = gasPrice
+        .multipliedBy(tx.ComputationAllowance)
+        .dividedBy(MICRO_DROPS_PER_DROP)
+      baseFee = baseFee.plus(extraFee)
+    }
+  } else if (tx.TransactionType === 'Batch') {
+    const rawTxFees = await tx.RawTransactions.reduce(
+      async (acc, rawTxn) => {
+        const resolvedAcc = await acc
+        const fee = await calculateFeePerTransactionType(
+          client,
+          rawTxn.RawTransaction,
+        )
+        return BigNumber.sum(resolvedAcc, fee)
+      },
+      Promise.resolve(new BigNumber(0)),
     )
+    baseFee = BigNumber.sum(baseFee.times(2), rawTxFees)
   } else if (isSpecialTxCost) {
     baseFee = await fetchOwnerReserveFee(client)
-  } else if (tx.TransactionType === 'Batch') {
-    const rawTxFees = await tx.RawTransactions.reduce(async (acc, rawTxn) => {
-      const resolvedAcc = await acc
-      const fee = await calculateFeePerTransactionType(
-        client,
-        rawTxn.RawTransaction,
-      )
-      return BigNumber.sum(resolvedAcc, fee)
-    }, Promise.resolve(new BigNumber(0)))
-    baseFee = BigNumber.sum(baseFee.times(2), rawTxFees)
   }
 
   /*
@@ -307,7 +340,7 @@ async function calculateFeePerTransactionType(
    * BaseFee × (1 + Number of Signatures Provided)
    */
   if (signersCount > 0) {
-    baseFee = BigNumber.sum(baseFee, scaleValue(netFeeDrops, signersCount))
+    baseFee = BigNumber.sum(baseFee, netFeeDrops.multipliedBy(signersCount))
   }
 
   const maxFeeDrops = xrpToDrops(client.maxFeeXRP)
@@ -337,17 +370,6 @@ export async function getTransactionFee(
   tx.Fee = fee.toString(10)
 }
 
-/**
- * Scales the given value by multiplying it with the provided multiplier.
- *
- * @param value - The value to be scaled.
- * @param multiplier - The multiplier to scale the value.
- * @returns The scaled value as a string.
- */
-function scaleValue(value, multiplier): string {
-  return new BigNumber(value).times(multiplier).toString()
-}
-
 /**
  * Sets the latest validated ledger sequence for the transaction.
  *
@@ -403,12 +425,9 @@ export async function checkAccountDeleteBlockers(
  */
 export function handleDeliverMax(tx: Payment): void {
   if (tx.DeliverMax != null) {
-    // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition -- needed here
-    if (tx.Amount == null) {
-      // If only DeliverMax is provided, use it to populate the Amount field
-      // eslint-disable-next-line no-param-reassign -- known RPC-level property
-      tx.Amount = tx.DeliverMax
-    }
+    // If only DeliverMax is provided, use it to populate the Amount field
+    // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition, no-param-reassign -- needed here
+    tx.Amount ??= tx.DeliverMax
 
     // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition -- needed here
     if (tx.Amount != null && tx.Amount !== tx.DeliverMax) {
@@ -436,7 +455,7 @@ export async function autofillBatchTxn(
 ): Promise<void> {
   const accountSequences: Record<string, number> = {}
 
-  for await (const rawTxn of tx.RawTransactions) {
+  for (const rawTxn of tx.RawTransactions) {
     const txn = rawTxn.RawTransaction
 
     // Sequence processing
@@ -445,6 +464,7 @@ export async function autofillBatchTxn(
         txn.Sequence = accountSequences[txn.Account]
         accountSequences[txn.Account] += 1
       } else {
+        // eslint-disable-next-line no-await-in-loop -- It has to wait
         const nextSequence = await getNextValidSequenceNumber(
           client,
           txn.Account,
@@ -458,28 +478,24 @@ export async function autofillBatchTxn(
 
     if (txn.Fee == null) {
       txn.Fee = '0'
-      // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition -- needed for JS checks
     } else if (txn.Fee !== '0') {
       throw new XrplError('Must have `Fee of "0" in inner Batch transaction.')
     }
 
     if (txn.SigningPubKey == null) {
       txn.SigningPubKey = ''
-      // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition -- needed for JS checks
     } else if (txn.SigningPubKey !== '') {
       throw new XrplError(
         'Must have `SigningPubKey` of "" in inner Batch transaction.',
       )
     }
 
-    // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition -- needed for JS checks
     if (txn.TxnSignature != null) {
       throw new XrplError(
         'Must not have `TxnSignature` in inner Batch transaction.',
       )
     }
 
-    // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition -- needed for JS checks
     if (txn.Signers != null) {
       throw new XrplError('Must not have `Signers` in inner Batch transaction.')
     }

package/src/sugar/getFeeXrp.ts

@@ -35,10 +35,8 @@ export default async function getFeeXrp(
   }
 
   const baseFeeXrp = new BigNumber(baseFee)
-  if (serverInfo.load_factor == null) {
-    // https://github.com/ripple/rippled/issues/3812#issuecomment-816871100
-    serverInfo.load_factor = 1
-  }
+  // https://github.com/ripple/rippled/issues/3812#issuecomment-816871100
+  serverInfo.load_factor ??= 1
   let fee = baseFeeXrp.times(serverInfo.load_factor).times(feeCushion)
 
   // Cap fee to `client.maxFeeXRP`

package/src/sugar/getOrderbook.ts

@@ -127,7 +127,7 @@ export function createBookOffersRequest(
     ledger_index: options.ledger_index ?? 'validated',
     ledger_hash: options.ledger_hash === null ? undefined : options.ledger_hash,
     limit: options.limit ?? DEFAULT_LIMIT,
-    taker: options.taker ? options.taker : undefined,
+    taker: options.taker ?? undefined,
   }
 
   return request

package/src/utils/getBalanceChanges.ts

@@ -134,7 +134,7 @@ function getTrustlineQuantity(node: NormalizedNode): BalanceChange[] | null {
    * If an offer is placed to acquire an asset with no existing trustline,
    * the trustline can be created when the offer is taken.
    */
-  const fields = node.NewFields == null ? node.FinalFields : node.NewFields
+  const fields = node.NewFields ?? node.FinalFields
 
   // the balance is always from low node's perspective
   const result = {

package/src/utils/hashes/SHAMap/LeafNode.ts

@@ -35,6 +35,7 @@ class LeafNode extends Node {
    * @throws If node is of unknown type.
    */
   public get hash(): string {
+    // eslint-disable-next-line @typescript-eslint/switch-exhaustiveness-check -- TODO: https://github.com/XRPLF/xrpl.js/issues/3060
     switch (this.type) {
       case NodeType.ACCOUNT_STATE: {
         const leafPrefix = HashPrefix.LEAF_NODE.toString(HEX)