@bitgo-beta/abstract-utxo 1.1.1-beta.232 → 1.1.1-beta.2321

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

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.pubkeyTestnet = exports.pubkeyProd = void 0;
+exports.getReplayProtectionPubkeys = getReplayProtectionPubkeys;
+exports.getReplayProtectionAddresses = getReplayProtectionAddresses;
+exports.isReplayProtectionUnspent = isReplayProtectionUnspent;
+const wasm_utxo_1 = require("@bitgo/wasm-utxo");
+exports.pubkeyProd = Buffer.from('0255b9f71ac2c78fffd83e3e37b9e17ae70d5437b7f56d0ed2e93b7de08015aa59', 'hex');
+exports.pubkeyTestnet = Buffer.from('0219da48412c2268865fe8c126327d1b12eee350a3b69eb09e3323cc9a11828945', 'hex');
+function getReplayProtectionPubkeys(coinName) {
+    switch (coinName) {
+        case 'bch':
+        case 'bsv':
+            return [exports.pubkeyProd];
+        case 'tbsv':
+        case 'tbch':
+            return [exports.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')];
+function getReplayProtectionAddresses(coinName, format = 'default') {
+    switch (coinName) {
+        case 'bch':
+        case 'bsv':
+            return replayProtectionScriptsProd.map((script) => wasm_utxo_1.address.fromOutputScriptWithCoin(script, coinName, format));
+        case 'tbsv':
+        case 'tbch':
+            return replayProtectionScriptsTestnet.map((script) => wasm_utxo_1.address.fromOutputScriptWithCoin(script, coinName, format));
+        default:
+            return [];
+    }
+}
+function isReplayProtectionUnspent(u, coinName) {
+    return getReplayProtectionAddresses(coinName).includes(u.address);
+}
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,27 @@
+import { BIP32, bip32, ECPair, fixedScriptWallet } from '@bitgo/wasm-utxo';
+import { Musig2Participant } from './musig2';
+export type ReplayProtectionKeys = {
+    publicKeys: (Uint8Array | ECPair)[];
+};
+/**
+ * Verify signatures on all signed inputs, per-input for granular error reporting.
+ * Shared by the generic wasm signing path and Zec's Ironwood (v6) signing path.
+ */
+export declare function verifyPsbtSignaturesWasm(tx: fixedScriptWallet.BitGoPsbt, wasmSigner: BIP32, rootWalletKeys: fixedScriptWallet.RootWalletKeys, replayProtection: ReplayProtectionKeys): void;
+/** Embed the wasm-utxo version metadata into the signed PSBT. Shared by all wasm signing paths. */
+export declare function writeWasmUtxoSignedWithKv(tx: fixedScriptWallet.BitGoPsbt): void;
+/**
+ * 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/cjs/src/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;;;GAGG;AACH,wBAAgB,wBAAwB,CACtC,EAAE,EAAE,iBAAiB,CAAC,SAAS,EAC/B,UAAU,EAAE,KAAK,EACjB,cAAc,EAAE,iBAAiB,CAAC,cAAc,EAChD,gBAAgB,EAAE,oBAAoB,GACrC,IAAI,CAyBN;AAED,mGAAmG;AACnG,wBAAgB,yBAAyB,CAAC,EAAE,EAAE,iBAAiB,CAAC,SAAS,GAAG,IAAI,CAS/E;AAED;;;;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,CAiB7B;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/cjs/src/transaction/fixedScript/signPsbtWasm.js

@@ -0,0 +1,130 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.verifyPsbtSignaturesWasm = verifyPsbtSignaturesWasm;
+exports.writeWasmUtxoSignedWithKv = writeWasmUtxoSignedWithKv;
+exports.signAndVerifyPsbtWasm = signAndVerifyPsbtWasm;
+exports.signPsbtWithMusig2ParticipantWasm = signPsbtWithMusig2ParticipantWasm;
+const assert_1 = __importDefault(require("assert"));
+const wasm_utxo_1 = require("@bitgo/wasm-utxo");
+const SigningError_1 = require("./SigningError");
+function toWasmBIP32(key) {
+    return key instanceof wasm_utxo_1.BIP32 ? key : wasm_utxo_1.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');
+}
+/**
+ * Verify signatures on all signed inputs, per-input for granular error reporting.
+ * Shared by the generic wasm signing path and Zec's Ironwood (v6) signing path.
+ */
+function verifyPsbtSignaturesWasm(tx, wasmSigner, rootWalletKeys, replayProtection) {
+    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 SigningError_1.InputSigningError(inputIndex, input.scriptType, { id: outputId }, new Error('invalid signature')));
+            }
+        }
+        catch (e) {
+            verifyErrors.push(new SigningError_1.InputSigningError(inputIndex, input.scriptType, { id: outputId }, e));
+        }
+    });
+    if (verifyErrors.length) {
+        throw new SigningError_1.TransactionSigningError([], verifyErrors);
+    }
+}
+/** Embed the wasm-utxo version metadata into the signed PSBT. Shared by all wasm signing paths. */
+function writeWasmUtxoSignedWithKv(tx) {
+    const versionInfo = (0, wasm_utxo_1.getWasmUtxoVersion)();
+    const versionPayload = new TextEncoder().encode(JSON.stringify({
+        version: versionInfo.version,
+        gitHash: versionInfo.gitHash,
+    }));
+    tx.setKV({ type: 'bitgo', subtype: wasm_utxo_1.fixedScriptWallet.BitGoKeySubtype.WasmUtxoSignedWith }, versionPayload);
+}
+/**
+ * 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.
+ */
+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 SigningError_1.BulkSigningError(e);
+    }
+    verifyPsbtSignaturesWasm(tx, wasmSigner, rootWalletKeys, replayProtection);
+    if (writeSignedWith) {
+        writeWasmUtxoSignedWithKv(tx);
+    }
+    return tx;
+}
+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':
+                (0, assert_1.default)(wasmSigner);
+                tx.generateMusig2Nonces(wasmSigner);
+                PSBT_CACHE_WASM.set(tx.unsignedTxId(), 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.unsignedTxId();
+                const cachedPsbt = PSBT_CACHE_WASM.get(txId);
+                (0, assert_1.default)(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
+                (0, assert_1.default)(params.walletId, 'walletId is required for MuSig2 bitgo nonce');
+                (0, assert_1.default)(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;
+        }
+    }
+    (0, assert_1.default)(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 * Verify signatures on all signed inputs, per-input for granular error reporting.\n * Shared by the generic wasm signing path and Zec's Ironwood (v6) signing path.\n */\nexport function verifyPsbtSignaturesWasm(\n  tx: fixedScriptWallet.BitGoPsbt,\n  wasmSigner: BIP32,\n  rootWalletKeys: fixedScriptWallet.RootWalletKeys,\n  replayProtection: ReplayProtectionKeys\n): void {\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\n/** Embed the wasm-utxo version metadata into the signed PSBT. Shared by all wasm signing paths. */\nexport function writeWasmUtxoSignedWithKv(tx: fixedScriptWallet.BitGoPsbt): void {\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/**\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  verifyPsbtSignaturesWasm(tx, wasmSigner, rootWalletKeys, replayProtection);\n\n  if (writeSignedWith) {\n    writeWasmUtxoSignedWithKv(tx);\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/cjs/src/transaction/fixedScript/signTransaction.d.ts

@@ -0,0 +1,31 @@
+import { BIP32, bip32, fixedScriptWallet } from '@bitgo/wasm-utxo';
+import { UtxoCoinName, WasmUtxoCoinName } 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;
+/**
+ * Finalize a signed PSBT into its final form: the extracted transaction bytes on the last
+ * signature round (unless the caller asked to keep the PSBT), otherwise the signed PSBT itself.
+ * Shared by the generic signing path and Zec's Ironwood (v6) signing path.
+ */
+export declare function finalizeSignedPsbt(signedPsbt: fixedScriptWallet.BitGoPsbt, { isLastSignature, extractTransaction }: {
+    isLastSignature?: boolean;
+    extractTransaction?: boolean;
+}): fixedScriptWallet.BitGoPsbt | Buffer;
+export declare function signTransaction(coin: Musig2Participant<fixedScriptWallet.BitGoPsbt>, tx: fixedScriptWallet.BitGoPsbt, signerKeychain: bip32.BIP32Interface | undefined, coinName: UtxoCoinName | WasmUtxoCoinName, 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/cjs/src/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,gBAAgB,EAAE,MAAM,aAAa,CAAC;AAC7D,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;;;;GAIG;AACH,wBAAgB,kBAAkB,CAChC,UAAU,EAAE,iBAAiB,CAAC,SAAS,EACvC,EAAE,eAAuB,EAAE,kBAAyB,EAAE,EAAE;IAAE,eAAe,CAAC,EAAE,OAAO,CAAC;IAAC,kBAAkB,CAAC,EAAE,OAAO,CAAA;CAAE,GAClH,iBAAiB,CAAC,SAAS,GAAG,MAAM,CAStC;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,GAAG,gBAAgB,EACzC,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,CAqB/C"}

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

@@ -0,0 +1,55 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.signAndVerifyPsbt = signAndVerifyPsbt;
+exports.finalizeSignedPsbt = finalizeSignedPsbt;
+exports.signTransaction = signTransaction;
+const assert_1 = __importDefault(require("assert"));
+const sdk_core_1 = require("@bitgo-beta/sdk-core");
+const lodash_1 = __importDefault(require("lodash"));
+const wasm_utxo_1 = require("@bitgo/wasm-utxo");
+const signPsbtWasm_1 = require("./signPsbtWasm");
+const replayProtection_1 = require("./replayProtection");
+function signAndVerifyPsbt(psbt, signerKeychain, rootWalletKeys, replayProtection, options = {}) {
+    (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, options);
+}
+/**
+ * Finalize a signed PSBT into its final form: the extracted transaction bytes on the last
+ * signature round (unless the caller asked to keep the PSBT), otherwise the signed PSBT itself.
+ * Shared by the generic signing path and Zec's Ironwood (v6) signing path.
+ */
+function finalizeSignedPsbt(signedPsbt, { isLastSignature = false, extractTransaction = true }) {
+    if (!isLastSignature) {
+        return signedPsbt;
+    }
+    if (extractTransaction) {
+        signedPsbt.finalizeAllInputs();
+        return Buffer.from(signedPsbt.extractTransaction().toBytes());
+    }
+    return signedPsbt;
+}
+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;
+    }
+    const { extractTransaction = true } = params;
+    (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);
+    const signedPsbt = await (0, signPsbtWasm_1.signPsbtWithMusig2ParticipantWasm)(coin, tx, signerKeychain, rootWalletKeys, {
+        replayProtection: {
+            publicKeys: (0, replayProtection_1.getReplayProtectionPubkeys)(coinName),
+        },
+        signingStep: params.signingStep,
+        walletId: params.walletId,
+        writeSignedWith: params.writeSignedWith,
+    });
+    return finalizeSignedPsbt(signedPsbt, { isLastSignature, extractTransaction });
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/cjs/src/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/cjs/src/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"}

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

@@ -0,0 +1,182 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.verifyTransaction = verifyTransaction;
+const debug_1 = __importDefault(require("debug"));
+const lodash_1 = __importDefault(require("lodash"));
+const bignumber_js_1 = __importDefault(require("bignumber.js"));
+const sdk_core_1 = require("@bitgo-beta/sdk-core");
+const wasm_utxo_1 = require("@bitgo/wasm-utxo");
+const decode_1 = require("../decode");
+const verifyKey_1 = require("../../verifyKey");
+const debug = (0, debug_1.default)('bitgo:abstract-utxo:verifyTransaction');
+/**
+ * Get the maximum percentage limit for pay-as-you-go outputs
+ *
+ * @protected
+ */
+function getPayGoLimit(allowPaygoOutput) {
+    // allowing paygo outputs needs to be the default behavior, so only disallow paygo outputs if the
+    // relevant verification option is both set and false
+    if (!lodash_1.default.isNil(allowPaygoOutput) && !allowPaygoOutput) {
+        return 0;
+    }
+    // 150 basis points is the absolute permitted maximum if paygo outputs are allowed
+    return 0.015;
+}
+/**
+ * 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
+ */
+async function verifyTransaction(coin, bitgo, params) {
+    const { txParams, txPrebuild, wallet, verification = {}, reqId } = params;
+    const txExplanation = await sdk_core_1.TxIntentMismatchError.tryGetTxExplanation(coin, txPrebuild);
+    // Helper to throw TxIntentMismatchError with consistent context
+    const throwTxMismatch = (message) => {
+        throw new sdk_core_1.TxIntentMismatchError(message, reqId, [txParams], txPrebuild.txHex, txExplanation);
+    };
+    if (!lodash_1.default.isUndefined(verification.disableNetworking) && !lodash_1.default.isBoolean(verification.disableNetworking)) {
+        throw new TypeError('verification.disableNetworking must be a boolean');
+    }
+    const isPsbt = txPrebuild.txHex && (0, wasm_utxo_1.hasPsbtMagic)((0, decode_1.stringToBufferTryFormats)(txPrebuild.txHex, ['hex', 'base64']));
+    if (isPsbt && txPrebuild.txInfo?.unspents) {
+        throw new Error('should not have unspents in txInfo for psbt');
+    }
+    const disableNetworking = !!verification.disableNetworking;
+    const isBridging = txParams.type === 'bridging';
+    const parsedTransaction = await coin.parseTransaction({
+        txParams,
+        txPrebuild,
+        wallet,
+        verification,
+        reqId,
+    });
+    const keychains = parsedTransaction.keychains;
+    // verify that the claimed user public key corresponds to the wallet's user private key
+    let userPublicKeyVerified = false;
+    try {
+        // verify the user public key matches the private key - this will throw if there is no match
+        userPublicKeyVerified = await (0, verifyKey_1.verifyUserPublicKey)(bitgo, {
+            userKeychain: keychains.user,
+            disableNetworking,
+            txParams,
+        });
+    }
+    catch (e) {
+        debug('failed to verify user public key!', e);
+    }
+    // let's verify these keychains
+    const keySignatures = parsedTransaction.keySignatures;
+    if (!lodash_1.default.isEmpty(keySignatures)) {
+        const verify = (key, pub) => {
+            if (!keychains.user || !keychains.user.pub) {
+                throwTxMismatch('missing user keychain');
+            }
+            return (0, verifyKey_1.verifyKeySignature)({
+                userKeychain: keychains.user,
+                keychainToVerify: key,
+                keySignature: pub,
+            });
+        };
+        const isBackupKeySignatureValid = verify(keychains.backup, keySignatures.backupPub);
+        const isBitgoKeySignatureValid = verify(keychains.bitgo, keySignatures.bitgoPub);
+        if (!isBackupKeySignatureValid || !isBitgoKeySignatureValid) {
+            throw new Error('secondary public key signatures invalid');
+        }
+        debug('successfully verified backup and bitgo key signatures');
+    }
+    else if (!disableNetworking) {
+        // these keys were obtained online and their signatures were not verified
+        // this could be dangerous
+        console.log('unsigned keys obtained online are being used for address verification');
+    }
+    if (parsedTransaction.needsCustomChangeKeySignatureVerification) {
+        if (!keychains.user || !userPublicKeyVerified) {
+            throw new Error('transaction requires verification of user public key, but it was unable to be verified');
+        }
+        const customChangeKeySignaturesVerified = (0, verifyKey_1.verifyCustomChangeKeySignatures)(parsedTransaction, keychains.user);
+        if (!customChangeKeySignaturesVerified) {
+            throw new Error('transaction requires verification of custom change key signatures, but they were unable to be verified');
+        }
+        debug('successfully verified user public key and custom change key signatures');
+    }
+    if (txParams.qr) {
+        const allExternalOutputs = [
+            ...parsedTransaction.explicitExternalOutputs,
+            ...parsedTransaction.implicitExternalOutputs,
+        ];
+        if (allExternalOutputs.length > 0) {
+            throwTxMismatch('quantum-resistant sweep transactions must only contain wallet-internal outputs');
+        }
+        return true;
+    }
+    const missingOutputs = parsedTransaction.missingOutputs;
+    if (missingOutputs.length !== 0) {
+        // there are some outputs in the recipients list that have not made it into the actual transaction
+        throwTxMismatch('expected outputs missing in transaction prebuild');
+    }
+    const intendedExternalSpend = parsedTransaction.explicitExternalSpendAmount;
+    // this is a limit we impose for the total value that is amended to the transaction beyond what was originally intended
+    const payAsYouGoLimit = new bignumber_js_1.default(getPayGoLimit(verification.allowPaygoOutput)).multipliedBy(intendedExternalSpend.toString());
+    /*
+    Some explanation for why we're doing what we're doing:
+    Some customers will have an output to BitGo's PAYGo wallet added to their transaction, and we need to account for
+    it here. To protect someone tampering with the output to make it send more than it should to BitGo, we define a
+    threshold for the output's value above which we'll throw an error, because the paygo output should never be that
+    high.
+     */
+    // make sure that all the extra addresses are change addresses
+    // get all the additional external outputs the server added and calculate their values
+    const nonChangeAmount = new bignumber_js_1.default(parsedTransaction.implicitExternalSpendAmount.toString());
+    debug('Intended spend is %s, Non-change amount is %s, paygo limit is %s', intendedExternalSpend.toString(), nonChangeAmount.toString(), payAsYouGoLimit.toString());
+    // There are two instances where we will get into this point here
+    if (nonChangeAmount.gt(payAsYouGoLimit)) {
+        if (isBridging) {
+            // The implicit external output is the bridge deposit address (see note above); it has no
+            // recipient to match against, so instead verify the total implicit external spend equals the
+            // intended bridge amount from bridgingParams.
+            const bridgeAmount = txParams.bridgingParams?.sbtc?.amount;
+            if (bridgeAmount === undefined) {
+                throwTxMismatch('bridging transaction is missing bridgingParams.sbtc.amount');
+            }
+            else if (!nonChangeAmount.eq(bridgeAmount.toString())) {
+                throwTxMismatch(`bridging output amount (${nonChangeAmount.toString()}) does not match intended bridge amount (${bridgeAmount})`);
+            }
+            else {
+                debug('verified bridging output amount matches bridgingParams.sbtc.amount');
+            }
+        }
+        else if (isPsbt && parsedTransaction.customChange) {
+            // In the case that we have a custom change address on a wallet and we are building the transaction
+            // with a PSBT, we do not have the metadata to verify the address from the custom change wallet, nor
+            // can we fetch that information from the other wallet because we may not have the credentials. Therefore,
+            // we will not throw an error here, but we will log a warning.
+            debug(`cannot verify some of the addresses because it belongs to a separate wallet`);
+        }
+        else {
+            // the additional external outputs can only be BitGo's pay-as-you-go fee, but we cannot verify the wallet address
+            // there are some addresses that are outside the scope of intended recipients that are not change addresses
+            throwTxMismatch('prebuild attempts to spend to unintended external recipients');
+        }
+    }
+    if (!txPrebuild.txHex) {
+        throw new Error(`txPrebuild.txHex not set`);
+    }
+    return true;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"verifyTransaction.js","sourceRoot":"","sources":["../../../../../src/transaction/fixedScript/verifyTransaction.ts"],"names":[],"mappings":"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","sourcesContent":["import buildDebug from 'debug';\nimport _ from 'lodash';\nimport BigNumber from 'bignumber.js';\nimport { BitGoBase, TxIntentMismatchError, IBaseCoin } from '@bitgo-beta/sdk-core';\nimport { hasPsbtMagic } from '@bitgo/wasm-utxo';\n\nimport { AbstractUtxoCoin, VerifyTransactionOptions } from '../../abstractUtxoCoin';\nimport { ParsedTransaction } from '../types';\nimport { stringToBufferTryFormats } from '../decode';\nimport { verifyCustomChangeKeySignatures, verifyKeySignature, verifyUserPublicKey } from '../../verifyKey';\n\nconst debug = buildDebug('bitgo:abstract-utxo:verifyTransaction');\n\n/**\n * Get the maximum percentage limit for pay-as-you-go outputs\n *\n * @protected\n */\nfunction getPayGoLimit(allowPaygoOutput?: boolean): number {\n  // allowing paygo outputs needs to be the default behavior, so only disallow paygo outputs if the\n  // relevant verification option is both set and false\n  if (!_.isNil(allowPaygoOutput) && !allowPaygoOutput) {\n    return 0;\n  }\n  // 150 basis points is the absolute permitted maximum if paygo outputs are allowed\n  return 0.015;\n}\n\n/**\n * Verify that a transaction prebuild complies with the original intention for fixed-script wallets\n *\n * This implementation handles transaction verification for traditional UTXO coins using fixed scripts\n * (non-descriptor wallets). It validates keychains, signatures, outputs, and amounts.\n *\n * @param coin - The UTXO coin instance\n * @param bitgo - BitGo API instance for network calls\n * @param params - Verification parameters\n * @param params.txParams - Transaction parameters passed to send\n * @param params.txPrebuild - Prebuild object returned by server\n * @param params.wallet - Wallet object to obtain keys to verify against\n * @param params.verification - Verification options (disableNetworking, keychains, addresses)\n * @param params.reqId - Optional request ID for logging\n * @returns {boolean} True if verification passes\n * @throws {TxIntentMismatchError} if transaction validation fails\n */\nexport async function verifyTransaction<TNumber extends bigint | number>(\n  coin: AbstractUtxoCoin,\n  bitgo: BitGoBase,\n  params: VerifyTransactionOptions<TNumber>\n): Promise<boolean> {\n  const { txParams, txPrebuild, wallet, verification = {}, reqId } = params;\n\n  const txExplanation = await TxIntentMismatchError.tryGetTxExplanation(coin as unknown as IBaseCoin, txPrebuild);\n\n  // Helper to throw TxIntentMismatchError with consistent context\n  const throwTxMismatch = (message: string): never => {\n    throw new TxIntentMismatchError(message, reqId, [txParams], txPrebuild.txHex, txExplanation);\n  };\n\n  if (!_.isUndefined(verification.disableNetworking) && !_.isBoolean(verification.disableNetworking)) {\n    throw new TypeError('verification.disableNetworking must be a boolean');\n  }\n  const isPsbt = txPrebuild.txHex && hasPsbtMagic(stringToBufferTryFormats(txPrebuild.txHex, ['hex', 'base64']));\n  if (isPsbt && txPrebuild.txInfo?.unspents) {\n    throw new Error('should not have unspents in txInfo for psbt');\n  }\n  const disableNetworking = !!verification.disableNetworking;\n  const isBridging = txParams.type === 'bridging';\n  const parsedTransaction: ParsedTransaction<TNumber> = await coin.parseTransaction<TNumber>({\n    txParams,\n    txPrebuild,\n    wallet,\n    verification,\n    reqId,\n  });\n\n  const keychains = parsedTransaction.keychains;\n\n  // verify that the claimed user public key corresponds to the wallet's user private key\n  let userPublicKeyVerified = false;\n  try {\n    // verify the user public key matches the private key - this will throw if there is no match\n    userPublicKeyVerified = await verifyUserPublicKey(bitgo, {\n      userKeychain: keychains.user,\n      disableNetworking,\n      txParams,\n    });\n  } catch (e) {\n    debug('failed to verify user public key!', e);\n  }\n\n  // let's verify these keychains\n  const keySignatures = parsedTransaction.keySignatures;\n  if (!_.isEmpty(keySignatures)) {\n    const verify = (key, pub) => {\n      if (!keychains.user || !keychains.user.pub) {\n        throwTxMismatch('missing user keychain');\n      }\n      return verifyKeySignature({\n        userKeychain: keychains.user as { pub: string },\n        keychainToVerify: key,\n        keySignature: pub,\n      });\n    };\n    const isBackupKeySignatureValid = verify(keychains.backup, keySignatures.backupPub);\n    const isBitgoKeySignatureValid = verify(keychains.bitgo, keySignatures.bitgoPub);\n    if (!isBackupKeySignatureValid || !isBitgoKeySignatureValid) {\n      throw new Error('secondary public key signatures invalid');\n    }\n    debug('successfully verified backup and bitgo key signatures');\n  } else if (!disableNetworking) {\n    // these keys were obtained online and their signatures were not verified\n    // this could be dangerous\n    console.log('unsigned keys obtained online are being used for address verification');\n  }\n\n  if (parsedTransaction.needsCustomChangeKeySignatureVerification) {\n    if (!keychains.user || !userPublicKeyVerified) {\n      throw new Error('transaction requires verification of user public key, but it was unable to be verified');\n    }\n    const customChangeKeySignaturesVerified = verifyCustomChangeKeySignatures(parsedTransaction, keychains.user);\n    if (!customChangeKeySignaturesVerified) {\n      throw new Error(\n        'transaction requires verification of custom change key signatures, but they were unable to be verified'\n      );\n    }\n    debug('successfully verified user public key and custom change key signatures');\n  }\n\n  if (txParams.qr) {\n    const allExternalOutputs = [\n      ...parsedTransaction.explicitExternalOutputs,\n      ...parsedTransaction.implicitExternalOutputs,\n    ];\n    if (allExternalOutputs.length > 0) {\n      throwTxMismatch('quantum-resistant sweep transactions must only contain wallet-internal outputs');\n    }\n    return true;\n  }\n\n  const missingOutputs = parsedTransaction.missingOutputs;\n  if (missingOutputs.length !== 0) {\n    // there are some outputs in the recipients list that have not made it into the actual transaction\n    throwTxMismatch('expected outputs missing in transaction prebuild');\n  }\n\n  const intendedExternalSpend = parsedTransaction.explicitExternalSpendAmount;\n\n  // this is a limit we impose for the total value that is amended to the transaction beyond what was originally intended\n  const payAsYouGoLimit = new BigNumber(getPayGoLimit(verification.allowPaygoOutput)).multipliedBy(\n    intendedExternalSpend.toString()\n  );\n\n  /*\n  Some explanation for why we're doing what we're doing:\n  Some customers will have an output to BitGo's PAYGo wallet added to their transaction, and we need to account for\n  it here. To protect someone tampering with the output to make it send more than it should to BitGo, we define a\n  threshold for the output's value above which we'll throw an error, because the paygo output should never be that\n  high.\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 nonChangeAmount = new BigNumber(parsedTransaction.implicitExternalSpendAmount.toString());\n\n  debug(\n    'Intended spend is %s, Non-change amount is %s, paygo limit is %s',\n    intendedExternalSpend.toString(),\n    nonChangeAmount.toString(),\n    payAsYouGoLimit.toString()\n  );\n\n  // There are two instances where we will get into this point here\n  if (nonChangeAmount.gt(payAsYouGoLimit)) {\n    if (isBridging) {\n      // The implicit external output is the bridge deposit address (see note above); it has no\n      // recipient to match against, so instead verify the total implicit external spend equals the\n      // intended bridge amount from bridgingParams.\n      const bridgeAmount = txParams.bridgingParams?.sbtc?.amount;\n      if (bridgeAmount === undefined) {\n        throwTxMismatch('bridging transaction is missing bridgingParams.sbtc.amount');\n      } else if (!nonChangeAmount.eq(bridgeAmount.toString())) {\n        throwTxMismatch(\n          `bridging output amount (${nonChangeAmount.toString()}) does not match intended bridge amount (${bridgeAmount})`\n        );\n      } else {\n        debug('verified bridging output amount matches bridgingParams.sbtc.amount');\n      }\n    } else if (isPsbt && parsedTransaction.customChange) {\n      // In the case that we have a custom change address on a wallet and we are building the transaction\n      // with a PSBT, we do not have the metadata to verify the address from the custom change wallet, nor\n      // can we fetch that information from the other wallet because we may not have the credentials. Therefore,\n      // we will not throw an error here, but we will log a warning.\n      debug(`cannot verify some of the addresses because it belongs to a separate wallet`);\n    } else {\n      // the additional external outputs can only be BitGo's pay-as-you-go fee, but we cannot verify the wallet address\n      // there are some addresses that are outside the scope of intended recipients that are not change addresses\n      throwTxMismatch('prebuild attempts to spend to unintended external recipients');\n    }\n  }\n\n  if (!txPrebuild.txHex) {\n    throw new Error(`txPrebuild.txHex not set`);\n  }\n\n  return true;\n}\n"]}

package/dist/cjs/src/transaction/getPayGoVerificationPubkey.d.ts

@@ -0,0 +1,9 @@
+import { UtxoCoinName } from '../names';
+/**
+ * We want to return the verification pubkey from our statics that has our
+ * verification pubkey.
+ * @param coinName
+ * @returns
+ */
+export declare function getPayGoVerificationPubkey(coinName: UtxoCoinName): string | undefined;
+//# sourceMappingURL=getPayGoVerificationPubkey.d.ts.map

package/dist/cjs/src/transaction/getPayGoVerificationPubkey.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"getPayGoVerificationPubkey.d.ts","sourceRoot":"","sources":["../../../../src/transaction/getPayGoVerificationPubkey.ts"],"names":[],"mappings":"AAAA,OAAO,EAAiB,YAAY,EAAE,MAAM,UAAU,CAAC;AAKvD;;;;;GAKG;AACH,wBAAgB,0BAA0B,CAAC,QAAQ,EAAE,YAAY,GAAG,MAAM,GAAG,SAAS,CAMrF"}