xrpl 5.0.0 → 5.1.0-batch.1

package/build/xrpl-latest.js

@@ -1831,28 +1831,52 @@ function multiSigningData(transaction, signingAccount, opts = {
 }
 exports.multiSigningData = multiSigningData;
 /**
- * Serialize a signingClaim
+ * Serialize an XLS-56 Batch V1_1 signing payload:
+ *   HashPrefix.batch | account | sequence | flags | txIDCount | txIDs[]
+ *   [ | batchAccount [ | signerAccount ] ]
  *
  * @param batch A Batch object to serialize.
  * @returns the serialized object with appropriate prefix
  */
 function signingBatchData(batch) {
+    if (batch.account == null) {
+        throw Error('No field `account`');
+    }
+    if (batch.sequence == null) {
+        throw Error('No field `sequence`');
+    }
     if (batch.flags == null) {
-        throw Error("No field `flags'");
+        throw Error('No field `flags`');
     }
     if (batch.txIDs == null) {
         throw Error('No field `txIDs`');
     }
     const prefix = hash_prefixes_1.HashPrefix.batch;
+    const account = types_1.coreTypes.AccountID.from(batch.account).toBytes();
+    const sequence = types_1.coreTypes.UInt32.from(batch.sequence).toBytes();
     const flags = types_1.coreTypes.UInt32.from(batch.flags).toBytes();
     const txIDsLength = types_1.coreTypes.UInt32.from(batch.txIDs.length).toBytes();
     const bytesList = new binary_serializer_1.BytesList();
     bytesList.put(prefix);
+    bytesList.put(account);
+    bytesList.put(sequence);
     bytesList.put(flags);
     bytesList.put(txIDsLength);
     batch.txIDs.forEach((txID) => {
         bytesList.put(types_1.coreTypes.Hash256.from(txID).toBytes());
     });
+    if (batch.batchAccount != null) {
+        bytesList.put(types_1.coreTypes.AccountID.from(batch.batchAccount).toBytes());
+    }
+    // The wire format is positional, so `signerAccount` must follow `batchAccount`.
+    // Reject `signerAccount` without `batchAccount` to avoid binding the signature
+    // to the wrong account.
+    if (batch.signerAccount != null) {
+        if (batch.batchAccount == null) {
+            throw Error('Field `signerAccount` requires `batchAccount`');
+        }
+        bytesList.put(types_1.coreTypes.AccountID.from(batch.signerAccount).toBytes());
+    }
     return bytesList.toBytes();
 }
 exports.signingBatchData = signingBatchData;
@@ -6620,6 +6644,14 @@ function constructBatchSignerObject(batchAccount, wallet, signature, multisignAd
     }
     return batchSigner;
 }
+function getBatchSeqValue(transaction) {
+    var _a, _b;
+    const sequence = (_a = transaction.Sequence) !== null && _a !== void 0 ? _a : 0;
+    if (sequence !== 0) {
+        return sequence;
+    }
+    return (_b = transaction.TicketSequence) !== null && _b !== void 0 ? _b : 0;
+}
 function signMultiBatch(wallet, transaction, opts = {}) {
     var _a;
     const batchAccount = (_a = opts.batchAccount) !== null && _a !== void 0 ? _a : wallet.classicAddress;
@@ -6634,14 +6666,19 @@ function signMultiBatch(wallet, transaction, opts = {}) {
         throw new errors_1.ValidationError('Must be a Batch transaction.');
     }
     (0, models_1.validate)(transaction);
-    const involvedAccounts = new Set(transaction.RawTransactions.map((raw) => raw.RawTransaction.Account));
+    const involvedAccounts = new Set();
+    transaction.RawTransactions.forEach((raw) => {
+        involvedAccounts.add(raw.RawTransaction.Account);
+        const counterparty = raw.RawTransaction
+            .Counterparty;
+        if (typeof counterparty === 'string') {
+            involvedAccounts.add(counterparty);
+        }
+    });
     if (!involvedAccounts.has(batchAccount)) {
         throw new errors_1.ValidationError('Must be signing for an address submitting a transaction in the Batch.');
     }
-    const fieldsToSign = {
-        flags: transaction.Flags,
-        txIDs: transaction.RawTransactions.map((rawTx) => (0, hashes_1.hashSignedTx)(rawTx.RawTransaction)),
-    };
+    const fieldsToSign = Object.assign({ account: transaction.Account, sequence: getBatchSeqValue(transaction), flags: transaction.Flags, txIDs: transaction.RawTransactions.map((rawTx) => (0, hashes_1.hashSignedTx)(rawTx.RawTransaction)), batchAccount }, (multisignAddress ? { signerAccount: multisignAddress } : {}));
     const signature = (0, ripple_keypairs_1.sign)((0, ripple_binary_codec_1.encodeForSigningBatch)(fieldsToSign), wallet.privateKey);
     transaction.BatchSigners = [
         constructBatchSignerObject(batchAccount, wallet, signature, multisignAddress),
@@ -6672,24 +6709,38 @@ function combineBatchSigners(transactions) {
     return (0, ripple_binary_codec_1.encode)(getTransactionWithAllBatchSigners(batchTransactions));
 }
 exports.combineBatchSigners = combineBatchSigners;
-function validateBatchTransactionEquivalence(transactions) {
-    const exampleTransaction = JSON.stringify({
-        flags: transactions[0].Flags,
-        transactionIDs: transactions[0].RawTransactions.map((rawTx) => (0, hashes_1.hashSignedTx)(rawTx.RawTransaction)),
-    });
-    if (transactions.slice(1).some((tx) => JSON.stringify({
+function getBatchEquivalenceKey(tx) {
+    return JSON.stringify({
+        account: tx.Account,
+        sequence: getBatchSeqValue(tx),
         flags: tx.Flags,
         transactionIDs: tx.RawTransactions.map((rawTx) => (0, hashes_1.hashSignedTx)(rawTx.RawTransaction)),
-    }) !== exampleTransaction)) {
-        throw new errors_1.ValidationError('Flags and transaction hashes are not the same for all provided transactions.');
+    });
+}
+function validateBatchTransactionEquivalence(transactions) {
+    const exampleTransaction = getBatchEquivalenceKey(transactions[0]);
+    if (transactions
+        .slice(1)
+        .some((tx) => getBatchEquivalenceKey(tx) !== exampleTransaction)) {
+        throw new errors_1.ValidationError('Account, sequence, flags, and transaction hashes must be the same for all provided transactions.');
     }
 }
 function getTransactionWithAllBatchSigners(transactions) {
+    const outerAccount = transactions[0].Account;
     const sortedSigners = transactions
         .flatMap((tx) => { var _a; return (_a = tx.BatchSigners) !== null && _a !== void 0 ? _a : []; })
-        .filter((signer) => signer.BatchSigner.Account !== transactions[0].Account)
+        .filter((signer) => signer.BatchSigner.Account !== outerAccount)
         .sort((signer1, signer2) => (0, utils_1.compareSigners)(signer1.BatchSigner, signer2.BatchSigner));
-    return Object.assign(Object.assign({}, transactions[0]), { BatchSigners: sortedSigners });
+    const dedupedSigners = [];
+    let lastAccount = '';
+    for (const signer of sortedSigners) {
+        const account = signer.BatchSigner.Account;
+        if (account !== lastAccount) {
+            dedupedSigners.push(signer);
+            lastAccount = account;
+        }
+    }
+    return Object.assign(Object.assign({}, transactions[0]), { BatchSigners: dedupedSigners });
 }