@bitgo-beta/abstract-utxo 1.1.1-beta.222 → 1.1.1-beta.2221

package/dist/esm/transaction/fixedScript/parseTransaction.js

@@ -0,0 +1,221 @@
+import assert from 'assert';
+import _ from 'lodash';
+import { KeyIndices } from '@bitgo-beta/sdk-core';
+import { fetchKeychains, getKeySignatures, toKeychainTriple, toXpubTriple, UtxoNamedKeychains, } from '../../keychains';
+import { verifyKeySignature } from '../../verifyKey';
+import { assertValidTransactionRecipient, fromExtendedAddressFormatToScript, isScriptRecipient, toExtendedAddressFormat, toOutputScript, } from '../recipient';
+import { outputDifference } from '../outputDifference';
+import { toTNumber } from '../../tnumber';
+import { parseOutput } from './parseOutput';
+function toCanonicalTransactionRecipient(coin, output) {
+    const amount = BigInt(output.valueString);
+    assertValidTransactionRecipient({ amount, address: output.address });
+    assert(output.address, 'address is required');
+    if (isScriptRecipient(output.address)) {
+        return { amount, address: output.address };
+    }
+    return { amount, address: coin.canonicalAddress(output.address) };
+}
+async function parseRbfTransaction(coin, params) {
+    const { txParams, wallet } = params;
+    assert(txParams.rbfTxIds);
+    assert(txParams.rbfTxIds.length === 1);
+    const txToBeReplaced = await wallet.getTransaction({ txHash: txParams.rbfTxIds[0], includeRbf: true });
+    const recipients = txToBeReplaced.outputs.flatMap((output) => {
+        // For self-sends, the walletId will be the same as the wallet's id
+        if (output.wallet === wallet.id()) {
+            return [];
+        }
+        return [toCanonicalTransactionRecipient(coin, output)];
+    });
+    // Recurse into parseTransaction with the derived recipients and without rbfTxIds
+    return parseTransaction(coin, {
+        ...params,
+        txParams: {
+            ...txParams,
+            recipients,
+            rbfTxIds: undefined,
+        },
+    });
+}
+function toExpectedOutputs(coin, txParams) {
+    // verify that each recipient from txParams has their own output
+    const expectedOutputs = (txParams.recipients ?? []).flatMap((output) => {
+        if (output.address === undefined) {
+            assert('script' in output, 'script is required for non-encodeable scriptPubkeys');
+            if (output.amount.toString() !== '0') {
+                throw new Error(`Only zero amounts allowed for non-encodeable scriptPubkeys: ${output}`);
+            }
+            return [
+                {
+                    script: toOutputScript(output, coin.name),
+                    value: output.amount === 'max' ? 'max' : BigInt(output.amount),
+                },
+            ];
+        }
+        return [
+            {
+                script: fromExtendedAddressFormatToScript(output.address, coin.name),
+                value: output.amount === 'max' ? 'max' : BigInt(output.amount),
+            },
+        ];
+    });
+    if (txParams.allowExternalChangeAddress && txParams.changeAddress) {
+        expectedOutputs.push({
+            script: toOutputScript(txParams.changeAddress, coin.name),
+            // When an external change address is explicitly specified, count all outputs going towards that
+            // address in the expected outputs (regardless of the output amount)
+            value: 'max',
+            // Note that the change output is not required to exist, so we mark it as optional.
+            optional: true,
+        });
+    }
+    return expectedOutputs;
+}
+function verifyCustomChangeKeys(userKeychain, customChange) {
+    for (const keyIndex of [KeyIndices.USER, KeyIndices.BACKUP, KeyIndices.BITGO]) {
+        if (!verifyKeySignature({
+            userKeychain,
+            keychainToVerify: customChange.keys[keyIndex],
+            keySignature: customChange.signatures[keyIndex],
+        })) {
+            throw new Error(`failed to verify custom change ${KeyIndices[keyIndex].toLowerCase()} key signature`);
+        }
+    }
+}
+export async function parseTransaction(coin, params) {
+    const { txParams, txPrebuild, wallet, verification = {}, reqId } = params;
+    // Branch off early for RBF transactions
+    if (txParams.rbfTxIds) {
+        return parseRbfTransaction(coin, params);
+    }
+    if (!_.isUndefined(verification.disableNetworking) && !_.isBoolean(verification.disableNetworking)) {
+        throw new Error('verification.disableNetworking must be a boolean');
+    }
+    const disableNetworking = verification.disableNetworking;
+    // obtain the keychains and key signatures
+    let keychains = verification.keychains;
+    if (!keychains) {
+        if (disableNetworking) {
+            throw new Error('cannot fetch keychains without networking');
+        }
+        keychains = await fetchKeychains(coin, wallet, reqId);
+    }
+    if (!UtxoNamedKeychains.is(keychains)) {
+        throw new Error('invalid keychains');
+    }
+    const keychainArray = toKeychainTriple(keychains);
+    const effectiveTxHex = txPrebuild.txHexPsbt ?? txPrebuild.txHex;
+    if (_.isUndefined(effectiveTxHex)) {
+        throw new Error('missing required txPrebuild property txHex');
+    }
+    const expectedOutputs = toExpectedOutputs(coin, txParams);
+    // get the keychains from the custom change wallet if needed
+    let customChange;
+    const { customChangeWalletId = undefined } = wallet.coinSpecific() || {};
+    if (customChangeWalletId) {
+        // fetch keychains from custom change wallet for deriving addresses.
+        // These keychains should be signed and this should be verified in verifyTransaction
+        const customChangeKeySignatures = wallet._wallet.customChangeKeySignatures;
+        const customChangeWallet = await coin.wallets().get({ id: customChangeWalletId });
+        const customChangeKeys = await fetchKeychains(coin, customChangeWallet, reqId);
+        if (!customChangeKeys) {
+            throw new Error('failed to fetch keychains for custom change wallet');
+        }
+        if (customChangeKeys.user && customChangeKeys.backup && customChangeKeys.bitgo && customChangeWallet) {
+            const customChangeKeychains = [
+                customChangeKeys.user,
+                customChangeKeys.backup,
+                customChangeKeys.bitgo,
+            ];
+            customChange = {
+                keys: customChangeKeychains,
+                signatures: [customChangeKeySignatures.user, customChangeKeySignatures.backup, customChangeKeySignatures.bitgo],
+            };
+        }
+    }
+    let customChangeXpubs;
+    if (customChange) {
+        verifyCustomChangeKeys(keychainArray[KeyIndices.USER], customChange);
+        customChangeXpubs = toXpubTriple(customChange.keys);
+    }
+    // obtain all outputs
+    const explanation = await coin.explainTransaction({
+        txHex: effectiveTxHex,
+        txInfo: txPrebuild.txInfo,
+        pubs: keychainArray.map((k) => k.pub),
+        customChangeXpubs,
+    });
+    const allOutputs = [...explanation.outputs, ...explanation.changeOutputs];
+    /**
+     * Loop through all the outputs and classify each of them as either internal spends
+     * or external spends by setting the "external" property to true or false on the output object.
+     */
+    const allOutputDetails = await Promise.all(allOutputs.map((currentOutput) => {
+        return parseOutput({
+            currentOutput,
+            coin,
+            txPrebuild,
+            verification,
+            keychainArray: toKeychainTriple(keychains),
+            wallet,
+            txParams: {
+                recipients: txParams.recipients ?? [],
+                changeAddress: txParams.changeAddress,
+            },
+            customChange,
+            reqId,
+        });
+    }));
+    const needsCustomChangeKeySignatureVerification = allOutputDetails.some((output) => output?.needsCustomChangeKeySignatureVerification);
+    const changeOutputs = _.filter(allOutputDetails, { external: false });
+    function toComparableOutputsWithExternal(outputs) {
+        return outputs.map((output) => ({
+            script: fromExtendedAddressFormatToScript(output.address, coin.name),
+            value: output.amount === 'max' ? 'max' : BigInt(output.amount),
+            external: output.external,
+        }));
+    }
+    const missingOutputs = outputDifference(expectedOutputs, toComparableOutputsWithExternal(allOutputs));
+    const implicitOutputs = outputDifference(toComparableOutputsWithExternal(allOutputDetails), expectedOutputs);
+    const explicitOutputs = outputDifference(toComparableOutputsWithExternal(allOutputDetails), implicitOutputs);
+    // these are all the non-wallet outputs that had been originally explicitly specified in recipients
+    const explicitExternalOutputs = explicitOutputs.filter((output) => output.external);
+    // this is the sum of all the originally explicitly specified non-wallet output values
+    const explicitExternalSpendAmount = toTNumber(explicitExternalOutputs.reduce((sum, o) => sum + BigInt(o.value), BigInt(0)), coin.amountType);
+    /**
+     * The calculation of the implicit external spend amount pertains to verifying the pay-as-you-go-fee BitGo
+     * automatically applied to transactions sending money out of the wallet. The logic is fairly straightforward
+     * in that we compare the external spend amount that was specified explicitly by the user to the portion
+     * that was specified implicitly. To protect customers from people tampering with the transaction outputs, we
+     * define a threshold for the maximum percentage of the implicit external spend in relation to the explicit
+     * external spend.
+     *
+     * This has become obsolete with the intoduction of `utxocore.paygo.verifyPayGoAddressProof()`.
+     */
+    // make sure that all the extra addresses are change addresses
+    // get all the additional external outputs the server added and calculate their values
+    const implicitExternalOutputs = implicitOutputs.filter((output) => output.external);
+    const implicitExternalSpendAmount = toTNumber(implicitExternalOutputs.reduce((sum, o) => sum + BigInt(o.value), BigInt(0)), coin.amountType);
+    function toOutputs(outputs) {
+        return outputs.map((output) => ({
+            address: toExtendedAddressFormat(output.script, coin.name),
+            amount: output.value.toString(),
+            external: output.external,
+        }));
+    }
+    return {
+        keychains,
+        keySignatures: getKeySignatures(wallet) ?? {},
+        outputs: allOutputDetails,
+        missingOutputs: toOutputs(missingOutputs),
+        explicitExternalOutputs: toOutputs(explicitExternalOutputs),
+        implicitExternalOutputs: toOutputs(implicitExternalOutputs),
+        changeOutputs,
+        explicitExternalSpendAmount,
+        implicitExternalSpendAmount,
+        needsCustomChangeKeySignatureVerification,
+        customChange,
+    };
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"parseTransaction.js","sourceRoot":"","sources":["../../../../src/transaction/fixedScript/parseTransaction.ts"],"names":[],"mappings":"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","sourcesContent":["import assert from 'assert';\n\nimport _ from 'lodash';\nimport { ITransactionRecipient, KeyIndices, Triple, VerificationOptions, Wallet } from '@bitgo-beta/sdk-core';\n\nimport type { AbstractUtxoCoin, ParseTransactionOptions } from '../../abstractUtxoCoin';\nimport type { FixedScriptWalletOutput, Output, ParsedTransaction } from '../types';\nimport {\n  fetchKeychains,\n  getKeySignatures,\n  toKeychainTriple,\n  toXpubTriple,\n  UtxoKeychain,\n  UtxoNamedKeychains,\n} from '../../keychains';\nimport { verifyKeySignature } from '../../verifyKey';\nimport {\n  assertValidTransactionRecipient,\n  fromExtendedAddressFormatToScript,\n  isScriptRecipient,\n  toExtendedAddressFormat,\n  toOutputScript,\n} from '../recipient';\nimport { ComparableOutput, ExpectedOutput, outputDifference } from '../outputDifference';\nimport { toTNumber } from '../../tnumber';\n\nimport type { TransactionExplanation } from './explainTransaction';\nimport { CustomChangeOptions, parseOutput } from './parseOutput';\n\nexport type ComparableOutputWithExternal<TValue> = (ComparableOutput<TValue> | ExpectedOutput) & {\n  external: boolean | undefined;\n};\n\nfunction toCanonicalTransactionRecipient(\n  coin: AbstractUtxoCoin,\n  output: { valueString: string; address?: string }\n): {\n  amount: bigint;\n  address: string;\n} {\n  const amount = BigInt(output.valueString);\n  assertValidTransactionRecipient({ amount, address: output.address });\n  assert(output.address, 'address is required');\n  if (isScriptRecipient(output.address)) {\n    return { amount, address: output.address };\n  }\n  return { amount, address: coin.canonicalAddress(output.address) };\n}\n\nasync function parseRbfTransaction<TNumber extends bigint | number>(\n  coin: AbstractUtxoCoin,\n  params: ParseTransactionOptions<TNumber>\n): Promise<ParsedTransaction<TNumber>> {\n  const { txParams, wallet } = params;\n\n  assert(txParams.rbfTxIds);\n  assert(txParams.rbfTxIds.length === 1);\n\n  const txToBeReplaced = await wallet.getTransaction({ txHash: txParams.rbfTxIds[0], includeRbf: true });\n  const recipients = txToBeReplaced.outputs.flatMap(\n    (output: { valueString: string; address?: string; wallet?: string }) => {\n      // For self-sends, the walletId will be the same as the wallet's id\n      if (output.wallet === wallet.id()) {\n        return [];\n      }\n      return [toCanonicalTransactionRecipient(coin, output)];\n    }\n  );\n\n  // Recurse into parseTransaction with the derived recipients and without rbfTxIds\n  return parseTransaction(coin, {\n    ...params,\n    txParams: {\n      ...txParams,\n      recipients,\n      rbfTxIds: undefined,\n    },\n  });\n}\n\nfunction toExpectedOutputs(\n  coin: AbstractUtxoCoin,\n  txParams: {\n    recipients?: ITransactionRecipient[];\n    allowExternalChangeAddress?: boolean;\n    changeAddress?: string;\n  }\n): ExpectedOutput[] {\n  // verify that each recipient from txParams has their own output\n  const expectedOutputs: ExpectedOutput[] = (txParams.recipients ?? []).flatMap((output) => {\n    if (output.address === undefined) {\n      assert('script' in output, 'script is required for non-encodeable scriptPubkeys');\n      if (output.amount.toString() !== '0') {\n        throw new Error(`Only zero amounts allowed for non-encodeable scriptPubkeys: ${output}`);\n      }\n      return [\n        {\n          script: toOutputScript(output, coin.name),\n          value: output.amount === 'max' ? 'max' : BigInt(output.amount),\n        },\n      ];\n    }\n    return [\n      {\n        script: fromExtendedAddressFormatToScript(output.address, coin.name),\n        value: output.amount === 'max' ? 'max' : BigInt(output.amount),\n      },\n    ];\n  });\n  if (txParams.allowExternalChangeAddress && txParams.changeAddress) {\n    expectedOutputs.push({\n      script: toOutputScript(txParams.changeAddress, coin.name),\n      // When an external change address is explicitly specified, count all outputs going towards that\n      // address in the expected outputs (regardless of the output amount)\n      value: 'max',\n      // Note that the change output is not required to exist, so we mark it as optional.\n      optional: true,\n    });\n  }\n  return expectedOutputs;\n}\n\nfunction verifyCustomChangeKeys(userKeychain: UtxoKeychain, customChange: CustomChangeOptions): void {\n  for (const keyIndex of [KeyIndices.USER, KeyIndices.BACKUP, KeyIndices.BITGO]) {\n    if (\n      !verifyKeySignature({\n        userKeychain,\n        keychainToVerify: customChange.keys[keyIndex],\n        keySignature: customChange.signatures[keyIndex],\n      })\n    ) {\n      throw new Error(`failed to verify custom change ${KeyIndices[keyIndex].toLowerCase()} key signature`);\n    }\n  }\n}\n\nexport async function parseTransaction<TNumber extends bigint | number>(\n  coin: AbstractUtxoCoin,\n  params: ParseTransactionOptions<TNumber>\n): Promise<ParsedTransaction<TNumber>> {\n  const { txParams, txPrebuild, wallet, verification = {}, reqId } = params;\n\n  // Branch off early for RBF transactions\n  if (txParams.rbfTxIds) {\n    return parseRbfTransaction(coin, params);\n  }\n\n  if (!_.isUndefined(verification.disableNetworking) && !_.isBoolean(verification.disableNetworking)) {\n    throw new Error('verification.disableNetworking must be a boolean');\n  }\n  const disableNetworking = verification.disableNetworking;\n\n  // obtain the keychains and key signatures\n  let keychains: UtxoNamedKeychains | VerificationOptions['keychains'] | undefined = verification.keychains;\n  if (!keychains) {\n    if (disableNetworking) {\n      throw new Error('cannot fetch keychains without networking');\n    }\n    keychains = await fetchKeychains(coin, wallet, reqId);\n  }\n\n  if (!UtxoNamedKeychains.is(keychains)) {\n    throw new Error('invalid keychains');\n  }\n\n  const keychainArray: Triple<UtxoKeychain> = toKeychainTriple(keychains);\n\n  const effectiveTxHex = txPrebuild.txHexPsbt ?? txPrebuild.txHex;\n  if (_.isUndefined(effectiveTxHex)) {\n    throw new Error('missing required txPrebuild property txHex');\n  }\n\n  const expectedOutputs = toExpectedOutputs(coin, txParams);\n\n  // get the keychains from the custom change wallet if needed\n  let customChange: CustomChangeOptions | undefined;\n  const { customChangeWalletId = undefined } = wallet.coinSpecific() || {};\n  if (customChangeWalletId) {\n    // fetch keychains from custom change wallet for deriving addresses.\n    // These keychains should be signed and this should be verified in verifyTransaction\n    const customChangeKeySignatures = wallet._wallet.customChangeKeySignatures;\n    const customChangeWallet: Wallet = await coin.wallets().get({ id: customChangeWalletId });\n    const customChangeKeys = await fetchKeychains(coin, customChangeWallet, reqId);\n\n    if (!customChangeKeys) {\n      throw new Error('failed to fetch keychains for custom change wallet');\n    }\n\n    if (customChangeKeys.user && customChangeKeys.backup && customChangeKeys.bitgo && customChangeWallet) {\n      const customChangeKeychains: Triple<UtxoKeychain> = [\n        customChangeKeys.user,\n        customChangeKeys.backup,\n        customChangeKeys.bitgo,\n      ];\n\n      customChange = {\n        keys: customChangeKeychains,\n        signatures: [customChangeKeySignatures.user, customChangeKeySignatures.backup, customChangeKeySignatures.bitgo],\n      };\n    }\n  }\n\n  let customChangeXpubs: Triple<string> | undefined;\n  if (customChange) {\n    verifyCustomChangeKeys(keychainArray[KeyIndices.USER], customChange);\n    customChangeXpubs = toXpubTriple(customChange.keys);\n  }\n\n  // obtain all outputs\n  const explanation: TransactionExplanation = await coin.explainTransaction<TNumber>({\n    txHex: effectiveTxHex,\n    txInfo: txPrebuild.txInfo,\n    pubs: keychainArray.map((k) => k.pub) as Triple<string>,\n    customChangeXpubs,\n  });\n\n  const allOutputs = [...explanation.outputs, ...explanation.changeOutputs];\n\n  /**\n   * Loop through all the outputs and classify each of them as either internal spends\n   * or external spends by setting the \"external\" property to true or false on the output object.\n   */\n  const allOutputDetails: Output[] = await Promise.all(\n    allOutputs.map((currentOutput) => {\n      return parseOutput({\n        currentOutput,\n        coin,\n        txPrebuild,\n        verification,\n        keychainArray: toKeychainTriple(keychains),\n        wallet,\n        txParams: {\n          recipients: txParams.recipients ?? [],\n          changeAddress: txParams.changeAddress,\n        },\n        customChange,\n        reqId,\n      });\n    })\n  );\n\n  const needsCustomChangeKeySignatureVerification = allOutputDetails.some(\n    (output) => (output as FixedScriptWalletOutput)?.needsCustomChangeKeySignatureVerification\n  );\n\n  const changeOutputs = _.filter(allOutputDetails, { external: false });\n\n  function toComparableOutputsWithExternal(outputs: Output[]): ComparableOutputWithExternal<bigint | 'max'>[] {\n    return outputs.map((output) => ({\n      script: fromExtendedAddressFormatToScript(output.address, coin.name),\n      value: output.amount === 'max' ? 'max' : (BigInt(output.amount) as bigint | 'max'),\n      external: output.external,\n    }));\n  }\n\n  const missingOutputs = outputDifference(expectedOutputs, toComparableOutputsWithExternal(allOutputs));\n\n  const implicitOutputs = outputDifference(toComparableOutputsWithExternal(allOutputDetails), expectedOutputs);\n  const explicitOutputs = outputDifference(toComparableOutputsWithExternal(allOutputDetails), implicitOutputs);\n\n  // these are all the non-wallet outputs that had been originally explicitly specified in recipients\n  const explicitExternalOutputs = explicitOutputs.filter((output) => output.external);\n  // this is the sum of all the originally explicitly specified non-wallet output values\n  const explicitExternalSpendAmount = toTNumber(\n    explicitExternalOutputs.reduce((sum: bigint, o) => sum + BigInt(o.value), BigInt(0)),\n    coin.amountType\n  ) as TNumber;\n\n  /**\n   * The calculation of the implicit external spend amount pertains to verifying the pay-as-you-go-fee BitGo\n   * automatically applied to transactions sending money out of the wallet. The logic is fairly straightforward\n   * in that we compare the external spend amount that was specified explicitly by the user to the portion\n   * that was specified implicitly. To protect customers from people tampering with the transaction outputs, we\n   * define a threshold for the maximum percentage of the implicit external spend in relation to the explicit\n   * external spend.\n   *\n   * This has become obsolete with the intoduction of `utxocore.paygo.verifyPayGoAddressProof()`.\n   */\n\n  // make sure that all the extra addresses are change addresses\n  // get all the additional external outputs the server added and calculate their values\n  const implicitExternalOutputs = implicitOutputs.filter((output) => output.external);\n  const implicitExternalSpendAmount = toTNumber(\n    implicitExternalOutputs.reduce((sum: bigint, o) => sum + BigInt(o.value), BigInt(0)),\n    coin.amountType\n  ) as TNumber;\n\n  function toOutputs(outputs: ExpectedOutput[] | ComparableOutputWithExternal<bigint | 'max'>[]): Output[] {\n    return outputs.map((output) => ({\n      address: toExtendedAddressFormat(output.script, coin.name),\n      amount: output.value.toString(),\n      external: output.external,\n    }));\n  }\n\n  return {\n    keychains,\n    keySignatures: getKeySignatures(wallet) ?? {},\n    outputs: allOutputDetails,\n    missingOutputs: toOutputs(missingOutputs),\n    explicitExternalOutputs: toOutputs(explicitExternalOutputs),\n    implicitExternalOutputs: toOutputs(implicitExternalOutputs),\n    changeOutputs,\n    explicitExternalSpendAmount,\n    implicitExternalSpendAmount,\n    needsCustomChangeKeySignatureVerification,\n    customChange,\n  };\n}\n"]}

