@bitgo/abstract-utxo 10.13.0 → 10.14.0

package/dist/cjs/src/transaction/fixedScript/signLegacyTransaction.js

@@ -56,13 +56,14 @@ const { isWalletUnspent, signInputWithUnspent, toOutput } = utxolib.bitgo;
  * @param transaction - wallet transaction (builder) to be signed
  * @param unspents - transaction unspents
  * @param walletSigner - signing parameters
+ * @param coinName - coin name for network-specific logic
  * @param isLastSignature - Returns full-signed transaction when true. Builds half-signed when false.
  * @param replayProtectionAddresses - List of replay protection addresses to skip signing
  */
-function signAndVerifyWalletTransaction(transaction, unspents, walletSigner, { isLastSignature, replayProtectionAddresses, }) {
+function signAndVerifyWalletTransaction(transaction, unspents, walletSigner, coinName, { isLastSignature, replayProtectionAddresses, }) {
     const network = transaction.network;
     if (replayProtectionAddresses === undefined) {
-        replayProtectionAddresses = (0, replayProtection_1.getReplayProtectionAddresses)(network);
+        replayProtectionAddresses = (0, replayProtection_1.getReplayProtectionAddresses)(coinName);
     }
     const prevOutputs = unspents.map((u) => toOutput(u, network));
     let txBuilder;
@@ -124,7 +125,7 @@ function signAndVerifyWalletTransaction(transaction, unspents, walletSigner, { i
     }
     return signedTransaction;
 }
-function signLegacyTransaction(tx, signerKeychain, params) {
+function signLegacyTransaction(tx, signerKeychain, coinName, params) {
     switch (params.signingStep) {
         case 'signerNonce':
         case 'cosignerNonce':
@@ -145,8 +146,8 @@ function signLegacyTransaction(tx, signerKeychain, params) {
     const cosignerKeychain = secp256k1_1.bip32.fromBase58(cosignerPub);
     (0, assert_1.default)(signerKeychain);
     const walletSigner = new utxo_lib_1.bitgo.WalletUnspentSigner(keychains, signerKeychain, cosignerKeychain);
-    return signAndVerifyWalletTransaction(tx, params.txInfo.unspents, walletSigner, {
+    return signAndVerifyWalletTransaction(tx, params.txInfo.unspents, walletSigner, coinName, {
         isLastSignature: params.isLastSignature,
     });
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"signLegacyTransaction.js","sourceRoot":"","sources":["../../../../../src/transaction/fixedScript/signLegacyTransaction.ts"],"names":[],"mappings":"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","sourcesContent":["import assert from 'assert';\n\nimport * as utxolib from '@bitgo/utxo-lib';\nimport { BIP32Interface, bip32 } from '@bitgo/secp256k1';\nimport { bitgo } from '@bitgo/utxo-lib';\nimport { isTriple, Triple } from '@bitgo/sdk-core';\nimport debugLib from 'debug';\n\nimport { getReplayProtectionAddresses } from './replayProtection';\nimport { InputSigningError, TransactionSigningError } from './SigningError';\n\nconst debug = debugLib('bitgo:v2:utxo');\n\nconst { isWalletUnspent, signInputWithUnspent, toOutput } = utxolib.bitgo;\n\ntype Unspent<TNumber extends number | bigint = number> = utxolib.bitgo.Unspent<TNumber>;\n\ntype RootWalletKeys = utxolib.bitgo.RootWalletKeys;\n\n/**\n * Sign all inputs of a wallet transaction and verify signatures after signing.\n * Collects and logs signing errors and verification errors, throws error in the end if any of them\n * failed.\n *\n * @param transaction - wallet transaction (builder) to be signed\n * @param unspents - transaction unspents\n * @param walletSigner - signing parameters\n * @param isLastSignature - Returns full-signed transaction when true. Builds half-signed when false.\n * @param replayProtectionAddresses - List of replay protection addresses to skip signing\n */\nexport function signAndVerifyWalletTransaction<TNumber extends number | bigint>(\n  transaction: utxolib.bitgo.UtxoTransaction<TNumber> | utxolib.bitgo.UtxoTransactionBuilder<TNumber>,\n  unspents: Unspent<TNumber>[],\n  walletSigner: utxolib.bitgo.WalletUnspentSigner<RootWalletKeys>,\n  {\n    isLastSignature,\n    replayProtectionAddresses,\n  }: {\n    isLastSignature: boolean;\n    replayProtectionAddresses?: string[];\n  }\n): utxolib.bitgo.UtxoTransaction<TNumber> {\n  const network = transaction.network as utxolib.Network;\n  if (replayProtectionAddresses === undefined) {\n    replayProtectionAddresses = getReplayProtectionAddresses(network);\n  }\n  const prevOutputs = unspents.map((u) => toOutput(u, network));\n\n  let txBuilder: utxolib.bitgo.UtxoTransactionBuilder<TNumber>;\n  if (transaction instanceof utxolib.bitgo.UtxoTransaction) {\n    txBuilder = utxolib.bitgo.createTransactionBuilderFromTransaction<TNumber>(transaction, prevOutputs);\n    if (transaction.ins.length !== unspents.length) {\n      throw new Error(`transaction inputs must match unspents`);\n    }\n  } else if (transaction instanceof utxolib.bitgo.UtxoTransactionBuilder) {\n    txBuilder = transaction;\n  } else {\n    throw new Error(`must pass UtxoTransaction or UtxoTransactionBuilder`);\n  }\n\n  const signErrors: InputSigningError<TNumber>[] = unspents\n    .map((unspent: Unspent<TNumber>, inputIndex: number) => {\n      if (replayProtectionAddresses.includes(unspent.address)) {\n        debug('Skipping signature for input %d of %d (RP input?)', inputIndex + 1, unspents.length);\n        return;\n      }\n      if (!isWalletUnspent<TNumber>(unspent)) {\n        return InputSigningError.expectedWalletUnspent<TNumber>(inputIndex, null, unspent);\n      }\n      try {\n        signInputWithUnspent<TNumber>(txBuilder, inputIndex, unspent, walletSigner);\n        debug('Successfully signed input %d of %d', inputIndex + 1, unspents.length);\n      } catch (e) {\n        return new InputSigningError<TNumber>(inputIndex, null, unspent, e);\n      }\n    })\n    .filter((e): e is InputSigningError<TNumber> => e !== undefined);\n\n  const signedTransaction = isLastSignature ? txBuilder.build() : txBuilder.buildIncomplete();\n\n  const verifyErrors: InputSigningError<TNumber>[] = signedTransaction.ins\n    .map((input, inputIndex) => {\n      const unspent = unspents[inputIndex] as Unspent<TNumber>;\n      if (replayProtectionAddresses.includes(unspent.address)) {\n        debug(\n          'Skipping input signature %d of %d (unspent from replay protection address which is platform signed only)',\n          inputIndex + 1,\n          unspents.length\n        );\n        return;\n      }\n      if (!isWalletUnspent<TNumber>(unspent)) {\n        return InputSigningError.expectedWalletUnspent<TNumber>(inputIndex, null, unspent);\n      }\n      try {\n        const publicKey = walletSigner.deriveForChainAndIndex(unspent.chain, unspent.index).signer.publicKey;\n        if (\n          !utxolib.bitgo.verifySignatureWithPublicKey<TNumber>(signedTransaction, inputIndex, prevOutputs, publicKey)\n        ) {\n          return new InputSigningError(inputIndex, null, unspent, new Error(`invalid signature`));\n        }\n      } catch (e) {\n        debug('Invalid signature');\n        return new InputSigningError<TNumber>(inputIndex, null, unspent, e);\n      }\n    })\n    .filter((e): e is InputSigningError<TNumber> => e !== undefined);\n\n  if (signErrors.length || verifyErrors.length) {\n    throw new TransactionSigningError(signErrors, verifyErrors);\n  }\n\n  return signedTransaction;\n}\n\nexport function signLegacyTransaction<TNumber extends number | bigint>(\n  tx: utxolib.bitgo.UtxoTransaction<TNumber>,\n  signerKeychain: BIP32Interface | undefined,\n  params: {\n    isLastSignature: boolean;\n    signingStep: 'signerNonce' | 'cosignerNonce' | 'signerSignature' | undefined;\n    txInfo: { unspents?: utxolib.bitgo.Unspent<TNumber>[] } | undefined;\n    pubs: string[] | undefined;\n    cosignerPub: string | undefined;\n  }\n): utxolib.bitgo.UtxoTransaction<TNumber> {\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  if (tx.ins.length !== params.txInfo?.unspents?.length) {\n    throw new Error('length of unspents array should equal to the number of transaction inputs');\n  }\n\n  if (!params.pubs || !isTriple(params.pubs)) {\n    throw new Error(`must provide xpub array`);\n  }\n\n  const keychains = params.pubs.map((pub) => bip32.fromBase58(pub)) as Triple<BIP32Interface>;\n  const cosignerPub = params.cosignerPub ?? params.pubs[2];\n  const cosignerKeychain = bip32.fromBase58(cosignerPub);\n\n  assert(signerKeychain);\n  const walletSigner = new bitgo.WalletUnspentSigner<RootWalletKeys>(keychains, signerKeychain, cosignerKeychain);\n  return signAndVerifyWalletTransaction(tx, params.txInfo.unspents, walletSigner, {\n    isLastSignature: params.isLastSignature,\n  }) as utxolib.bitgo.UtxoTransaction<TNumber>;\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"signLegacyTransaction.js","sourceRoot":"","sources":["../../../../../src/transaction/fixedScript/signLegacyTransaction.ts"],"names":[],"mappings":"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","sourcesContent":["import assert from 'assert';\n\nimport * as utxolib from '@bitgo/utxo-lib';\nimport { BIP32Interface, bip32 } from '@bitgo/secp256k1';\nimport { bitgo } from '@bitgo/utxo-lib';\nimport { isTriple, Triple } from '@bitgo/sdk-core';\nimport debugLib from 'debug';\n\nimport { UtxoCoinName } from '../../names';\n\nimport { getReplayProtectionAddresses } from './replayProtection';\nimport { InputSigningError, TransactionSigningError } from './SigningError';\n\nconst debug = debugLib('bitgo:v2:utxo');\n\nconst { isWalletUnspent, signInputWithUnspent, toOutput } = utxolib.bitgo;\n\ntype Unspent<TNumber extends number | bigint = number> = utxolib.bitgo.Unspent<TNumber>;\n\ntype RootWalletKeys = utxolib.bitgo.RootWalletKeys;\n\n/**\n * Sign all inputs of a wallet transaction and verify signatures after signing.\n * Collects and logs signing errors and verification errors, throws error in the end if any of them\n * failed.\n *\n * @param transaction - wallet transaction (builder) to be signed\n * @param unspents - transaction unspents\n * @param walletSigner - signing parameters\n * @param coinName - coin name for network-specific logic\n * @param isLastSignature - Returns full-signed transaction when true. Builds half-signed when false.\n * @param replayProtectionAddresses - List of replay protection addresses to skip signing\n */\nexport function signAndVerifyWalletTransaction<TNumber extends number | bigint>(\n  transaction: utxolib.bitgo.UtxoTransaction<TNumber> | utxolib.bitgo.UtxoTransactionBuilder<TNumber>,\n  unspents: Unspent<TNumber>[],\n  walletSigner: utxolib.bitgo.WalletUnspentSigner<RootWalletKeys>,\n  coinName: UtxoCoinName,\n  {\n    isLastSignature,\n    replayProtectionAddresses,\n  }: {\n    isLastSignature: boolean;\n    replayProtectionAddresses?: string[];\n  }\n): utxolib.bitgo.UtxoTransaction<TNumber> {\n  const network = transaction.network as utxolib.Network;\n  if (replayProtectionAddresses === undefined) {\n    replayProtectionAddresses = getReplayProtectionAddresses(coinName);\n  }\n  const prevOutputs = unspents.map((u) => toOutput(u, network));\n\n  let txBuilder: utxolib.bitgo.UtxoTransactionBuilder<TNumber>;\n  if (transaction instanceof utxolib.bitgo.UtxoTransaction) {\n    txBuilder = utxolib.bitgo.createTransactionBuilderFromTransaction<TNumber>(transaction, prevOutputs);\n    if (transaction.ins.length !== unspents.length) {\n      throw new Error(`transaction inputs must match unspents`);\n    }\n  } else if (transaction instanceof utxolib.bitgo.UtxoTransactionBuilder) {\n    txBuilder = transaction;\n  } else {\n    throw new Error(`must pass UtxoTransaction or UtxoTransactionBuilder`);\n  }\n\n  const signErrors: InputSigningError<TNumber>[] = unspents\n    .map((unspent: Unspent<TNumber>, inputIndex: number) => {\n      if (replayProtectionAddresses.includes(unspent.address)) {\n        debug('Skipping signature for input %d of %d (RP input?)', inputIndex + 1, unspents.length);\n        return;\n      }\n      if (!isWalletUnspent<TNumber>(unspent)) {\n        return InputSigningError.expectedWalletUnspent<TNumber>(inputIndex, null, unspent);\n      }\n      try {\n        signInputWithUnspent<TNumber>(txBuilder, inputIndex, unspent, walletSigner);\n        debug('Successfully signed input %d of %d', inputIndex + 1, unspents.length);\n      } catch (e) {\n        return new InputSigningError<TNumber>(inputIndex, null, unspent, e);\n      }\n    })\n    .filter((e): e is InputSigningError<TNumber> => e !== undefined);\n\n  const signedTransaction = isLastSignature ? txBuilder.build() : txBuilder.buildIncomplete();\n\n  const verifyErrors: InputSigningError<TNumber>[] = signedTransaction.ins\n    .map((input, inputIndex) => {\n      const unspent = unspents[inputIndex] as Unspent<TNumber>;\n      if (replayProtectionAddresses.includes(unspent.address)) {\n        debug(\n          'Skipping input signature %d of %d (unspent from replay protection address which is platform signed only)',\n          inputIndex + 1,\n          unspents.length\n        );\n        return;\n      }\n      if (!isWalletUnspent<TNumber>(unspent)) {\n        return InputSigningError.expectedWalletUnspent<TNumber>(inputIndex, null, unspent);\n      }\n      try {\n        const publicKey = walletSigner.deriveForChainAndIndex(unspent.chain, unspent.index).signer.publicKey;\n        if (\n          !utxolib.bitgo.verifySignatureWithPublicKey<TNumber>(signedTransaction, inputIndex, prevOutputs, publicKey)\n        ) {\n          return new InputSigningError(inputIndex, null, unspent, new Error(`invalid signature`));\n        }\n      } catch (e) {\n        debug('Invalid signature');\n        return new InputSigningError<TNumber>(inputIndex, null, unspent, e);\n      }\n    })\n    .filter((e): e is InputSigningError<TNumber> => e !== undefined);\n\n  if (signErrors.length || verifyErrors.length) {\n    throw new TransactionSigningError(signErrors, verifyErrors);\n  }\n\n  return signedTransaction;\n}\n\nexport function signLegacyTransaction<TNumber extends number | bigint>(\n  tx: utxolib.bitgo.UtxoTransaction<TNumber>,\n  signerKeychain: BIP32Interface | undefined,\n  coinName: UtxoCoinName,\n  params: {\n    isLastSignature: boolean;\n    signingStep: 'signerNonce' | 'cosignerNonce' | 'signerSignature' | undefined;\n    txInfo: { unspents?: utxolib.bitgo.Unspent<TNumber>[] } | undefined;\n    pubs: string[] | undefined;\n    cosignerPub: string | undefined;\n  }\n): utxolib.bitgo.UtxoTransaction<TNumber> {\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  if (tx.ins.length !== params.txInfo?.unspents?.length) {\n    throw new Error('length of unspents array should equal to the number of transaction inputs');\n  }\n\n  if (!params.pubs || !isTriple(params.pubs)) {\n    throw new Error(`must provide xpub array`);\n  }\n\n  const keychains = params.pubs.map((pub) => bip32.fromBase58(pub)) as Triple<BIP32Interface>;\n  const cosignerPub = params.cosignerPub ?? params.pubs[2];\n  const cosignerKeychain = bip32.fromBase58(cosignerPub);\n\n  assert(signerKeychain);\n  const walletSigner = new bitgo.WalletUnspentSigner<RootWalletKeys>(keychains, signerKeychain, cosignerKeychain);\n  return signAndVerifyWalletTransaction(tx, params.txInfo.unspents, walletSigner, coinName, {\n    isLastSignature: params.isLastSignature,\n  }) as utxolib.bitgo.UtxoTransaction<TNumber>;\n}\n"]}

package/dist/cjs/src/transaction/fixedScript/{signPsbt.d.ts → signPsbtUtxolib.d.ts}

@@ -7,24 +7,15 @@ export type PsbtParsedScriptType = 'p2sh' | 'p2wsh' | 'p2shP2wsh' | 'p2shP2pk' |
  * Collects and logs signing errors and verification errors, throws error in the end if any of them
  * failed.
  *
- * If it is the last signature, finalize and extract the transaction from the psbt.
- *
  * This function mirrors signAndVerifyWalletTransaction, but is used for signing PSBTs instead of
  * using TransactionBuilder
  *
  * @param psbt
  * @param signerKeychain
- * @param isLastSignature
  */
-export declare function signAndVerifyPsbt(psbt: utxolib.bitgo.UtxoPsbt, signerKeychain: utxolib.BIP32Interface, { isLastSignature, 
-/** deprecated */
-allowNonSegwitSigningWithoutPrevTx, }: {
-    isLastSignature: boolean;
-    allowNonSegwitSigningWithoutPrevTx?: boolean;
-}): utxolib.bitgo.UtxoPsbt | utxolib.bitgo.UtxoTransaction<bigint>;
-export declare function signPsbtWithMusig2Participant(coin: Musig2Participant<utxolib.bitgo.UtxoPsbt>, tx: utxolib.bitgo.UtxoPsbt, signerKeychain: BIP32Interface | undefined, params: {
-    isLastSignature: boolean;
+export declare function signAndVerifyPsbt(psbt: utxolib.bitgo.UtxoPsbt, signerKeychain: utxolib.BIP32Interface): utxolib.bitgo.UtxoPsbt;
+export declare function signPsbtWithMusig2ParticipantUtxolib(coin: Musig2Participant<utxolib.bitgo.UtxoPsbt>, tx: utxolib.bitgo.UtxoPsbt, signerKeychain: BIP32Interface | undefined, params: {
     signingStep: 'signerNonce' | 'cosignerNonce' | 'signerSignature' | undefined;
     walletId: string | undefined;
-}): Promise<utxolib.bitgo.UtxoPsbt | utxolib.bitgo.UtxoTransaction<bigint>>;
-//# sourceMappingURL=signPsbt.d.ts.map
+}): Promise<utxolib.bitgo.UtxoPsbt>;
+//# sourceMappingURL=signPsbtUtxolib.d.ts.map

package/dist/cjs/src/transaction/fixedScript/signPsbtUtxolib.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"signPsbtUtxolib.d.ts","sourceRoot":"","sources":["../../../../../src/transaction/fixedScript/signPsbtUtxolib.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,OAAO,MAAM,iBAAiB,CAAC;AAC3C,OAAO,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAC;AAKlD,OAAO,EAAE,iBAAiB,EAAE,MAAM,UAAU,CAAC;AAI7C,MAAM,MAAM,oBAAoB,GAC5B,MAAM,GACN,OAAO,GACP,WAAW,GACX,UAAU,GACV,qBAAqB,GACrB,wBAAwB,GAExB,YAAY,GACZ,sBAAsB,GACtB,mBAAmB,CAAC;AAExB;;;;;;;;;;GAUG;AACH,wBAAgB,iBAAiB,CAC/B,IAAI,EAAE,OAAO,CAAC,KAAK,CAAC,QAAQ,EAC5B,cAAc,EAAE,OAAO,CAAC,cAAc,GACrC,OAAO,CAAC,KAAK,CAAC,QAAQ,CAwDxB;AAYD,wBAAsB,oCAAoC,CACxD,IAAI,EAAE,iBAAiB,CAAC,OAAO,CAAC,KAAK,CAAC,QAAQ,CAAC,EAC/C,EAAE,EAAE,OAAO,CAAC,KAAK,CAAC,QAAQ,EAC1B,cAAc,EAAE,cAAc,GAAG,SAAS,EAC1C,MAAM,EAAE;IACN,WAAW,EAAE,aAAa,GAAG,eAAe,GAAG,iBAAiB,GAAG,SAAS,CAAC;IAC7E,QAAQ,EAAE,MAAM,GAAG,SAAS,CAAC;CAC9B,GACA,OAAO,CAAC,OAAO,CAAC,KAAK,CAAC,QAAQ,CAAC,CA6CjC"}

package/dist/cjs/src/transaction/fixedScript/signPsbtUtxolib.js

@@ -0,0 +1,157 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.signAndVerifyPsbt = signAndVerifyPsbt;
+exports.signPsbtWithMusig2ParticipantUtxolib = signPsbtWithMusig2ParticipantUtxolib;
+const assert_1 = __importDefault(require("assert"));
+const utxolib = __importStar(require("@bitgo/utxo-lib"));
+const utxo_lib_1 = require("@bitgo/utxo-lib");
+const debug_1 = __importDefault(require("debug"));
+const SigningError_1 = require("./SigningError");
+const debug = (0, debug_1.default)('bitgo:v2:utxo');
+/**
+ * Sign all inputs of a psbt and verify signatures after signing.
+ * Collects and logs signing errors and verification errors, throws error in the end if any of them
+ * failed.
+ *
+ * This function mirrors signAndVerifyWalletTransaction, but is used for signing PSBTs instead of
+ * using TransactionBuilder
+ *
+ * @param psbt
+ * @param signerKeychain
+ */
+function signAndVerifyPsbt(psbt, signerKeychain) {
+    const txInputs = psbt.txInputs;
+    const outputIds = [];
+    const scriptTypes = [];
+    const signErrors = psbt.data.inputs
+        .map((input, inputIndex) => {
+        const outputId = utxolib.bitgo.formatOutputId(utxolib.bitgo.getOutputIdForInput(txInputs[inputIndex]));
+        outputIds.push(outputId);
+        const { scriptType } = utxolib.bitgo.parsePsbtInput(input);
+        scriptTypes.push(scriptType);
+        if (scriptType === 'p2shP2pk') {
+            debug('Skipping signature for input %d of %d (RP input?)', inputIndex + 1, psbt.data.inputs.length);
+            return;
+        }
+        try {
+            psbt.signInputHD(inputIndex, signerKeychain);
+            debug('Successfully signed input %d of %d', inputIndex + 1, psbt.data.inputs.length);
+        }
+        catch (e) {
+            return new SigningError_1.InputSigningError(inputIndex, scriptType, { id: outputId }, e);
+        }
+    })
+        .filter((e) => e !== undefined);
+    const verifyErrors = psbt.data.inputs
+        .map((input, inputIndex) => {
+        const scriptType = scriptTypes[inputIndex];
+        if (scriptType === 'p2shP2pk') {
+            debug('Skipping input signature %d of %d (unspent from replay protection address which is platform signed only)', inputIndex + 1, psbt.data.inputs.length);
+            return;
+        }
+        const outputId = outputIds[inputIndex];
+        try {
+            if (!psbt.validateSignaturesOfInputHD(inputIndex, signerKeychain)) {
+                return new SigningError_1.InputSigningError(inputIndex, scriptType, { id: outputId }, new Error(`invalid signature`));
+            }
+        }
+        catch (e) {
+            debug('Invalid signature');
+            return new SigningError_1.InputSigningError(inputIndex, scriptType, { id: outputId }, e);
+        }
+    })
+        .filter((e) => e !== undefined);
+    if (signErrors.length || verifyErrors.length) {
+        throw new SigningError_1.TransactionSigningError(signErrors, verifyErrors);
+    }
+    return psbt;
+}
+/**
+ * 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 UtxoPsbt object. It will be required during the signing step.
+ * For more info, check SignTransactionOptions.signingStep
+ *
+ * TODO BTC-276: This cache may need to be done with LRU like memory safe caching if memory issues comes up.
+ */
+const PSBT_CACHE = new Map();
+async function signPsbtWithMusig2ParticipantUtxolib(coin, tx, signerKeychain, params) {
+    if (utxo_lib_1.bitgo.isTransactionWithKeyPathSpendInput(tx)) {
+        switch (params.signingStep) {
+            case 'signerNonce':
+                (0, assert_1.default)(signerKeychain);
+                tx.setAllInputsMusig2NonceHD(signerKeychain);
+                PSBT_CACHE.set(tx.getUnsignedTx().getId(), tx);
+                return tx;
+            case 'cosignerNonce':
+                (0, assert_1.default)(params.walletId, 'walletId is required for MuSig2 bitgo nonce');
+                return await coin.getMusig2Nonces(tx, params.walletId);
+            case 'signerSignature':
+                const txId = tx.getUnsignedTx().getId();
+                const psbt = PSBT_CACHE.get(txId);
+                (0, assert_1.default)(psbt, `Psbt is missing from txCache (cache size ${PSBT_CACHE.size}).
+            This may be due to the request being routed to a different BitGo-Express instance that for signing step 'signerNonce'.`);
+                PSBT_CACHE.delete(txId);
+                tx = psbt.combine(tx);
+                break;
+            default:
+                // this instance is not an external signer
+                (0, assert_1.default)(params.walletId, 'walletId is required for MuSig2 bitgo nonce');
+                (0, assert_1.default)(signerKeychain);
+                tx.setAllInputsMusig2NonceHD(signerKeychain);
+                const response = await coin.getMusig2Nonces(tx, params.walletId);
+                tx = tx.combine(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;
+        }
+    }
+    (0, assert_1.default)(signerKeychain);
+    return signAndVerifyPsbt(tx, signerKeychain);
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"signPsbtUtxolib.js","sourceRoot":"","sources":["../../../../../src/transaction/fixedScript/signPsbtUtxolib.ts"],"names":[],"mappings":"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","sourcesContent":["import assert from 'assert';\n\nimport * as utxolib from '@bitgo/utxo-lib';\nimport { BIP32Interface } from '@bitgo/secp256k1';\nimport { bitgo } from '@bitgo/utxo-lib';\nimport debugLib from 'debug';\n\nimport { InputSigningError, TransactionSigningError } from './SigningError';\nimport { Musig2Participant } from './musig2';\n\nconst debug = debugLib('bitgo:v2:utxo');\n\nexport type PsbtParsedScriptType =\n  | 'p2sh'\n  | 'p2wsh'\n  | 'p2shP2wsh'\n  | 'p2shP2pk'\n  | 'taprootKeyPathSpend'\n  | 'taprootScriptPathSpend'\n  // wasm-utxo types\n  | 'p2trLegacy'\n  | 'p2trMusig2ScriptPath'\n  | 'p2trMusig2KeyPath';\n\n/**\n * Sign all inputs of a psbt and verify signatures after signing.\n * Collects and logs signing errors and verification errors, throws error in the end if any of them\n * failed.\n *\n * This function mirrors signAndVerifyWalletTransaction, but is used for signing PSBTs instead of\n * using TransactionBuilder\n *\n * @param psbt\n * @param signerKeychain\n */\nexport function signAndVerifyPsbt(\n  psbt: utxolib.bitgo.UtxoPsbt,\n  signerKeychain: utxolib.BIP32Interface\n): utxolib.bitgo.UtxoPsbt {\n  const txInputs = psbt.txInputs;\n  const outputIds: string[] = [];\n  const scriptTypes: PsbtParsedScriptType[] = [];\n\n  const signErrors: InputSigningError<bigint>[] = psbt.data.inputs\n    .map((input, inputIndex: number) => {\n      const outputId = utxolib.bitgo.formatOutputId(utxolib.bitgo.getOutputIdForInput(txInputs[inputIndex]));\n      outputIds.push(outputId);\n\n      const { scriptType } = utxolib.bitgo.parsePsbtInput(input);\n      scriptTypes.push(scriptType);\n\n      if (scriptType === 'p2shP2pk') {\n        debug('Skipping signature for input %d of %d (RP input?)', inputIndex + 1, psbt.data.inputs.length);\n        return;\n      }\n\n      try {\n        psbt.signInputHD(inputIndex, signerKeychain);\n        debug('Successfully signed input %d of %d', inputIndex + 1, psbt.data.inputs.length);\n      } catch (e) {\n        return new InputSigningError<bigint>(inputIndex, scriptType, { id: outputId }, e);\n      }\n    })\n    .filter((e): e is InputSigningError<bigint> => e !== undefined);\n\n  const verifyErrors: InputSigningError<bigint>[] = psbt.data.inputs\n    .map((input, inputIndex) => {\n      const scriptType = scriptTypes[inputIndex];\n      if (scriptType === 'p2shP2pk') {\n        debug(\n          'Skipping input signature %d of %d (unspent from replay protection address which is platform signed only)',\n          inputIndex + 1,\n          psbt.data.inputs.length\n        );\n        return;\n      }\n\n      const outputId = outputIds[inputIndex];\n      try {\n        if (!psbt.validateSignaturesOfInputHD(inputIndex, signerKeychain)) {\n          return new InputSigningError(inputIndex, scriptType, { id: outputId }, new Error(`invalid signature`));\n        }\n      } catch (e) {\n        debug('Invalid signature');\n        return new InputSigningError<bigint>(inputIndex, scriptType, { id: outputId }, e);\n      }\n    })\n    .filter((e): e is InputSigningError<bigint> => e !== undefined);\n\n  if (signErrors.length || verifyErrors.length) {\n    throw new TransactionSigningError(signErrors, verifyErrors);\n  }\n\n  return psbt;\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 UtxoPsbt object. It will be required during the signing step.\n * For more info, check SignTransactionOptions.signingStep\n *\n * TODO BTC-276: This cache may need to be done with LRU like memory safe caching if memory issues comes up.\n */\nconst PSBT_CACHE = new Map<string, utxolib.bitgo.UtxoPsbt>();\n\nexport async function signPsbtWithMusig2ParticipantUtxolib(\n  coin: Musig2Participant<utxolib.bitgo.UtxoPsbt>,\n  tx: utxolib.bitgo.UtxoPsbt,\n  signerKeychain: BIP32Interface | undefined,\n  params: {\n    signingStep: 'signerNonce' | 'cosignerNonce' | 'signerSignature' | undefined;\n    walletId: string | undefined;\n  }\n): Promise<utxolib.bitgo.UtxoPsbt> {\n  if (bitgo.isTransactionWithKeyPathSpendInput(tx)) {\n    switch (params.signingStep) {\n      case 'signerNonce':\n        assert(signerKeychain);\n        tx.setAllInputsMusig2NonceHD(signerKeychain);\n        PSBT_CACHE.set(tx.getUnsignedTx().getId(), 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.getUnsignedTx().getId();\n        const psbt = PSBT_CACHE.get(txId);\n        assert(\n          psbt,\n          `Psbt is missing from txCache (cache size ${PSBT_CACHE.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.delete(txId);\n        tx = psbt.combine(tx);\n        break;\n      default:\n        // this instance is not an external signer\n        assert(params.walletId, 'walletId is required for MuSig2 bitgo nonce');\n        assert(signerKeychain);\n        tx.setAllInputsMusig2NonceHD(signerKeychain);\n        const response = await coin.getMusig2Nonces(tx, params.walletId);\n        tx = tx.combine(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 signAndVerifyPsbt(tx, signerKeychain);\n}\n"]}

package/dist/cjs/src/transaction/fixedScript/signPsbtWasm.d.ts

@@ -7,16 +7,11 @@ export type ReplayProtectionKeys = {
 /**
  * Sign all inputs of a PSBT and verify signatures after signing.
  * Collects and logs signing errors and verification errors, throws error in the end if any of them failed.
- *
- * If it is the last signature, finalize and extract the transaction from the psbt.
  */
-export declare function signAndVerifyPsbtWasm(tx: fixedScriptWallet.BitGoPsbt, signerKeychain: BIP32Interface, rootWalletKeys: fixedScriptWallet.RootWalletKeys, replayProtection: ReplayProtectionKeys, { isLastSignature }: {
-    isLastSignature: boolean;
-}): fixedScriptWallet.BitGoPsbt | Buffer;
+export declare function signAndVerifyPsbtWasm(tx: fixedScriptWallet.BitGoPsbt, signerKeychain: BIP32Interface, rootWalletKeys: fixedScriptWallet.RootWalletKeys, replayProtection: ReplayProtectionKeys): fixedScriptWallet.BitGoPsbt;
 export declare function signPsbtWithMusig2ParticipantWasm(coin: Musig2Participant<fixedScriptWallet.BitGoPsbt>, tx: fixedScriptWallet.BitGoPsbt, signerKeychain: BIP32Interface | undefined, rootWalletKeys: fixedScriptWallet.RootWalletKeys, params: {
     replayProtection: ReplayProtectionKeys;
-    isLastSignature: boolean;
     signingStep: 'signerNonce' | 'cosignerNonce' | 'signerSignature' | undefined;
     walletId: string | undefined;
-}): Promise<fixedScriptWallet.BitGoPsbt | Buffer>;
+}): Promise<fixedScriptWallet.BitGoPsbt>;
 //# sourceMappingURL=signPsbtWasm.d.ts.map

package/dist/cjs/src/transaction/fixedScript/signPsbtWasm.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"signPsbtWasm.d.ts","sourceRoot":"","sources":["../../../../../src/transaction/fixedScript/signPsbtWasm.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,cAAc,EAAE,MAAM,iBAAiB,CAAC;AACjD,OAAO,EAAS,MAAM,EAAE,iBAAiB,EAAE,MAAM,kBAAkB,CAAC;AAGpE,OAAO,EAAE,iBAAiB,EAAE,MAAM,UAAU,CAAC;AAE7C,MAAM,MAAM,oBAAoB,GAAG;IACjC,UAAU,EAAE,CAAC,UAAU,GAAG,MAAM,CAAC,EAAE,CAAC;CACrC,CAAC;AAmBF;;;;;GAKG;AACH,wBAAgB,qBAAqB,CACnC,EAAE,EAAE,iBAAiB,CAAC,SAAS,EAC/B,cAAc,EAAE,cAAc,EAC9B,cAAc,EAAE,iBAAiB,CAAC,cAAc,EAChD,gBAAgB,EAAE,oBAAoB,EACtC,EAAE,eAAe,EAAE,EAAE;IAAE,eAAe,EAAE,OAAO,CAAA;CAAE,GAChD,iBAAiB,CAAC,SAAS,GAAG,MAAM,CAkDtC;AAOD,wBAAsB,iCAAiC,CACrD,IAAI,EAAE,iBAAiB,CAAC,iBAAiB,CAAC,SAAS,CAAC,EACpD,EAAE,EAAE,iBAAiB,CAAC,SAAS,EAC/B,cAAc,EAAE,cAAc,GAAG,SAAS,EAC1C,cAAc,EAAE,iBAAiB,CAAC,cAAc,EAChD,MAAM,EAAE;IACN,gBAAgB,EAAE,oBAAoB,CAAC;IACvC,eAAe,EAAE,OAAO,CAAC;IACzB,WAAW,EAAE,aAAa,GAAG,eAAe,GAAG,iBAAiB,GAAG,SAAS,CAAC;IAC7E,QAAQ,EAAE,MAAM,GAAG,SAAS,CAAC;CAC9B,GACA,OAAO,CAAC,iBAAiB,CAAC,SAAS,GAAG,MAAM,CAAC,CA0D/C"}
+{"version":3,"file":"signPsbtWasm.d.ts","sourceRoot":"","sources":["../../../../../src/transaction/fixedScript/signPsbtWasm.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,cAAc,EAAE,MAAM,iBAAiB,CAAC;AACjD,OAAO,EAAS,MAAM,EAAE,iBAAiB,EAAE,MAAM,kBAAkB,CAAC;AAGpE,OAAO,EAAE,iBAAiB,EAAE,MAAM,UAAU,CAAC;AAE7C,MAAM,MAAM,oBAAoB,GAAG;IACjC,UAAU,EAAE,CAAC,UAAU,GAAG,MAAM,CAAC,EAAE,CAAC;CACrC,CAAC;AAmBF;;;GAGG;AACH,wBAAgB,qBAAqB,CACnC,EAAE,EAAE,iBAAiB,CAAC,SAAS,EAC/B,cAAc,EAAE,cAAc,EAC9B,cAAc,EAAE,iBAAiB,CAAC,cAAc,EAChD,gBAAgB,EAAE,oBAAoB,GACrC,iBAAiB,CAAC,SAAS,CA6C7B;AAOD,wBAAsB,iCAAiC,CACrD,IAAI,EAAE,iBAAiB,CAAC,iBAAiB,CAAC,SAAS,CAAC,EACpD,EAAE,EAAE,iBAAiB,CAAC,SAAS,EAC/B,cAAc,EAAE,cAAc,GAAG,SAAS,EAC1C,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;CAC9B,GACA,OAAO,CAAC,iBAAiB,CAAC,SAAS,CAAC,CAiDtC"}

package/dist/cjs/src/transaction/fixedScript/signPsbtWasm.js

@@ -22,10 +22,8 @@ function hasKeyPathSpendInput(tx, rootWalletKeys, replayProtection) {
 /**
  * Sign all inputs of a PSBT and verify signatures after signing.
  * Collects and logs signing errors and verification errors, throws error in the end if any of them failed.
- *
- * If it is the last signature, finalize and extract the transaction from the psbt.
  */
-function signAndVerifyPsbtWasm(tx, signerKeychain, rootWalletKeys, replayProtection, { isLastSignature }) {
+function signAndVerifyPsbtWasm(tx, signerKeychain, rootWalletKeys, replayProtection) {
     const wasmSigner = toWasmBIP32(signerKeychain);
     const parsed = tx.parseTransactionWithWalletKeys(rootWalletKeys, replayProtection);
     const signErrors = [];
@@ -62,10 +60,6 @@ function signAndVerifyPsbtWasm(tx, signerKeychain, rootWalletKeys, replayProtect
     if (signErrors.length || verifyErrors.length) {
         throw new SigningError_1.TransactionSigningError(signErrors, verifyErrors);
     }
-    if (isLastSignature) {
-        tx.finalizeAllInputs();
-        return Buffer.from(tx.extractTransaction());
-    }
     return tx;
 }
 function toWasmBIP32(key) {
@@ -75,12 +69,6 @@ function toWasmBIP32(key) {
 async function signPsbtWithMusig2ParticipantWasm(coin, tx, signerKeychain, rootWalletKeys, params) {
     const wasmSigner = signerKeychain ? toWasmBIP32(signerKeychain) : undefined;
     if (hasKeyPathSpendInput(tx, rootWalletKeys, params.replayProtection)) {
-        // We can only be the first signature on a transaction with taproot key path spend inputs because
-        // we require the secret nonce in the cache of the first signer, which is impossible to retrieve if
-        // deserialized from a hex.
-        if (params.isLastSignature) {
-            throw new Error('Cannot be last signature on a transaction with key path spend inputs');
-        }
         switch (params.signingStep) {
             case 'signerNonce':
                 (0, assert_1.default)(wasmSigner);
@@ -122,8 +110,6 @@ async function signPsbtWithMusig2ParticipantWasm(coin, tx, signerKeychain, rootW
         }
     }
     (0, assert_1.default)(signerKeychain);
-    return signAndVerifyPsbtWasm(tx, signerKeychain, rootWalletKeys, params.replayProtection, {
-        isLastSignature: params.isLastSignature,
-    });
+    return signAndVerifyPsbtWasm(tx, signerKeychain, rootWalletKeys, params.replayProtection);
 }
-//# 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 { BIP32Interface } from '@bitgo/utxo-lib';\nimport { BIP32, ECPair, fixedScriptWallet } from '@bitgo/wasm-utxo';\n\nimport { InputSigningError, TransactionSigningError } from './SigningError';\nimport { Musig2Participant } from './musig2';\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 * Collects and logs signing errors and verification errors, throws error in the end if any of them failed.\n *\n * If it is the last signature, finalize and extract the transaction from the psbt.\n */\nexport function signAndVerifyPsbtWasm(\n  tx: fixedScriptWallet.BitGoPsbt,\n  signerKeychain: BIP32Interface,\n  rootWalletKeys: fixedScriptWallet.RootWalletKeys,\n  replayProtection: ReplayProtectionKeys,\n  { isLastSignature }: { isLastSignature: boolean }\n): fixedScriptWallet.BitGoPsbt | Buffer {\n  const wasmSigner = toWasmBIP32(signerKeychain);\n  const parsed = tx.parseTransactionWithWalletKeys(rootWalletKeys, replayProtection);\n\n  const signErrors: InputSigningError<bigint>[] = [];\n  const verifyErrors: InputSigningError<bigint>[] = [];\n\n  // Sign all inputs (skipping replay protection inputs)\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      tx.sign(inputIndex, wasmSigner);\n    } catch (e) {\n      signErrors.push(new InputSigningError<bigint>(inputIndex, input.scriptType, { id: outputId }, e));\n    }\n  });\n\n  // Verify signatures for all signed inputs\n  parsed.inputs.forEach((input, inputIndex) => {\n    if (input.scriptType === 'p2shP2pk') {\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 (signErrors.length || verifyErrors.length) {\n    throw new TransactionSigningError(signErrors, verifyErrors);\n  }\n\n  if (isLastSignature) {\n    tx.finalizeAllInputs();\n    return Buffer.from(tx.extractTransaction());\n  }\n\n  return tx;\n}\n\nfunction toWasmBIP32(key: BIP32Interface): BIP32 {\n  // Convert using base58 string to ensure private key is properly transferred\n  return BIP32.fromBase58(key.toBase58());\n}\n\nexport async function signPsbtWithMusig2ParticipantWasm(\n  coin: Musig2Participant<fixedScriptWallet.BitGoPsbt>,\n  tx: fixedScriptWallet.BitGoPsbt,\n  signerKeychain: BIP32Interface | undefined,\n  rootWalletKeys: fixedScriptWallet.RootWalletKeys,\n  params: {\n    replayProtection: ReplayProtectionKeys;\n    isLastSignature: boolean;\n    signingStep: 'signerNonce' | 'cosignerNonce' | 'signerSignature' | undefined;\n    walletId: string | undefined;\n  }\n): Promise<fixedScriptWallet.BitGoPsbt | Buffer> {\n  const wasmSigner = signerKeychain ? toWasmBIP32(signerKeychain) : undefined;\n\n  if (hasKeyPathSpendInput(tx, rootWalletKeys, params.replayProtection)) {\n    // We can only be the first signature on a transaction with taproot key path spend inputs because\n    // we require the secret nonce in the cache of the first signer, which is impossible to retrieve if\n    // deserialized from a hex.\n    if (params.isLastSignature) {\n      throw new Error('Cannot be last signature on a transaction with key path spend inputs');\n    }\n\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    isLastSignature: params.isLastSignature,\n  });\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"signPsbtWasm.js","sourceRoot":"","sources":["../../../../../src/transaction/fixedScript/signPsbtWasm.ts"],"names":[],"mappings":";;;;;AAiCA,sDAkDC;AAOD,8EA2DC;AArJD,oDAA4B;AAG5B,gDAAoE;AAEpE,iDAA4E;AAO5E;;;;;GAKG;AACH,MAAM,eAAe,GAAG,IAAI,GAAG,EAAuC,CAAC;AAEvE,SAAS,oBAAoB,CAC3B,EAA+B,EAC/B,cAAgD,EAChD,gBAAsC;IAEtC,MAAM,MAAM,GAAG,EAAE,CAAC,8BAA8B,CAAC,cAAc,EAAE,gBAAgB,CAAC,CAAC;IACnF,OAAO,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,KAAK,CAAC,UAAU,KAAK,mBAAmB,CAAC,CAAC;AACjF,CAAC;AAED;;;GAGG;AACH,SAAgB,qBAAqB,CACnC,EAA+B,EAC/B,cAA8B,EAC9B,cAAgD,EAChD,gBAAsC;IAEtC,MAAM,UAAU,GAAG,WAAW,CAAC,cAAc,CAAC,CAAC;IAC/C,MAAM,MAAM,GAAG,EAAE,CAAC,8BAA8B,CAAC,cAAc,EAAE,gBAAgB,CAAC,CAAC;IAEnF,MAAM,UAAU,GAAgC,EAAE,CAAC;IACnD,MAAM,YAAY,GAAgC,EAAE,CAAC;IAErD,sDAAsD;IACtD,MAAM,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC,KAAK,EAAE,UAAU,EAAE,EAAE;QAC1C,IAAI,KAAK,CAAC,UAAU,KAAK,UAAU,EAAE,CAAC;YACpC,gEAAgE;YAChE,OAAO;QACT,CAAC;QAED,MAAM,QAAQ,GAAG,GAAG,KAAK,CAAC,cAAc,CAAC,IAAI,IAAI,KAAK,CAAC,cAAc,CAAC,IAAI,EAAE,CAAC;QAC7E,IAAI,CAAC;YACH,EAAE,CAAC,IAAI,CAAC,UAAU,EAAE,UAAU,CAAC,CAAC;QAClC,CAAC;QAAC,OAAO,CAAC,EAAE,CAAC;YACX,UAAU,CAAC,IAAI,CAAC,IAAI,gCAAiB,CAAS,UAAU,EAAE,KAAK,CAAC,UAAU,EAAE,EAAE,EAAE,EAAE,QAAQ,EAAE,EAAE,CAAC,CAAC,CAAC,CAAC;QACpG,CAAC;IACH,CAAC,CAAC,CAAC;IAEH,0CAA0C;IAC1C,MAAM,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC,KAAK,EAAE,UAAU,EAAE,EAAE;QAC1C,IAAI,KAAK,CAAC,UAAU,KAAK,UAAU,EAAE,CAAC;YACpC,OAAO;QACT,CAAC;QAED,MAAM,QAAQ,GAAG,GAAG,KAAK,CAAC,cAAc,CAAC,IAAI,IAAI,KAAK,CAAC,cAAc,CAAC,IAAI,EAAE,CAAC;QAC7E,IAAI,CAAC;YACH,IAAI,CAAC,EAAE,CAAC,eAAe,CAAC,UAAU,EAAE,UAAU,CAAC,EAAE,CAAC;gBAChD,YAAY,CAAC,IAAI,CACf,IAAI,gCAAiB,CAAC,UAAU,EAAE,KAAK,CAAC,UAAU,EAAE,EAAE,EAAE,EAAE,QAAQ,EAAE,EAAE,IAAI,KAAK,CAAC,mBAAmB,CAAC,CAAC,CACtG,CAAC;YACJ,CAAC;QACH,CAAC;QAAC,OAAO,CAAC,EAAE,CAAC;YACX,YAAY,CAAC,IAAI,CAAC,IAAI,gCAAiB,CAAS,UAAU,EAAE,KAAK,CAAC,UAAU,EAAE,EAAE,EAAE,EAAE,QAAQ,EAAE,EAAE,CAAC,CAAC,CAAC,CAAC;QACtG,CAAC;IACH,CAAC,CAAC,CAAC;IAEH,IAAI,UAAU,CAAC,MAAM,IAAI,YAAY,CAAC,MAAM,EAAE,CAAC;QAC7C,MAAM,IAAI,sCAAuB,CAAC,UAAU,EAAE,YAAY,CAAC,CAAC;IAC9D,CAAC;IAED,OAAO,EAAE,CAAC;AACZ,CAAC;AAED,SAAS,WAAW,CAAC,GAAmB;IACtC,4EAA4E;IAC5E,OAAO,iBAAK,CAAC,UAAU,CAAC,GAAG,CAAC,QAAQ,EAAE,CAAC,CAAC;AAC1C,CAAC;AAEM,KAAK,UAAU,iCAAiC,CACrD,IAAoD,EACpD,EAA+B,EAC/B,cAA0C,EAC1C,cAAgD,EAChD,MAIC;IAED,MAAM,UAAU,GAAG,cAAc,CAAC,CAAC,CAAC,WAAW,CAAC,cAAc,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC;IAE5E,IAAI,oBAAoB,CAAC,EAAE,EAAE,cAAc,EAAE,MAAM,CAAC,gBAAgB,CAAC,EAAE,CAAC;QACtE,QAAQ,MAAM,CAAC,WAAW,EAAE,CAAC;YAC3B,KAAK,aAAa;gBAChB,IAAA,gBAAM,EAAC,UAAU,CAAC,CAAC;gBACnB,EAAE,CAAC,oBAAoB,CAAC,UAAU,CAAC,CAAC;gBACpC,eAAe,CAAC,GAAG,CAAC,EAAE,CAAC,YAAY,EAAE,EAAE,EAAE,CAAC,CAAC;gBAC3C,OAAO,EAAE,CAAC;YACZ,KAAK,eAAe;gBAClB,IAAA,gBAAM,EAAC,MAAM,CAAC,QAAQ,EAAE,6CAA6C,CAAC,CAAC;gBACvE,OAAO,MAAM,IAAI,CAAC,eAAe,CAAC,EAAE,EAAE,MAAM,CAAC,QAAQ,CAAC,CAAC;YACzD,KAAK,iBAAiB,CAAC,CAAC,CAAC;gBACvB,MAAM,IAAI,GAAG,EAAE,CAAC,YAAY,EAAE,CAAC;gBAC/B,MAAM,UAAU,GAAG,eAAe,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC;gBAC7C,IAAA,gBAAM,EACJ,UAAU,EACV,4CAA4C,eAAe,CAAC,IAAI;mIACyD,CAC1H,CAAC;gBACF,eAAe,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC;gBAC7B,UAAU,CAAC,mBAAmB,CAAC,EAAE,CAAC,CAAC;gBACnC,EAAE,GAAG,UAAU,CAAC;gBAChB,MAAM;YACR,CAAC;YACD;gBACE,0CAA0C;gBAC1C,IAAA,gBAAM,EAAC,MAAM,CAAC,QAAQ,EAAE,6CAA6C,CAAC,CAAC;gBACvE,IAAA,gBAAM,EAAC,UAAU,CAAC,CAAC;gBACnB,EAAE,CAAC,oBAAoB,CAAC,UAAU,CAAC,CAAC;gBACpC,MAAM,QAAQ,GAAG,MAAM,IAAI,CAAC,eAAe,CAAC,EAAE,EAAE,MAAM,CAAC,QAAQ,CAAC,CAAC;gBACjE,EAAE,CAAC,mBAAmB,CAAC,QAAQ,CAAC,CAAC;gBACjC,MAAM;QACV,CAAC;IACH,CAAC;SAAM,CAAC;QACN,QAAQ,MAAM,CAAC,WAAW,EAAE,CAAC;YAC3B,KAAK,aAAa,CAAC;YACnB,KAAK,eAAe;gBAClB;;;mBAGG;gBACH,OAAO,EAAE,CAAC;QACd,CAAC;IACH,CAAC;IAED,IAAA,gBAAM,EAAC,cAAc,CAAC,CAAC;IACvB,OAAO,qBAAqB,CAAC,EAAE,EAAE,cAAc,EAAE,cAAc,EAAE,MAAM,CAAC,gBAAgB,CAAC,CAAC;AAC5F,CAAC","sourcesContent":["import assert from 'assert';\n\nimport { BIP32Interface } from '@bitgo/utxo-lib';\nimport { BIP32, ECPair, fixedScriptWallet } from '@bitgo/wasm-utxo';\n\nimport { InputSigningError, TransactionSigningError } from './SigningError';\nimport { Musig2Participant } from './musig2';\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 * 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: BIP32Interface,\n  rootWalletKeys: fixedScriptWallet.RootWalletKeys,\n  replayProtection: ReplayProtectionKeys\n): fixedScriptWallet.BitGoPsbt {\n  const wasmSigner = toWasmBIP32(signerKeychain);\n  const parsed = tx.parseTransactionWithWalletKeys(rootWalletKeys, replayProtection);\n\n  const signErrors: InputSigningError<bigint>[] = [];\n  const verifyErrors: InputSigningError<bigint>[] = [];\n\n  // Sign all inputs (skipping replay protection inputs)\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      tx.sign(inputIndex, wasmSigner);\n    } catch (e) {\n      signErrors.push(new InputSigningError<bigint>(inputIndex, input.scriptType, { id: outputId }, e));\n    }\n  });\n\n  // Verify signatures for all signed inputs\n  parsed.inputs.forEach((input, inputIndex) => {\n    if (input.scriptType === 'p2shP2pk') {\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 (signErrors.length || verifyErrors.length) {\n    throw new TransactionSigningError(signErrors, verifyErrors);\n  }\n\n  return tx;\n}\n\nfunction toWasmBIP32(key: BIP32Interface): BIP32 {\n  // Convert using base58 string to ensure private key is properly transferred\n  return BIP32.fromBase58(key.toBase58());\n}\n\nexport async function signPsbtWithMusig2ParticipantWasm(\n  coin: Musig2Participant<fixedScriptWallet.BitGoPsbt>,\n  tx: fixedScriptWallet.BitGoPsbt,\n  signerKeychain: BIP32Interface | undefined,\n  rootWalletKeys: fixedScriptWallet.RootWalletKeys,\n  params: {\n    replayProtection: ReplayProtectionKeys;\n    signingStep: 'signerNonce' | 'cosignerNonce' | 'signerSignature' | undefined;\n    walletId: string | undefined;\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}\n"]}

package/dist/cjs/src/transaction/fixedScript/signTransaction.d.ts

@@ -1,8 +1,16 @@
 import { BIP32Interface } from '@bitgo/secp256k1';
 import * as utxolib from '@bitgo/utxo-lib';
 import { fixedScriptWallet } from '@bitgo/wasm-utxo';
+import { UtxoCoinName } from '../../names';
 import { Musig2Participant } from './musig2';
-export declare function signTransaction<T extends utxolib.bitgo.UtxoPsbt | utxolib.bitgo.UtxoTransaction<bigint | number> | fixedScriptWallet.BitGoPsbt>(coin: Musig2Participant<utxolib.bitgo.UtxoPsbt> | Musig2Participant<fixedScriptWallet.BitGoPsbt>, tx: T, signerKeychain: BIP32Interface | undefined, network: utxolib.Network, params: {
+import { ReplayProtectionKeys } from './signPsbtWasm';
+/**
+ * Sign and verify a PSBT using either utxolib or wasm-utxo depending on the PSBT type.
+ */
+export declare function signAndVerifyPsbt(psbt: utxolib.bitgo.UtxoPsbt, signerKeychain: BIP32Interface, rootWalletKeys: fixedScriptWallet.RootWalletKeys | undefined, replayProtection: ReplayProtectionKeys | undefined): utxolib.bitgo.UtxoPsbt;
+export declare function signAndVerifyPsbt(psbt: fixedScriptWallet.BitGoPsbt, signerKeychain: BIP32Interface, rootWalletKeys: fixedScriptWallet.RootWalletKeys, replayProtection: ReplayProtectionKeys): fixedScriptWallet.BitGoPsbt;
+export declare function signAndVerifyPsbt(psbt: utxolib.bitgo.UtxoPsbt | fixedScriptWallet.BitGoPsbt, signerKeychain: BIP32Interface, rootWalletKeys: fixedScriptWallet.RootWalletKeys, replayProtection: ReplayProtectionKeys): utxolib.bitgo.UtxoPsbt | fixedScriptWallet.BitGoPsbt;
+export declare function signTransaction<T extends utxolib.bitgo.UtxoPsbt | utxolib.bitgo.UtxoTransaction<bigint | number> | fixedScriptWallet.BitGoPsbt>(coin: Musig2Participant<utxolib.bitgo.UtxoPsbt> | Musig2Participant<fixedScriptWallet.BitGoPsbt>, tx: T, signerKeychain: BIP32Interface | undefined, coinName: UtxoCoinName, params: {
     walletId: string | undefined;
     txInfo: {
         unspents?: utxolib.bitgo.Unspent<bigint | number>[];

package/dist/cjs/src/transaction/fixedScript/signTransaction.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"signTransaction.d.ts","sourceRoot":"","sources":["../../../../../src/transaction/fixedScript/signTransaction.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAC;AAElD,OAAO,KAAK,OAAO,MAAM,iBAAiB,CAAC;AAC3C,OAAO,EAAE,iBAAiB,EAAE,MAAM,kBAAkB,CAAC;AAErD,OAAO,EAAE,iBAAiB,EAAE,MAAM,UAAU,CAAC;AAM7C,wBAAsB,eAAe,CACnC,CAAC,SAAS,OAAO,CAAC,KAAK,CAAC,QAAQ,GAAG,OAAO,CAAC,KAAK,CAAC,eAAe,CAAC,MAAM,GAAG,MAAM,CAAC,GAAG,iBAAiB,CAAC,SAAS,EAE/G,IAAI,EAAE,iBAAiB,CAAC,OAAO,CAAC,KAAK,CAAC,QAAQ,CAAC,GAAG,iBAAiB,CAAC,iBAAiB,CAAC,SAAS,CAAC,EAChG,EAAE,EAAE,CAAC,EACL,cAAc,EAAE,cAAc,GAAG,SAAS,EAC1C,OAAO,EAAE,OAAO,CAAC,OAAO,EACxB,MAAM,EAAE;IACN,QAAQ,EAAE,MAAM,GAAG,SAAS,CAAC;IAC7B,MAAM,EAAE;QAAE,QAAQ,CAAC,EAAE,OAAO,CAAC,KAAK,CAAC,OAAO,CAAC,MAAM,GAAG,MAAM,CAAC,EAAE,CAAA;KAAE,GAAG,SAAS,CAAC;IAC5E,eAAe,EAAE,OAAO,CAAC;IACzB,WAAW,EAAE,aAAa,GAAG,eAAe,GAAG,iBAAiB,GAAG,SAAS,CAAC;IAC7E,iBAAiB;IACjB,kCAAkC,EAAE,OAAO,CAAC;IAC5C,IAAI,EAAE,MAAM,EAAE,GAAG,SAAS,CAAC;IAC3B,WAAW,EAAE,MAAM,GAAG,SAAS,CAAC;CACjC,GACA,OAAO,CACR,OAAO,CAAC,KAAK,CAAC,QAAQ,GAAG,OAAO,CAAC,KAAK,CAAC,eAAe,CAAC,MAAM,GAAG,MAAM,CAAC,GAAG,iBAAiB,CAAC,SAAS,GAAG,MAAM,CAC/G,CAwCA"}
+{"version":3,"file":"signTransaction.d.ts","sourceRoot":"","sources":["../../../../../src/transaction/fixedScript/signTransaction.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAC;AAElD,OAAO,KAAK,OAAO,MAAM,iBAAiB,CAAC;AAC3C,OAAO,EAAE,iBAAiB,EAAE,MAAM,kBAAkB,CAAC;AAErD,OAAO,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAE3C,OAAO,EAAE,iBAAiB,EAAE,MAAM,UAAU,CAAC;AAG7C,OAAO,EAA4D,oBAAoB,EAAE,MAAM,gBAAgB,CAAC;AAGhH;;GAEG;AACH,wBAAgB,iBAAiB,CAC/B,IAAI,EAAE,OAAO,CAAC,KAAK,CAAC,QAAQ,EAC5B,cAAc,EAAE,cAAc,EAC9B,cAAc,EAAE,iBAAiB,CAAC,cAAc,GAAG,SAAS,EAC5D,gBAAgB,EAAE,oBAAoB,GAAG,SAAS,GACjD,OAAO,CAAC,KAAK,CAAC,QAAQ,CAAC;AAC1B,wBAAgB,iBAAiB,CAC/B,IAAI,EAAE,iBAAiB,CAAC,SAAS,EACjC,cAAc,EAAE,cAAc,EAC9B,cAAc,EAAE,iBAAiB,CAAC,cAAc,EAChD,gBAAgB,EAAE,oBAAoB,GACrC,iBAAiB,CAAC,SAAS,CAAC;AAC/B,wBAAgB,iBAAiB,CAC/B,IAAI,EAAE,OAAO,CAAC,KAAK,CAAC,QAAQ,GAAG,iBAAiB,CAAC,SAAS,EAC1D,cAAc,EAAE,cAAc,EAC9B,cAAc,EAAE,iBAAiB,CAAC,cAAc,EAChD,gBAAgB,EAAE,oBAAoB,GACrC,OAAO,CAAC,KAAK,CAAC,QAAQ,GAAG,iBAAiB,CAAC,SAAS,CAAC;AAgBxD,wBAAsB,eAAe,CACnC,CAAC,SAAS,OAAO,CAAC,KAAK,CAAC,QAAQ,GAAG,OAAO,CAAC,KAAK,CAAC,eAAe,CAAC,MAAM,GAAG,MAAM,CAAC,GAAG,iBAAiB,CAAC,SAAS,EAE/G,IAAI,EAAE,iBAAiB,CAAC,OAAO,CAAC,KAAK,CAAC,QAAQ,CAAC,GAAG,iBAAiB,CAAC,iBAAiB,CAAC,SAAS,CAAC,EAChG,EAAE,EAAE,CAAC,EACL,cAAc,EAAE,cAAc,GAAG,SAAS,EAC1C,QAAQ,EAAE,YAAY,EACtB,MAAM,EAAE;IACN,QAAQ,EAAE,MAAM,GAAG,SAAS,CAAC;IAC7B,MAAM,EAAE;QAAE,QAAQ,CAAC,EAAE,OAAO,CAAC,KAAK,CAAC,OAAO,CAAC,MAAM,GAAG,MAAM,CAAC,EAAE,CAAA;KAAE,GAAG,SAAS,CAAC;IAC5E,eAAe,EAAE,OAAO,CAAC;IACzB,WAAW,EAAE,aAAa,GAAG,eAAe,GAAG,iBAAiB,GAAG,SAAS,CAAC;IAC7E,iBAAiB;IACjB,kCAAkC,EAAE,OAAO,CAAC;IAC5C,IAAI,EAAE,MAAM,EAAE,GAAG,SAAS,CAAC;IAC3B,WAAW,EAAE,MAAM,GAAG,SAAS,CAAC;CACjC,GACA,OAAO,CACR,OAAO,CAAC,KAAK,CAAC,QAAQ,GAAG,OAAO,CAAC,KAAK,CAAC,eAAe,CAAC,MAAM,GAAG,MAAM,CAAC,GAAG,iBAAiB,CAAC,SAAS,GAAG,MAAM,CAC/G,CAqDA"}

package/dist/cjs/src/transaction/fixedScript/signTransaction.js

@@ -3,6 +3,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.signAndVerifyPsbt = signAndVerifyPsbt;
 exports.signTransaction = signTransaction;
 const assert_1 = __importDefault(require("assert"));
 const sdk_core_1 = require("@bitgo/sdk-core");
@@ -10,36 +11,54 @@ const lodash_1 = __importDefault(require("lodash"));
 const utxo_lib_1 = require("@bitgo/utxo-lib");
 const wasm_utxo_1 = require("@bitgo/wasm-utxo");
 const signLegacyTransaction_1 = require("./signLegacyTransaction");
-const signPsbt_1 = require("./signPsbt");
+const signPsbtUtxolib_1 = require("./signPsbtUtxolib");
 const signPsbtWasm_1 = require("./signPsbtWasm");
 const replayProtection_1 = require("./replayProtection");
-async function signTransaction(coin, tx, signerKeychain, network, params) {
+function signAndVerifyPsbt(psbt, signerKeychain, rootWalletKeys, replayProtection) {
+    if (psbt instanceof utxo_lib_1.bitgo.UtxoPsbt) {
+        return (0, signPsbtUtxolib_1.signAndVerifyPsbt)(psbt, signerKeychain);
+    }
+    else {
+        (0, assert_1.default)(rootWalletKeys, 'rootWalletKeys required for wasm-utxo signing');
+        (0, assert_1.default)(replayProtection, 'replayProtection required for wasm-utxo signing');
+        return (0, signPsbtWasm_1.signAndVerifyPsbtWasm)(psbt, signerKeychain, rootWalletKeys, replayProtection);
+    }
+}
+async function signTransaction(coin, tx, signerKeychain, coinName, params) {
     let isLastSignature = false;
     if (lodash_1.default.isBoolean(params.isLastSignature)) {
         // if build is called instead of buildIncomplete, no signature placeholders are left in the sig script
         isLastSignature = params.isLastSignature;
     }
     if (tx instanceof utxo_lib_1.bitgo.UtxoPsbt) {
-        return (0, signPsbt_1.signPsbtWithMusig2Participant)(coin, tx, signerKeychain, {
-            isLastSignature,
+        const signedPsbt = await (0, signPsbtUtxolib_1.signPsbtWithMusig2ParticipantUtxolib)(coin, tx, signerKeychain, {
             signingStep: params.signingStep,
             walletId: params.walletId,
         });
+        if (isLastSignature) {
+            signedPsbt.finalizeAllInputs();
+            return signedPsbt.extractTransaction();
+        }
+        return signedPsbt;
     }
     else if (tx instanceof wasm_utxo_1.fixedScriptWallet.BitGoPsbt) {
         (0, assert_1.default)(params.pubs, 'pubs are required for fixed script signing');
         (0, assert_1.default)((0, sdk_core_1.isTriple)(params.pubs), 'pubs must be a triple');
         const rootWalletKeys = wasm_utxo_1.fixedScriptWallet.RootWalletKeys.fromXpubs(params.pubs);
-        return (0, signPsbtWasm_1.signPsbtWithMusig2ParticipantWasm)(coin, tx, signerKeychain, rootWalletKeys, {
+        const signedPsbt = await (0, signPsbtWasm_1.signPsbtWithMusig2ParticipantWasm)(coin, tx, signerKeychain, rootWalletKeys, {
             replayProtection: {
-                publicKeys: (0, replayProtection_1.getReplayProtectionPubkeys)(network),
+                publicKeys: (0, replayProtection_1.getReplayProtectionPubkeys)(coinName),
             },
-            isLastSignature,
             signingStep: params.signingStep,
             walletId: params.walletId,
         });
+        if (isLastSignature) {
+            signedPsbt.finalizeAllInputs();
+            return Buffer.from(signedPsbt.extractTransaction());
+        }
+        return signedPsbt;
     }
-    return (0, signLegacyTransaction_1.signLegacyTransaction)(tx, signerKeychain, {
+    return (0, signLegacyTransaction_1.signLegacyTransaction)(tx, signerKeychain, coinName, {
         isLastSignature,
         signingStep: params.signingStep,
         txInfo: params.txInfo,
@@ -47,4 +66,4 @@ async function signTransaction(coin, tx, signerKeychain, network, params) {
         cosignerPub: params.cosignerPub,
     });
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"signTransaction.js","sourceRoot":"","sources":["../../../../../src/transaction/fixedScript/signTransaction.ts"],"names":[],"mappings":";;;;;AAsCA,8CAaC;AAED,0CAwEC;AA7HD,oDAA4B;AAE5B,8CAA2C;AAC3C,oDAAuB;AAEvB,8CAAwC;AAExC,gDAAqD;AAKrD,mEAAgE;AAChE,uDAAwH;AACxH,iDAAgH;AAChH,yDAAgE;AAuBhE,SAAgB,iBAAiB,CAC/B,IAA0D,EAC1D,cAA8B,EAC9B,cAA4D,EAC5D,gBAAkD;IAElD,IAAI,IAAI,YAAY,gBAAK,CAAC,QAAQ,EAAE,CAAC;QACnC,OAAO,IAAA,mCAAwB,EAAC,IAAI,EAAE,cAAc,CAAC,CAAC;IACxD,CAAC;SAAM,CAAC;QACN,IAAA,gBAAM,EAAC,cAAc,EAAE,+CAA+C,CAAC,CAAC;QACxE,IAAA,gBAAM,EAAC,gBAAgB,EAAE,iDAAiD,CAAC,CAAC;QAC5E,OAAO,IAAA,oCAAqB,EAAC,IAAI,EAAE,cAAc,EAAE,cAAc,EAAE,gBAAgB,CAAC,CAAC;IACvF,CAAC;AACH,CAAC;AAEM,KAAK,UAAU,eAAe,CAGnC,IAAgG,EAChG,EAAK,EACL,cAA0C,EAC1C,QAAsB,EACtB,MASC;IAID,IAAI,eAAe,GAAG,KAAK,CAAC;IAC5B,IAAI,gBAAC,CAAC,SAAS,CAAC,MAAM,CAAC,eAAe,CAAC,EAAE,CAAC;QACxC,sGAAsG;QACtG,eAAe,GAAG,MAAM,CAAC,eAAe,CAAC;IAC3C,CAAC;IAED,IAAI,EAAE,YAAY,gBAAK,CAAC,QAAQ,EAAE,CAAC;QACjC,MAAM,UAAU,GAAG,MAAM,IAAA,sDAAoC,EAC3D,IAAiD,EACjD,EAAE,EACF,cAAc,EACd;YACE,WAAW,EAAE,MAAM,CAAC,WAAW;YAC/B,QAAQ,EAAE,MAAM,CAAC,QAAQ;SAC1B,CACF,CAAC;QACF,IAAI,eAAe,EAAE,CAAC;YACpB,UAAU,CAAC,iBAAiB,EAAE,CAAC;YAC/B,OAAO,UAAU,CAAC,kBAAkB,EAAE,CAAC;QACzC,CAAC;QACD,OAAO,UAAU,CAAC;IACpB,CAAC;SAAM,IAAI,EAAE,YAAY,6BAAiB,CAAC,SAAS,EAAE,CAAC;QACrD,IAAA,gBAAM,EAAC,MAAM,CAAC,IAAI,EAAE,4CAA4C,CAAC,CAAC;QAClE,IAAA,gBAAM,EAAC,IAAA,mBAAQ,EAAC,MAAM,CAAC,IAAI,CAAC,EAAE,uBAAuB,CAAC,CAAC;QACvD,MAAM,cAAc,GAAG,6BAAiB,CAAC,cAAc,CAAC,SAAS,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC;QAC/E,MAAM,UAAU,GAAG,MAAM,IAAA,gDAAiC,EACxD,IAAsD,EACtD,EAAE,EACF,cAAc,EACd,cAAc,EACd;YACE,gBAAgB,EAAE;gBAChB,UAAU,EAAE,IAAA,6CAA0B,EAAC,QAAQ,CAAC;aACjD;YACD,WAAW,EAAE,MAAM,CAAC,WAAW;YAC/B,QAAQ,EAAE,MAAM,CAAC,QAAQ;SAC1B,CACF,CAAC;QACF,IAAI,eAAe,EAAE,CAAC;YACpB,UAAU,CAAC,iBAAiB,EAAE,CAAC;YAC/B,OAAO,MAAM,CAAC,IAAI,CAAC,UAAU,CAAC,kBAAkB,EAAE,CAAC,CAAC;QACtD,CAAC;QACD,OAAO,UAAU,CAAC;IACpB,CAAC;IAED,OAAO,IAAA,6CAAqB,EAAC,EAAE,EAAE,cAAc,EAAE,QAAQ,EAAE;QACzD,eAAe;QACf,WAAW,EAAE,MAAM,CAAC,WAAW;QAC/B,MAAM,EAAE,MAAM,CAAC,MAAM;QACrB,IAAI,EAAE,MAAM,CAAC,IAAI;QACjB,WAAW,EAAE,MAAM,CAAC,WAAW;KAChC,CAAC,CAAC;AACL,CAAC","sourcesContent":["import assert from 'assert';\n\nimport { isTriple } from '@bitgo/sdk-core';\nimport _ from 'lodash';\nimport { BIP32Interface } from '@bitgo/secp256k1';\nimport { bitgo } from '@bitgo/utxo-lib';\nimport * as utxolib from '@bitgo/utxo-lib';\nimport { fixedScriptWallet } from '@bitgo/wasm-utxo';\n\nimport { UtxoCoinName } from '../../names';\n\nimport { Musig2Participant } from './musig2';\nimport { signLegacyTransaction } from './signLegacyTransaction';\nimport { signPsbtWithMusig2ParticipantUtxolib, signAndVerifyPsbt as signAndVerifyPsbtUtxolib } from './signPsbtUtxolib';\nimport { signPsbtWithMusig2ParticipantWasm, signAndVerifyPsbtWasm, ReplayProtectionKeys } from './signPsbtWasm';\nimport { getReplayProtectionPubkeys } from './replayProtection';\n\n/**\n * Sign and verify a PSBT using either utxolib or wasm-utxo depending on the PSBT type.\n */\nexport function signAndVerifyPsbt(\n  psbt: utxolib.bitgo.UtxoPsbt,\n  signerKeychain: BIP32Interface,\n  rootWalletKeys: fixedScriptWallet.RootWalletKeys | undefined,\n  replayProtection: ReplayProtectionKeys | undefined\n): utxolib.bitgo.UtxoPsbt;\nexport function signAndVerifyPsbt(\n  psbt: fixedScriptWallet.BitGoPsbt,\n  signerKeychain: BIP32Interface,\n  rootWalletKeys: fixedScriptWallet.RootWalletKeys,\n  replayProtection: ReplayProtectionKeys\n): fixedScriptWallet.BitGoPsbt;\nexport function signAndVerifyPsbt(\n  psbt: utxolib.bitgo.UtxoPsbt | fixedScriptWallet.BitGoPsbt,\n  signerKeychain: BIP32Interface,\n  rootWalletKeys: fixedScriptWallet.RootWalletKeys,\n  replayProtection: ReplayProtectionKeys\n): utxolib.bitgo.UtxoPsbt | fixedScriptWallet.BitGoPsbt;\nexport function signAndVerifyPsbt(\n  psbt: utxolib.bitgo.UtxoPsbt | fixedScriptWallet.BitGoPsbt,\n  signerKeychain: BIP32Interface,\n  rootWalletKeys: fixedScriptWallet.RootWalletKeys | undefined,\n  replayProtection: ReplayProtectionKeys | undefined\n): utxolib.bitgo.UtxoPsbt | fixedScriptWallet.BitGoPsbt {\n  if (psbt instanceof bitgo.UtxoPsbt) {\n    return signAndVerifyPsbtUtxolib(psbt, signerKeychain);\n  } else {\n    assert(rootWalletKeys, 'rootWalletKeys required for wasm-utxo signing');\n    assert(replayProtection, 'replayProtection required for wasm-utxo signing');\n    return signAndVerifyPsbtWasm(psbt, signerKeychain, rootWalletKeys, replayProtection);\n  }\n}\n\nexport async function signTransaction<\n  T extends utxolib.bitgo.UtxoPsbt | utxolib.bitgo.UtxoTransaction<bigint | number> | fixedScriptWallet.BitGoPsbt\n>(\n  coin: Musig2Participant<utxolib.bitgo.UtxoPsbt> | Musig2Participant<fixedScriptWallet.BitGoPsbt>,\n  tx: T,\n  signerKeychain: BIP32Interface | undefined,\n  coinName: UtxoCoinName,\n  params: {\n    walletId: string | undefined;\n    txInfo: { unspents?: utxolib.bitgo.Unspent<bigint | number>[] } | undefined;\n    isLastSignature: boolean;\n    signingStep: 'signerNonce' | 'cosignerNonce' | 'signerSignature' | undefined;\n    /** deprecated */\n    allowNonSegwitSigningWithoutPrevTx: boolean;\n    pubs: string[] | undefined;\n    cosignerPub: string | undefined;\n  }\n): Promise<\n  utxolib.bitgo.UtxoPsbt | utxolib.bitgo.UtxoTransaction<bigint | number> | fixedScriptWallet.BitGoPsbt | Buffer\n> {\n  let isLastSignature = false;\n  if (_.isBoolean(params.isLastSignature)) {\n    // if build is called instead of buildIncomplete, no signature placeholders are left in the sig script\n    isLastSignature = params.isLastSignature;\n  }\n\n  if (tx instanceof bitgo.UtxoPsbt) {\n    const signedPsbt = await signPsbtWithMusig2ParticipantUtxolib(\n      coin as Musig2Participant<utxolib.bitgo.UtxoPsbt>,\n      tx,\n      signerKeychain,\n      {\n        signingStep: params.signingStep,\n        walletId: params.walletId,\n      }\n    );\n    if (isLastSignature) {\n      signedPsbt.finalizeAllInputs();\n      return signedPsbt.extractTransaction();\n    }\n    return signedPsbt;\n  } else if (tx instanceof fixedScriptWallet.BitGoPsbt) {\n    assert(params.pubs, 'pubs are required for fixed script signing');\n    assert(isTriple(params.pubs), 'pubs must be a triple');\n    const rootWalletKeys = fixedScriptWallet.RootWalletKeys.fromXpubs(params.pubs);\n    const signedPsbt = await signPsbtWithMusig2ParticipantWasm(\n      coin as Musig2Participant<fixedScriptWallet.BitGoPsbt>,\n      tx,\n      signerKeychain,\n      rootWalletKeys,\n      {\n        replayProtection: {\n          publicKeys: getReplayProtectionPubkeys(coinName),\n        },\n        signingStep: params.signingStep,\n        walletId: params.walletId,\n      }\n    );\n    if (isLastSignature) {\n      signedPsbt.finalizeAllInputs();\n      return Buffer.from(signedPsbt.extractTransaction());\n    }\n    return signedPsbt;\n  }\n\n  return signLegacyTransaction(tx, signerKeychain, coinName, {\n    isLastSignature,\n    signingStep: params.signingStep,\n    txInfo: params.txInfo,\n    pubs: params.pubs,\n    cosignerPub: params.cosignerPub,\n  });\n}\n"]}