xrpl 4.3.0-smartescrow.3 → 4.4.0-smartescrow.0

package/src/sugar/autofill.ts

@@ -1,10 +1,11 @@
+/* eslint-disable max-lines -- lots of helper functions needed for autofill */
 import BigNumber from 'bignumber.js'
 import { xAddressToClassicAddress, isValidXAddress } from 'ripple-address-codec'
 
 import { type Client } from '..'
 import { ValidationError, XrplError } from '../errors'
 import { AccountInfoRequest, AccountObjectsRequest } from '../models/methods'
-import { Transaction } from '../models/transactions'
+import { Batch, Payment, Transaction } from '../models/transactions'
 import { xrpToDrops } from '../utils'
 
 import getFeeXrp from './getFeeXrp'
@@ -148,7 +149,10 @@ function validateAccountAddress(
   tagField: string,
 ): void {
   // if X-address is given, convert it to classic address
-  const { classicAccount, tag } = getClassicAccountAndTag(tx[accountField])
+  const { classicAccount, tag } = getClassicAccountAndTag(
+    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions -- okay here
+    tx[accountField] as string,
+  )
   // eslint-disable-next-line no-param-reassign -- param reassign is safe
   tx[accountField] = classicAccount
 
@@ -166,17 +170,17 @@ function validateAccountAddress(
 /**
  * Retrieves the classic account and tag from an account address.
  *
- * @param Account - The account address.
+ * @param account - The account address.
  * @param [expectedTag] - The expected tag for the account address.
  * @returns The classic account and tag.
  * @throws {ValidationError} If the address includes a tag that does not match the tag specified in the transaction.
  */
 function getClassicAccountAndTag(
-  Account: string,
+  account: string,
   expectedTag?: number,
 ): ClassicAccountAndTag {
-  if (isValidXAddress(Account)) {
-    const classic = xAddressToClassicAddress(Account)
+  if (isValidXAddress(account)) {
+    const classic = xAddressToClassicAddress(account)
     if (expectedTag != null && classic.tag !== expectedTag) {
       throw new ValidationError(
         'address includes a tag that does not match the tag specified in the transaction',
@@ -188,7 +192,7 @@ function getClassicAccountAndTag(
     }
   }
   return {
-    classicAccount: Account,
+    classicAccount: account,
     tag: expectedTag,
   }
 }
@@ -200,7 +204,6 @@ function getClassicAccountAndTag(
  * @param fieldName - The name of the field to convert.export
  */
 function convertToClassicAddress(tx: Transaction, fieldName: string): void {
-  // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment -- assignment is safe
   const account = tx[fieldName]
   if (typeof account === 'string') {
     const { classicAccount } = getClassicAccountAndTag(account)
@@ -209,6 +212,20 @@ function convertToClassicAddress(tx: Transaction, fieldName: string): void {
   }
 }
 
+// Helper function to get the next valid sequence number for an account.
+async function getNextValidSequenceNumber(
+  client: Client,
+  account: string,
+): Promise<number> {
+  const request: AccountInfoRequest = {
+    command: 'account_info',
+    account,
+    ledger_index: 'current',
+  }
+  const data = await client.request(request)
+  return data.result.account_data.Sequence
+}
+
 /**
  * Sets the next valid sequence number for a transaction.
  *
@@ -221,14 +238,8 @@ export async function setNextValidSequenceNumber(
   client: Client,
   tx: Transaction,
 ): Promise<void> {
-  const request: AccountInfoRequest = {
-    command: 'account_info',
-    account: tx.Account,
-    ledger_index: 'current',
-  }
-  const data = await client.request(request)
   // eslint-disable-next-line no-param-reassign, require-atomic-updates -- param reassign is safe with no race condition
-  tx.Sequence = data.result.account_data.Sequence
+  tx.Sequence = await getNextValidSequenceNumber(client, tx.Account)
 }
 
 /**
@@ -266,20 +277,27 @@ async function fetchGasPrice(client: Client): Promise<BigNumber> {
  * @param client - The client object.
  * @param tx - The transaction object.
  * @param [signersCount=0] - The number of signers (default is 0). Only used for multisigning.
- * @returns A promise that resolves with void. Modifies the `tx` parameter to give it the calculated fee.
+ * @returns A promise that returns the fee.
  */
-// eslint-disable-next-line max-lines-per-function -- okay here
-export async function calculateFeePerTransactionType(
+// eslint-disable-next-line max-lines-per-function -- needed here due to the complexity of the fee calculation
+async function calculateFeePerTransactionType(
   client: Client,
   tx: Transaction,
   signersCount = 0,
-): Promise<void> {
+): Promise<BigNumber> {
   const netFeeXRP = await getFeeXrp(client)
   const netFeeDrops = new BigNumber(xrpToDrops(netFeeXRP))
   let baseFee = netFeeDrops
 
-  // EscrowFinish Transaction with Fulfillment/ComputationAllowance
-  if (tx.TransactionType === 'EscrowFinish') {
+  const isSpecialTxCost = ['AccountDelete', 'AMMCreate'].includes(
+    tx.TransactionType,
+  )
+
+  // EscrowCreate transaction with FinishFunction
+  if (tx.TransactionType === 'EscrowCreate' && tx.FinishFunction != null) {
+    baseFee = baseFee.plus(1000)
+  } 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))
@@ -295,17 +313,17 @@ export async function calculateFeePerTransactionType(
         .dividedBy(MICRO_DROPS_PER_DROP)
       baseFee = baseFee.plus(extraFee)
     }
-  }
-  // EscrowCreate transaction with FinishFunction
-  if (tx.TransactionType === 'EscrowCreate' && tx.FinishFunction != null) {
-    baseFee = baseFee.plus(1000)
-  }
-
-  const isSpecialTxCost = ['AccountDelete', 'AMMCreate'].includes(
-    tx.TransactionType,
-  )
-
-  if (isSpecialTxCost) {
+  } 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)
   }
 
@@ -314,7 +332,7 @@ export async function calculateFeePerTransactionType(
    * BaseFee × (1 + Number of Signatures Provided)
    */
   if (signersCount > 0) {
-    baseFee = BigNumber.sum(baseFee, netFeeDrops.multipliedBy(1 + signersCount))
+    baseFee = BigNumber.sum(baseFee, netFeeDrops.multipliedBy(signersCount))
   }
 
   const maxFeeDrops = xrpToDrops(client.maxFeeXRP)
@@ -323,8 +341,25 @@ export async function calculateFeePerTransactionType(
     : BigNumber.min(baseFee, maxFeeDrops)
 
   // Round up baseFee and return it as a string
-  // eslint-disable-next-line no-param-reassign, @typescript-eslint/no-magic-numbers, require-atomic-updates -- safe reassignment.
-  tx.Fee = totalFee.dp(0, BigNumber.ROUND_CEIL).toString(10)
+  return totalFee.dp(0, BigNumber.ROUND_CEIL)
+}
+
+/**
+ * Calculates the fee per transaction type and sets it in the transaction.
+ *
+ * @param client - The client object.
+ * @param tx - The transaction object.
+ * @param [signersCount=0] - The number of signers (default is 0). Only used for multisigning.
+ * @returns A promise that resolves with void. Modifies the `tx` parameter to give it the calculated fee.
+ */
+export async function getTransactionFee(
+  client: Client,
+  tx: Transaction,
+  signersCount = 0,
+): Promise<void> {
+  const fee = await calculateFeePerTransactionType(client, tx, signersCount)
+  // eslint-disable-next-line @typescript-eslint/no-magic-numbers, require-atomic-updates, no-param-reassign -- fine here
+  tx.Fee = fee.toString(10)
 }
 
 /**
@@ -373,3 +408,98 @@ export async function checkAccountDeleteBlockers(
     resolve()
   })
 }
+
+/**
+ * Replaces Amount with DeliverMax if needed.
+ *
+ * @param tx - The transaction object.
+ * @throws ValidationError if Amount and DeliverMax are both provided but do not match.
+ */
+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
+    }
+
+    // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition -- needed here
+    if (tx.Amount != null && tx.Amount !== tx.DeliverMax) {
+      throw new ValidationError(
+        'PaymentTransaction: Amount and DeliverMax fields must be identical when both are provided',
+      )
+    }
+
+    // eslint-disable-next-line no-param-reassign -- needed here
+    delete tx.DeliverMax
+  }
+}
+
+/**
+ * Autofills all the relevant `x` fields.
+ *
+ * @param client - The client object.
+ * @param tx - The transaction object.
+ * @returns A promise that resolves with void if there are no blockers, or rejects with an XrplError if there are blockers.
+ */
+// eslint-disable-next-line complexity, max-lines-per-function -- needed here, lots to check
+export async function autofillBatchTxn(
+  client: Client,
+  tx: Batch,
+): Promise<void> {
+  const accountSequences: Record<string, number> = {}
+
+  for await (const rawTxn of tx.RawTransactions) {
+    const txn = rawTxn.RawTransaction
+
+    // Sequence processing
+    if (txn.Sequence == null && txn.TicketSequence == null) {
+      if (txn.Account in accountSequences) {
+        txn.Sequence = accountSequences[txn.Account]
+        accountSequences[txn.Account] += 1
+      } else {
+        const nextSequence = await getNextValidSequenceNumber(
+          client,
+          txn.Account,
+        )
+        const sequence =
+          txn.Account === tx.Account ? nextSequence + 1 : nextSequence
+        accountSequences[txn.Account] = sequence + 1
+        txn.Sequence = sequence
+      }
+    }
+
+    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.')
+    }
+
+    if (txn.NetworkID == null && txNeedsNetworkID(client)) {
+      txn.NetworkID = client.networkID
+    }
+  }
+}

package/src/sugar/submit.ts

@@ -175,7 +175,6 @@ function isSigned(transaction: SubmittableTransaction | string): boolean {
     // eslint-disable-next-line @typescript-eslint/consistent-type-assertions -- we know that tx.Signers is an array of Signers
     const signers = tx.Signers as Signer[]
     for (const signer of signers) {
-      // eslint-disable-next-line max-depth -- necessary for checking if signer is signed
       if (
         // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition -- necessary check
         signer.Signer.SigningPubKey == null ||
@@ -283,7 +282,7 @@ export function getLastLedgerSequence(
   transaction: Transaction | string,
 ): number | null {
   const tx = typeof transaction === 'string' ? decode(transaction) : transaction
-  // eslint-disable-next-line @typescript-eslint/consistent-type-assertions -- converts LastLedgSeq to number if present.
+  // eslint-disable-next-line @typescript-eslint/consistent-type-assertions -- converts LastLedgerSeq to number if present.
   return tx.LastLedgerSequence as number | null
 }
 

package/src/utils/hashes/hashLedger.ts

@@ -12,6 +12,8 @@ import { APIVersion } from '../../models'
 import { LedgerEntry } from '../../models/ledger'
 import { LedgerVersionMap } from '../../models/ledger/Ledger'
 import { Transaction, TransactionMetadata } from '../../models/transactions'
+import { GlobalFlags } from '../../models/transactions/common'
+import { hasFlag } from '../../models/utils'
 
 import HashPrefix from './HashPrefix'
 import sha512Half from './sha512Half'
@@ -66,7 +68,7 @@ function addLengthPrefix(hex: string): string {
  *
  * @param tx - A transaction to hash. Tx may be in binary blob form. Tx must be signed.
  * @returns A hash of tx.
- * @throws ValidationError if the Transaction is unsigned.\
+ * @throws ValidationError if the Transaction is unsigned.
  * @category Utilities
  */
 export function hashSignedTx(tx: Transaction | string): string {
@@ -84,7 +86,8 @@ export function hashSignedTx(tx: Transaction | string): string {
   if (
     txObject.TxnSignature === undefined &&
     txObject.Signers === undefined &&
-    txObject.SigningPubKey === undefined
+    txObject.SigningPubKey === undefined &&
+    !hasFlag(txObject, GlobalFlags.tfInnerBatchTxn, 'tfInnerBatchTxn')
   ) {
     throw new ValidationError('The transaction must be signed to hash it.')
   }