package/dist/esm/transaction/fixedScript/replayProtection.d.ts

@@ -0,0 +1,10 @@
+import { type AddressFormat } from '@bitgo/wasm-utxo';
+import { UtxoCoinName } from '../../names';
+export declare const pubkeyProd: Buffer<ArrayBuffer>;
+export declare const pubkeyTestnet: Buffer<ArrayBuffer>;
+export declare function getReplayProtectionPubkeys(coinName: UtxoCoinName): Buffer[];
+export declare function getReplayProtectionAddresses(coinName: UtxoCoinName, format?: AddressFormat): string[];
+export declare function isReplayProtectionUnspent(u: {
+    address: string;
+}, coinName: UtxoCoinName): boolean;
+//# sourceMappingURL=replayProtection.d.ts.map

package/dist/esm/transaction/fixedScript/replayProtection.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"replayProtection.d.ts","sourceRoot":"","sources":["../../../../src/transaction/fixedScript/replayProtection.ts"],"names":[],"mappings":"AAAA,OAAO,EAAW,KAAK,aAAa,EAAE,MAAM,kBAAkB,CAAC;AAE/D,OAAO,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAE3C,eAAO,MAAM,UAAU,qBAA2F,CAAC;AAEnH,eAAO,MAAM,aAAa,qBAA2F,CAAC;AAEtH,wBAAgB,0BAA0B,CAAC,QAAQ,EAAE,YAAY,GAAG,MAAM,EAAE,CAU3E;AAWD,wBAAgB,4BAA4B,CAAC,QAAQ,EAAE,YAAY,EAAE,MAAM,GAAE,aAAyB,GAAG,MAAM,EAAE,CAWhH;AAED,wBAAgB,yBAAyB,CAAC,CAAC,EAAE;IAAE,OAAO,EAAE,MAAM,CAAA;CAAE,EAAE,QAAQ,EAAE,YAAY,GAAG,OAAO,CAEjG"}

package/dist/esm/transaction/fixedScript/replayProtection.js

@@ -0,0 +1,38 @@
+import { address } from '@bitgo/wasm-utxo';
+export const pubkeyProd = Buffer.from('0255b9f71ac2c78fffd83e3e37b9e17ae70d5437b7f56d0ed2e93b7de08015aa59', 'hex');
+export const pubkeyTestnet = Buffer.from('0219da48412c2268865fe8c126327d1b12eee350a3b69eb09e3323cc9a11828945', 'hex');
+export function getReplayProtectionPubkeys(coinName) {
+    switch (coinName) {
+        case 'bch':
+        case 'bsv':
+            return [pubkeyProd];
+        case 'tbsv':
+        case 'tbch':
+            return [pubkeyTestnet];
+    }
+    return [];
+}
+// sh(pk(pubkeyProd))
+// 33p1q7mTGyeM5UnZERGiMcVUkY12SCsatA
+// bitcoincash:pqt5x9w0m6z0f3znjkkx79wl3l7ywrszesemp8xgpf
+const replayProtectionScriptsProd = [Buffer.from('a914174315cfde84f4c45395ac6f15df8ffc470e02cc87', 'hex')];
+// sh(pk(pubkeyTestnet))
+// 2MuMnPoSDgWEpNWH28X2nLtYMXQJCyT61eY
+// bchtest:pqtjmnzwqffkrk2349g3cecfwwjwxusvnq87n07cal
+const replayProtectionScriptsTestnet = [Buffer.from('a914172dcc4e025361d951a9511c670973a4e3720c9887', 'hex')];
+export function getReplayProtectionAddresses(coinName, format = 'default') {
+    switch (coinName) {
+        case 'bch':
+        case 'bsv':
+            return replayProtectionScriptsProd.map((script) => address.fromOutputScriptWithCoin(script, coinName, format));
+        case 'tbsv':
+        case 'tbch':
+            return replayProtectionScriptsTestnet.map((script) => address.fromOutputScriptWithCoin(script, coinName, format));
+        default:
+            return [];
+    }
+}
+export function isReplayProtectionUnspent(u, coinName) {
+    return getReplayProtectionAddresses(coinName).includes(u.address);
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/esm/transaction/fixedScript/signPsbtWasm.d.ts

@@ -0,0 +1,20 @@
+import { BIP32, bip32, ECPair, fixedScriptWallet } from '@bitgo/wasm-utxo';
+import { Musig2Participant } from './musig2';
+export type ReplayProtectionKeys = {
+    publicKeys: (Uint8Array | ECPair)[];
+};
+/**
+ * Sign all inputs of a PSBT and verify signatures after signing.
+ * Uses bulk signing for performance (signs all matching inputs in one pass).
+ * Collects and logs signing errors and verification errors, throws error in the end if any of them failed.
+ */
+export declare function signAndVerifyPsbtWasm(tx: fixedScriptWallet.BitGoPsbt, signerKeychain: bip32.BIP32Interface | BIP32, rootWalletKeys: fixedScriptWallet.RootWalletKeys, replayProtection: ReplayProtectionKeys, { writeSignedWith }?: {
+    writeSignedWith?: boolean;
+}): fixedScriptWallet.BitGoPsbt;
+export declare function signPsbtWithMusig2ParticipantWasm(coin: Musig2Participant<fixedScriptWallet.BitGoPsbt>, tx: fixedScriptWallet.BitGoPsbt, signerKeychain: bip32.BIP32Interface | undefined, rootWalletKeys: fixedScriptWallet.RootWalletKeys, params: {
+    replayProtection: ReplayProtectionKeys;
+    signingStep: 'signerNonce' | 'cosignerNonce' | 'signerSignature' | undefined;
+    walletId: string | undefined;
+    writeSignedWith?: boolean;
+}): Promise<fixedScriptWallet.BitGoPsbt>;
+//# sourceMappingURL=signPsbtWasm.d.ts.map

package/dist/esm/transaction/fixedScript/signPsbtWasm.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"signPsbtWasm.d.ts","sourceRoot":"","sources":["../../../../src/transaction/fixedScript/signPsbtWasm.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,KAAK,EAAE,KAAK,EAAE,MAAM,EAAE,iBAAiB,EAAsB,MAAM,kBAAkB,CAAC;AAG/F,OAAO,EAAE,iBAAiB,EAAE,MAAM,UAAU,CAAC;AAM7C,MAAM,MAAM,oBAAoB,GAAG;IACjC,UAAU,EAAE,CAAC,UAAU,GAAG,MAAM,CAAC,EAAE,CAAC;CACrC,CAAC;AAmBF;;;;GAIG;AACH,wBAAgB,qBAAqB,CACnC,EAAE,EAAE,iBAAiB,CAAC,SAAS,EAC/B,cAAc,EAAE,KAAK,CAAC,cAAc,GAAG,KAAK,EAC5C,cAAc,EAAE,iBAAiB,CAAC,cAAc,EAChD,gBAAgB,EAAE,oBAAoB,EACtC,EAAE,eAAuB,EAAE,GAAE;IAAE,eAAe,CAAC,EAAE,OAAO,CAAA;CAAO,GAC9D,iBAAiB,CAAC,SAAS,CAgD7B;AAED,wBAAsB,iCAAiC,CACrD,IAAI,EAAE,iBAAiB,CAAC,iBAAiB,CAAC,SAAS,CAAC,EACpD,EAAE,EAAE,iBAAiB,CAAC,SAAS,EAC/B,cAAc,EAAE,KAAK,CAAC,cAAc,GAAG,SAAS,EAChD,cAAc,EAAE,iBAAiB,CAAC,cAAc,EAChD,MAAM,EAAE;IACN,gBAAgB,EAAE,oBAAoB,CAAC;IACvC,WAAW,EAAE,aAAa,GAAG,eAAe,GAAG,iBAAiB,GAAG,SAAS,CAAC;IAC7E,QAAQ,EAAE,MAAM,GAAG,SAAS,CAAC;IAC7B,eAAe,CAAC,EAAE,OAAO,CAAC;CAC3B,GACA,OAAO,CAAC,iBAAiB,CAAC,SAAS,CAAC,CAmDtC"}

package/dist/esm/transaction/fixedScript/signPsbtWasm.js

@@ -0,0 +1,111 @@
+import assert from 'assert';
+import { BIP32, fixedScriptWallet, getWasmUtxoVersion } from '@bitgo/wasm-utxo';
+import { BulkSigningError, InputSigningError, TransactionSigningError } from './SigningError';
+function toWasmBIP32(key) {
+    return key instanceof BIP32 ? key : BIP32.fromBase58(key.toBase58());
+}
+/**
+ * Key Value: Unsigned tx id => PSBT
+ * It is used to cache PSBTs with taproot key path (MuSig2) inputs during external express signer is activated.
+ * Reason: MuSig2 signer secure nonce is cached in the BitGoPsbt object. It will be required during the signing step.
+ * For more info, check SignTransactionOptions.signingStep
+ */
+const PSBT_CACHE_WASM = new Map();
+function hasKeyPathSpendInput(tx, rootWalletKeys, replayProtection) {
+    const parsed = tx.parseTransactionWithWalletKeys(rootWalletKeys, { replayProtection });
+    return parsed.inputs.some((input) => input.scriptType === 'p2trMusig2KeyPath');
+}
+/**
+ * Sign all inputs of a PSBT and verify signatures after signing.
+ * Uses bulk signing for performance (signs all matching inputs in one pass).
+ * Collects and logs signing errors and verification errors, throws error in the end if any of them failed.
+ */
+export function signAndVerifyPsbtWasm(tx, signerKeychain, rootWalletKeys, replayProtection, { writeSignedWith = false } = {}) {
+    const wasmSigner = toWasmBIP32(signerKeychain);
+    // Bulk sign all wallet inputs (ECDSA + MuSig2) - much faster than per-input signing
+    try {
+        tx.sign(wasmSigner);
+    }
+    catch (e) {
+        throw new BulkSigningError(e);
+    }
+    // Verify signatures for all signed inputs (still per-input for granular error reporting)
+    const parsed = tx.parseTransactionWithWalletKeys(rootWalletKeys, { replayProtection });
+    const verifyErrors = [];
+    parsed.inputs.forEach((input, inputIndex) => {
+        if (input.scriptType === 'p2shP2pk') {
+            // Skip replay protection inputs - they are platform signed only
+            return;
+        }
+        const outputId = `${input.previousOutput.txid}:${input.previousOutput.vout}`;
+        try {
+            if (!tx.verifySignature(inputIndex, wasmSigner)) {
+                verifyErrors.push(new InputSigningError(inputIndex, input.scriptType, { id: outputId }, new Error('invalid signature')));
+            }
+        }
+        catch (e) {
+            verifyErrors.push(new InputSigningError(inputIndex, input.scriptType, { id: outputId }, e));
+        }
+    });
+    if (verifyErrors.length) {
+        throw new TransactionSigningError([], verifyErrors);
+    }
+    if (writeSignedWith) {
+        const versionInfo = getWasmUtxoVersion();
+        const versionPayload = new TextEncoder().encode(JSON.stringify({
+            version: versionInfo.version,
+            gitHash: versionInfo.gitHash,
+        }));
+        tx.setKV({ type: 'bitgo', subtype: fixedScriptWallet.BitGoKeySubtype.WasmUtxoSignedWith }, versionPayload);
+    }
+    return tx;
+}
+export async function signPsbtWithMusig2ParticipantWasm(coin, tx, signerKeychain, rootWalletKeys, params) {
+    const wasmSigner = signerKeychain ? toWasmBIP32(signerKeychain) : undefined;
+    if (hasKeyPathSpendInput(tx, rootWalletKeys, params.replayProtection)) {
+        switch (params.signingStep) {
+            case 'signerNonce':
+                assert(wasmSigner);
+                tx.generateMusig2Nonces(wasmSigner);
+                PSBT_CACHE_WASM.set(tx.unsignedTxId(), tx);
+                return tx;
+            case 'cosignerNonce':
+                assert(params.walletId, 'walletId is required for MuSig2 bitgo nonce');
+                return await coin.getMusig2Nonces(tx, params.walletId);
+            case 'signerSignature': {
+                const txId = tx.unsignedTxId();
+                const cachedPsbt = PSBT_CACHE_WASM.get(txId);
+                assert(cachedPsbt, `Psbt is missing from txCache (cache size ${PSBT_CACHE_WASM.size}).
+            This may be due to the request being routed to a different BitGo-Express instance that for signing step 'signerNonce'.`);
+                PSBT_CACHE_WASM.delete(txId);
+                cachedPsbt.combineMusig2Nonces(tx);
+                tx = cachedPsbt;
+                break;
+            }
+            default:
+                // this instance is not an external signer
+                assert(params.walletId, 'walletId is required for MuSig2 bitgo nonce');
+                assert(wasmSigner);
+                tx.generateMusig2Nonces(wasmSigner);
+                const response = await coin.getMusig2Nonces(tx, params.walletId);
+                tx.combineMusig2Nonces(response);
+                break;
+        }
+    }
+    else {
+        switch (params.signingStep) {
+            case 'signerNonce':
+            case 'cosignerNonce':
+                /**
+                 * In certain cases, the caller of this method may not know whether the txHex contains a psbt with taproot key path spend input(s).
+                 * Instead of throwing error, no-op and return the txHex. So that the caller can call this method in the same sequence.
+                 */
+                return tx;
+        }
+    }
+    assert(signerKeychain);
+    return signAndVerifyPsbtWasm(tx, signerKeychain, rootWalletKeys, params.replayProtection, {
+        writeSignedWith: params.writeSignedWith,
+    });
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"signPsbtWasm.js","sourceRoot":"","sources":["../../../../src/transaction/fixedScript/signPsbtWasm.ts"],"names":[],"mappings":"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","sourcesContent":["import assert from 'assert';\n\nimport { BIP32, bip32, ECPair, fixedScriptWallet, getWasmUtxoVersion } from '@bitgo/wasm-utxo';\n\nimport { BulkSigningError, InputSigningError, TransactionSigningError } from './SigningError';\nimport { Musig2Participant } from './musig2';\n\nfunction toWasmBIP32(key: bip32.BIP32Interface | BIP32): BIP32 {\n  return key instanceof BIP32 ? key : BIP32.fromBase58(key.toBase58());\n}\n\nexport type ReplayProtectionKeys = {\n  publicKeys: (Uint8Array | ECPair)[];\n};\n\n/**\n * Key Value: Unsigned tx id => PSBT\n * It is used to cache PSBTs with taproot key path (MuSig2) inputs during external express signer is activated.\n * Reason: MuSig2 signer secure nonce is cached in the BitGoPsbt object. It will be required during the signing step.\n * For more info, check SignTransactionOptions.signingStep\n */\nconst PSBT_CACHE_WASM = new Map<string, fixedScriptWallet.BitGoPsbt>();\n\nfunction hasKeyPathSpendInput(\n  tx: fixedScriptWallet.BitGoPsbt,\n  rootWalletKeys: fixedScriptWallet.RootWalletKeys,\n  replayProtection: ReplayProtectionKeys\n): boolean {\n  const parsed = tx.parseTransactionWithWalletKeys(rootWalletKeys, { replayProtection });\n  return parsed.inputs.some((input) => input.scriptType === 'p2trMusig2KeyPath');\n}\n\n/**\n * Sign all inputs of a PSBT and verify signatures after signing.\n * Uses bulk signing for performance (signs all matching inputs in one pass).\n * Collects and logs signing errors and verification errors, throws error in the end if any of them failed.\n */\nexport function signAndVerifyPsbtWasm(\n  tx: fixedScriptWallet.BitGoPsbt,\n  signerKeychain: bip32.BIP32Interface | BIP32,\n  rootWalletKeys: fixedScriptWallet.RootWalletKeys,\n  replayProtection: ReplayProtectionKeys,\n  { writeSignedWith = false }: { writeSignedWith?: boolean } = {}\n): fixedScriptWallet.BitGoPsbt {\n  const wasmSigner = toWasmBIP32(signerKeychain);\n\n  // Bulk sign all wallet inputs (ECDSA + MuSig2) - much faster than per-input signing\n  try {\n    tx.sign(wasmSigner);\n  } catch (e) {\n    throw new BulkSigningError(e);\n  }\n\n  // Verify signatures for all signed inputs (still per-input for granular error reporting)\n  const parsed = tx.parseTransactionWithWalletKeys(rootWalletKeys, { replayProtection });\n  const verifyErrors: InputSigningError<bigint>[] = [];\n\n  parsed.inputs.forEach((input, inputIndex) => {\n    if (input.scriptType === 'p2shP2pk') {\n      // Skip replay protection inputs - they are platform signed only\n      return;\n    }\n\n    const outputId = `${input.previousOutput.txid}:${input.previousOutput.vout}`;\n    try {\n      if (!tx.verifySignature(inputIndex, wasmSigner)) {\n        verifyErrors.push(\n          new InputSigningError(inputIndex, input.scriptType, { id: outputId }, new Error('invalid signature'))\n        );\n      }\n    } catch (e) {\n      verifyErrors.push(new InputSigningError<bigint>(inputIndex, input.scriptType, { id: outputId }, e));\n    }\n  });\n\n  if (verifyErrors.length) {\n    throw new TransactionSigningError([], verifyErrors);\n  }\n\n  if (writeSignedWith) {\n    const versionInfo = getWasmUtxoVersion();\n    const versionPayload = new TextEncoder().encode(\n      JSON.stringify({\n        version: versionInfo.version,\n        gitHash: versionInfo.gitHash,\n      })\n    );\n    tx.setKV({ type: 'bitgo', subtype: fixedScriptWallet.BitGoKeySubtype.WasmUtxoSignedWith }, versionPayload);\n  }\n\n  return tx;\n}\n\nexport async function signPsbtWithMusig2ParticipantWasm(\n  coin: Musig2Participant<fixedScriptWallet.BitGoPsbt>,\n  tx: fixedScriptWallet.BitGoPsbt,\n  signerKeychain: bip32.BIP32Interface | undefined,\n  rootWalletKeys: fixedScriptWallet.RootWalletKeys,\n  params: {\n    replayProtection: ReplayProtectionKeys;\n    signingStep: 'signerNonce' | 'cosignerNonce' | 'signerSignature' | undefined;\n    walletId: string | undefined;\n    writeSignedWith?: boolean;\n  }\n): Promise<fixedScriptWallet.BitGoPsbt> {\n  const wasmSigner = signerKeychain ? toWasmBIP32(signerKeychain) : undefined;\n\n  if (hasKeyPathSpendInput(tx, rootWalletKeys, params.replayProtection)) {\n    switch (params.signingStep) {\n      case 'signerNonce':\n        assert(wasmSigner);\n        tx.generateMusig2Nonces(wasmSigner);\n        PSBT_CACHE_WASM.set(tx.unsignedTxId(), tx);\n        return tx;\n      case 'cosignerNonce':\n        assert(params.walletId, 'walletId is required for MuSig2 bitgo nonce');\n        return await coin.getMusig2Nonces(tx, params.walletId);\n      case 'signerSignature': {\n        const txId = tx.unsignedTxId();\n        const cachedPsbt = PSBT_CACHE_WASM.get(txId);\n        assert(\n          cachedPsbt,\n          `Psbt is missing from txCache (cache size ${PSBT_CACHE_WASM.size}).\n            This may be due to the request being routed to a different BitGo-Express instance that for signing step 'signerNonce'.`\n        );\n        PSBT_CACHE_WASM.delete(txId);\n        cachedPsbt.combineMusig2Nonces(tx);\n        tx = cachedPsbt;\n        break;\n      }\n      default:\n        // this instance is not an external signer\n        assert(params.walletId, 'walletId is required for MuSig2 bitgo nonce');\n        assert(wasmSigner);\n        tx.generateMusig2Nonces(wasmSigner);\n        const response = await coin.getMusig2Nonces(tx, params.walletId);\n        tx.combineMusig2Nonces(response);\n        break;\n    }\n  } else {\n    switch (params.signingStep) {\n      case 'signerNonce':\n      case 'cosignerNonce':\n        /**\n         * In certain cases, the caller of this method may not know whether the txHex contains a psbt with taproot key path spend input(s).\n         * Instead of throwing error, no-op and return the txHex. So that the caller can call this method in the same sequence.\n         */\n        return tx;\n    }\n  }\n\n  assert(signerKeychain);\n  return signAndVerifyPsbtWasm(tx, signerKeychain, rootWalletKeys, params.replayProtection, {\n    writeSignedWith: params.writeSignedWith,\n  });\n}\n"]}

package/dist/esm/transaction/fixedScript/signTransaction.d.ts

@@ -0,0 +1,22 @@
+import { BIP32, bip32, fixedScriptWallet } from '@bitgo/wasm-utxo';
+import { UtxoCoinName } from '../../names';
+import type { Unspent } from '../../unspent';
+import { Musig2Participant } from './musig2';
+import { ReplayProtectionKeys } from './signPsbtWasm';
+export declare function signAndVerifyPsbt(psbt: fixedScriptWallet.BitGoPsbt, signerKeychain: bip32.BIP32Interface | BIP32, rootWalletKeys: fixedScriptWallet.RootWalletKeys, replayProtection: ReplayProtectionKeys, options?: {
+    writeSignedWith?: boolean;
+}): fixedScriptWallet.BitGoPsbt;
+export declare function signTransaction(coin: Musig2Participant<fixedScriptWallet.BitGoPsbt>, tx: fixedScriptWallet.BitGoPsbt, signerKeychain: bip32.BIP32Interface | undefined, coinName: UtxoCoinName, params: {
+    walletId: string | undefined;
+    txInfo: {
+        unspents?: Unspent<bigint | number>[];
+    } | undefined;
+    isLastSignature: boolean;
+    signingStep: 'signerNonce' | 'cosignerNonce' | 'signerSignature' | undefined;
+    pubs: string[] | undefined;
+    cosignerPub: string | undefined;
+    /** When true (default), extract finalized PSBT to legacy transaction format. When false, return finalized PSBT. */
+    extractTransaction?: boolean;
+    writeSignedWith?: boolean;
+}): Promise<fixedScriptWallet.BitGoPsbt | Buffer>;
+//# sourceMappingURL=signTransaction.d.ts.map

package/dist/esm/transaction/fixedScript/signTransaction.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"signTransaction.d.ts","sourceRoot":"","sources":["../../../../src/transaction/fixedScript/signTransaction.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,KAAK,EAAE,KAAK,EAAE,iBAAiB,EAAE,MAAM,kBAAkB,CAAC;AAEnE,OAAO,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAC3C,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,eAAe,CAAC;AAE7C,OAAO,EAAE,iBAAiB,EAAE,MAAM,UAAU,CAAC;AAC7C,OAAO,EAA4D,oBAAoB,EAAE,MAAM,gBAAgB,CAAC;AAGhH,wBAAgB,iBAAiB,CAC/B,IAAI,EAAE,iBAAiB,CAAC,SAAS,EACjC,cAAc,EAAE,KAAK,CAAC,cAAc,GAAG,KAAK,EAC5C,cAAc,EAAE,iBAAiB,CAAC,cAAc,EAChD,gBAAgB,EAAE,oBAAoB,EACtC,OAAO,GAAE;IAAE,eAAe,CAAC,EAAE,OAAO,CAAA;CAAO,GAC1C,iBAAiB,CAAC,SAAS,CAI7B;AAED,wBAAsB,eAAe,CACnC,IAAI,EAAE,iBAAiB,CAAC,iBAAiB,CAAC,SAAS,CAAC,EACpD,EAAE,EAAE,iBAAiB,CAAC,SAAS,EAC/B,cAAc,EAAE,KAAK,CAAC,cAAc,GAAG,SAAS,EAChD,QAAQ,EAAE,YAAY,EACtB,MAAM,EAAE;IACN,QAAQ,EAAE,MAAM,GAAG,SAAS,CAAC;IAC7B,MAAM,EAAE;QAAE,QAAQ,CAAC,EAAE,OAAO,CAAC,MAAM,GAAG,MAAM,CAAC,EAAE,CAAA;KAAE,GAAG,SAAS,CAAC;IAC9D,eAAe,EAAE,OAAO,CAAC;IACzB,WAAW,EAAE,aAAa,GAAG,eAAe,GAAG,iBAAiB,GAAG,SAAS,CAAC;IAC7E,IAAI,EAAE,MAAM,EAAE,GAAG,SAAS,CAAC;IAC3B,WAAW,EAAE,MAAM,GAAG,SAAS,CAAC;IAChC,mHAAmH;IACnH,kBAAkB,CAAC,EAAE,OAAO,CAAC;IAC7B,eAAe,CAAC,EAAE,OAAO,CAAC;CAC3B,GACA,OAAO,CAAC,iBAAiB,CAAC,SAAS,GAAG,MAAM,CAAC,CA4B/C"}

package/dist/esm/transaction/fixedScript/signTransaction.js

@@ -0,0 +1,39 @@
+import assert from 'assert';
+import { isTriple } from '@bitgo-beta/sdk-core';
+import _ from 'lodash';
+import { fixedScriptWallet } from '@bitgo/wasm-utxo';
+import { signPsbtWithMusig2ParticipantWasm, signAndVerifyPsbtWasm } from './signPsbtWasm';
+import { getReplayProtectionPubkeys } from './replayProtection';
+export function signAndVerifyPsbt(psbt, signerKeychain, rootWalletKeys, replayProtection, options = {}) {
+    assert(rootWalletKeys, 'rootWalletKeys required for wasm-utxo signing');
+    assert(replayProtection, 'replayProtection required for wasm-utxo signing');
+    return signAndVerifyPsbtWasm(psbt, signerKeychain, rootWalletKeys, replayProtection, options);
+}
+export async function signTransaction(coin, tx, signerKeychain, coinName, params) {
+    let isLastSignature = false;
+    if (_.isBoolean(params.isLastSignature)) {
+        // if build is called instead of buildIncomplete, no signature placeholders are left in the sig script
+        isLastSignature = params.isLastSignature;
+    }
+    const { extractTransaction = true } = params;
+    assert(params.pubs, 'pubs are required for fixed script signing');
+    assert(isTriple(params.pubs), 'pubs must be a triple');
+    const rootWalletKeys = fixedScriptWallet.RootWalletKeys.fromXpubs(params.pubs);
+    const signedPsbt = await signPsbtWithMusig2ParticipantWasm(coin, tx, signerKeychain, rootWalletKeys, {
+        replayProtection: {
+            publicKeys: getReplayProtectionPubkeys(coinName),
+        },
+        signingStep: params.signingStep,
+        walletId: params.walletId,
+        writeSignedWith: params.writeSignedWith,
+    });
+    if (isLastSignature) {
+        if (extractTransaction) {
+            signedPsbt.finalizeAllInputs();
+            return Buffer.from(signedPsbt.extractTransaction().toBytes());
+        }
+        return signedPsbt;
+    }
+    return signedPsbt;
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/esm/transaction/fixedScript/verifyTransaction.d.ts

@@ -0,0 +1,21 @@
+import { BitGoBase } from '@bitgo-beta/sdk-core';
+import { AbstractUtxoCoin, VerifyTransactionOptions } from '../../abstractUtxoCoin';
+/**
+ * Verify that a transaction prebuild complies with the original intention for fixed-script wallets
+ *
+ * This implementation handles transaction verification for traditional UTXO coins using fixed scripts
+ * (non-descriptor wallets). It validates keychains, signatures, outputs, and amounts.
+ *
+ * @param coin - The UTXO coin instance
+ * @param bitgo - BitGo API instance for network calls
+ * @param params - Verification parameters
+ * @param params.txParams - Transaction parameters passed to send
+ * @param params.txPrebuild - Prebuild object returned by server
+ * @param params.wallet - Wallet object to obtain keys to verify against
+ * @param params.verification - Verification options (disableNetworking, keychains, addresses)
+ * @param params.reqId - Optional request ID for logging
+ * @returns {boolean} True if verification passes
+ * @throws {TxIntentMismatchError} if transaction validation fails
+ */
+export declare function verifyTransaction<TNumber extends bigint | number>(coin: AbstractUtxoCoin, bitgo: BitGoBase, params: VerifyTransactionOptions<TNumber>): Promise<boolean>;
+//# sourceMappingURL=verifyTransaction.d.ts.map

package/dist/esm/transaction/fixedScript/verifyTransaction.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"verifyTransaction.d.ts","sourceRoot":"","sources":["../../../../src/transaction/fixedScript/verifyTransaction.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,SAAS,EAAoC,MAAM,sBAAsB,CAAC;AAGnF,OAAO,EAAE,gBAAgB,EAAE,wBAAwB,EAAE,MAAM,wBAAwB,CAAC;AAsBpF;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAsB,iBAAiB,CAAC,OAAO,SAAS,MAAM,GAAG,MAAM,EACrE,IAAI,EAAE,gBAAgB,EACtB,KAAK,EAAE,SAAS,EAChB,MAAM,EAAE,wBAAwB,CAAC,OAAO,CAAC,GACxC,OAAO,CAAC,OAAO,CAAC,CA6JlB"}