@bitgo-beta/abstract-utxo 1.1.1-beta.21 → 1.1.1-beta.2100

package/dist/cjs/test/unit/verifyTransaction.js

@@ -0,0 +1,536 @@
+"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 });
+const assert_1 = __importDefault(require("assert"));
+const sinon = __importStar(require("sinon"));
+const sdk_core_1 = require("@bitgo-beta/sdk-core");
+const util_1 = require("./util");
+describe('Verify Transaction', function () {
+    const coin = (0, util_1.getUtxoCoin)('tbtc');
+    const userKeychain = coin.keychains().create();
+    const otherKeychain = coin.keychains().create();
+    const changeKeys = {
+        user: coin.keychains().create(),
+        backup: coin.keychains().create(),
+        bitgo: coin.keychains().create(),
+    };
+    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+    const sign = async (key, keychain) => (await coin.signMessage(keychain, key.pub)).toString('hex');
+    const signUser = (key) => sign(key, userKeychain);
+    const signOther = (key) => sign(key, otherKeychain);
+    const passphrase = 'test_passphrase';
+    const stubData = {
+        unsignedSendingWallet: {
+            keyIds: sinon.stub().returns(['0', '1', '2']),
+        },
+        parseTransactionData: {
+            badKey: {
+                keychains: {
+                    // user public key swapped out
+                    user: {
+                        pub: otherKeychain.pub,
+                        encryptedPrv: util_1.defaultBitGo.encrypt({
+                            input: userKeychain.prv,
+                            password: passphrase,
+                        }),
+                    },
+                },
+                needsCustomChangeKeySignatureVerification: true,
+            },
+            noCustomChange: {
+                keychains: { user: userKeychain },
+                needsCustomChangeKeySignatureVerification: true,
+            },
+            emptyCustomChange: {
+                keychains: { user: userKeychain },
+                needsCustomChangeKeySignatureVerification: true,
+                customChange: {},
+            },
+            // needs to be async function to create signatures
+            badSigs: async () => ({
+                keychains: { user: userKeychain },
+                needsCustomChangeKeySignatureVerification: true,
+                customChange: {
+                    keys: [changeKeys.user, changeKeys.backup, changeKeys.bitgo],
+                    signatures: [
+                        await signOther(changeKeys.user),
+                        await signOther(changeKeys.backup),
+                        await signOther(changeKeys.bitgo),
+                    ],
+                },
+            }),
+            goodSigs: async () => ({
+                keychains: { user: userKeychain },
+                needsCustomChangeKeySignatureVerification: true,
+                customChange: {
+                    keys: [changeKeys.user, changeKeys.backup, changeKeys.bitgo],
+                    signatures: [
+                        await signUser(changeKeys.user),
+                        await signUser(changeKeys.backup),
+                        await signUser(changeKeys.bitgo),
+                    ],
+                },
+                missingOutputs: 1,
+            }),
+        },
+    };
+    const unsignedSendingWallet = sinon.createStubInstance(sdk_core_1.Wallet, stubData.unsignedSendingWallet);
+    it('should fail if the user private key cannot be verified to match the user public key', async () => {
+        sinon.stub(coin, 'parseTransaction').resolves(stubData.parseTransactionData.badKey);
+        const verifyWallet = sinon.createStubInstance(sdk_core_1.Wallet, {});
+        await assert_1.default.rejects(coin.verifyTransaction({
+            txParams: {
+                walletPassphrase: passphrase,
+            },
+            txPrebuild: {},
+            wallet: verifyWallet,
+            verification: {},
+        }), /transaction requires verification of user public key, but it was unable to be verified/);
+        coin.parseTransaction.restore();
+    });
+    it('should fail if the custom change verification data is required but missing', async () => {
+        sinon.stub(coin, 'parseTransaction').resolves(stubData.parseTransactionData.noCustomChange);
+        await assert_1.default.rejects(coin.verifyTransaction({
+            txParams: {
+                walletPassphrase: passphrase,
+            },
+            txPrebuild: {},
+            wallet: unsignedSendingWallet,
+            verification: {},
+        }), /parsed transaction is missing required custom change verification data/);
+        coin.parseTransaction.restore();
+    });
+    it('should fail if the custom change keys or key signatures are missing', async () => {
+        sinon.stub(coin, 'parseTransaction').resolves(stubData.parseTransactionData.emptyCustomChange);
+        await assert_1.default.rejects(coin.verifyTransaction({
+            txParams: {
+                walletPassphrase: passphrase,
+            },
+            txPrebuild: {},
+            wallet: unsignedSendingWallet,
+            verification: {},
+        }), /customChange property is missing keys or signatures/);
+        coin.parseTransaction.restore();
+    });
+    it('should fail if the custom change key signatures cannot be verified', async () => {
+        sinon.stub(coin, 'parseTransaction').resolves((await stubData.parseTransactionData.badSigs()));
+        await assert_1.default.rejects(coin.verifyTransaction({
+            txParams: {
+                walletPassphrase: passphrase,
+            },
+            txPrebuild: {},
+            wallet: unsignedSendingWallet,
+            verification: {},
+        }), /transaction requires verification of custom change key signatures, but they were unable to be verified/);
+        coin.parseTransaction.restore();
+    });
+    it('should successfully verify a custom change transaction when change keys and signatures are valid', async () => {
+        sinon.stub(coin, 'parseTransaction').resolves((await stubData.parseTransactionData.goodSigs()));
+        // if verify transaction gets rejected with the outputs missing error message,
+        // then we know that the verification of the custom change key signatures was successful
+        await assert_1.default.rejects(coin.verifyTransaction({
+            txParams: {
+                walletPassphrase: passphrase,
+            },
+            txPrebuild: {},
+            wallet: unsignedSendingWallet,
+            verification: {},
+        }), /expected outputs missing in transaction prebuild/);
+        coin.parseTransaction.restore();
+    });
+    it('should not allow more than 150 basis points of implicit external outputs (for paygo outputs)', async () => {
+        const coinMock = sinon.stub(coin, 'parseTransaction').resolves({
+            keychains: {},
+            keySignatures: {},
+            outputs: [],
+            missingOutputs: [],
+            explicitExternalOutputs: [],
+            implicitExternalOutputs: [],
+            changeOutputs: [],
+            explicitExternalSpendAmount: 10000,
+            implicitExternalSpendAmount: 151,
+            needsCustomChangeKeySignatureVerification: false,
+        });
+        await assert_1.default.rejects(coin.verifyTransaction({
+            txParams: {
+                walletPassphrase: passphrase,
+            },
+            txPrebuild: {},
+            wallet: unsignedSendingWallet,
+        }), /prebuild attempts to spend to unintended external recipients/);
+        coinMock.restore();
+    });
+    it('should allow 150 basis points of implicit external outputs (for paygo outputs)', async () => {
+        const coinMock = sinon.stub(coin, 'parseTransaction').resolves({
+            keychains: {},
+            keySignatures: {},
+            outputs: [],
+            missingOutputs: [],
+            explicitExternalOutputs: [],
+            implicitExternalOutputs: [],
+            changeOutputs: [],
+            explicitExternalSpendAmount: 1000,
+            implicitExternalSpendAmount: 15,
+            needsCustomChangeKeySignatureVerification: false,
+        });
+        const result = await coin.verifyTransaction({
+            txParams: {
+                walletPassphrase: passphrase,
+            },
+            txPrebuild: {
+                txHex: '00',
+            },
+            wallet: unsignedSendingWallet,
+        });
+        assert_1.default.strictEqual(result, true);
+        coinMock.restore();
+    });
+    it('should not allow any implicit external outputs if paygo outputs are disallowed', async () => {
+        const coinMock = sinon.stub(coin, 'parseTransaction').resolves({
+            keychains: {},
+            keySignatures: {},
+            outputs: [],
+            missingOutputs: [],
+            explicitExternalOutputs: [],
+            implicitExternalOutputs: [],
+            changeOutputs: [],
+            explicitExternalSpendAmount: 0,
+            implicitExternalSpendAmount: 10,
+            needsCustomChangeKeySignatureVerification: false,
+        });
+        await assert_1.default.rejects(coin.verifyTransaction({
+            txParams: {
+                walletPassphrase: passphrase,
+            },
+            txPrebuild: {
+                txHex: '00',
+            },
+            wallet: unsignedSendingWallet,
+            verification: {
+                allowPaygoOutput: false,
+            },
+        }), /prebuild attempts to spend to unintended external recipients/);
+        coinMock.restore();
+    });
+    it('should allow paygo outputs if empty verification object is passed', async () => {
+        const coinMock = sinon.stub(coin, 'parseTransaction').resolves({
+            keychains: {},
+            keySignatures: {},
+            outputs: [],
+            missingOutputs: [],
+            explicitExternalOutputs: [],
+            implicitExternalOutputs: [],
+            changeOutputs: [],
+            explicitExternalSpendAmount: 1000,
+            implicitExternalSpendAmount: 15,
+            needsCustomChangeKeySignatureVerification: false,
+        });
+        const result = await coin.verifyTransaction({
+            txParams: {
+                walletPassphrase: passphrase,
+            },
+            txPrebuild: {
+                txHex: '00',
+            },
+            wallet: unsignedSendingWallet,
+            verification: {},
+        });
+        assert_1.default.strictEqual(result, true);
+        coinMock.restore();
+    });
+    it('should verify a bridging transaction whose implicit external output matches the bridge amount', async () => {
+        // Bridging intents (e.g. BTC -> sBTC peg-in) carry no recipients; the single external output
+        // is the bridge deposit address computed server-side. With explicitExternalSpendAmount 0 the
+        // paygo limit is 0, so any implicit external output would normally be rejected as an
+        // "unintended external recipient". For type: 'bridging' we instead verify that the implicit
+        // external spend equals bridgingParams.sbtc.amount.
+        const coinMock = sinon.stub(coin, 'parseTransaction').resolves({
+            keychains: {},
+            keySignatures: {},
+            outputs: [],
+            missingOutputs: [],
+            explicitExternalOutputs: [],
+            implicitExternalOutputs: [
+                {
+                    address: 'sbtc_deposit_address',
+                    amount: '22000',
+                },
+            ],
+            changeOutputs: [],
+            explicitExternalSpendAmount: 0,
+            implicitExternalSpendAmount: 22000,
+            needsCustomChangeKeySignatureVerification: false,
+        });
+        const result = await coin.verifyTransaction({
+            txParams: {
+                walletPassphrase: passphrase,
+                type: 'bridging',
+                bridgingParams: { sbtc: { amount: '22000', stacksRecipient: 'SM1X', maxFee: '1000', lockTime: 100 } },
+            },
+            txPrebuild: {
+                txHex: '00',
+            },
+            wallet: unsignedSendingWallet,
+            verification: {},
+        });
+        assert_1.default.strictEqual(result, true);
+        coinMock.restore();
+    });
+    it('should reject a bridging transaction whose implicit external output does not match the bridge amount', async () => {
+        const coinMock = sinon.stub(coin, 'parseTransaction').resolves({
+            keychains: {},
+            keySignatures: {},
+            outputs: [],
+            missingOutputs: [],
+            explicitExternalOutputs: [],
+            implicitExternalOutputs: [
+                {
+                    address: 'sbtc_deposit_address',
+                    amount: '50000',
+                },
+            ],
+            changeOutputs: [],
+            explicitExternalSpendAmount: 0,
+            implicitExternalSpendAmount: 50000,
+            needsCustomChangeKeySignatureVerification: false,
+        });
+        await assert_1.default.rejects(coin.verifyTransaction({
+            txParams: {
+                walletPassphrase: passphrase,
+                type: 'bridging',
+                bridgingParams: { sbtc: { amount: '22000', stacksRecipient: 'SM1X', maxFee: '1000', lockTime: 100 } },
+            },
+            txPrebuild: {
+                txHex: '00',
+            },
+            wallet: unsignedSendingWallet,
+            verification: {},
+        }), /bridging output amount \(50000\) does not match intended bridge amount \(22000\)/);
+        coinMock.restore();
+    });
+    it('should reject a bridging transaction that is missing bridgingParams.sbtc.amount', async () => {
+        const coinMock = sinon.stub(coin, 'parseTransaction').resolves({
+            keychains: {},
+            keySignatures: {},
+            outputs: [],
+            missingOutputs: [],
+            explicitExternalOutputs: [],
+            implicitExternalOutputs: [
+                {
+                    address: 'sbtc_deposit_address',
+                    amount: '22000',
+                },
+            ],
+            changeOutputs: [],
+            explicitExternalSpendAmount: 0,
+            implicitExternalSpendAmount: 22000,
+            needsCustomChangeKeySignatureVerification: false,
+        });
+        await assert_1.default.rejects(coin.verifyTransaction({
+            txParams: {
+                walletPassphrase: passphrase,
+                type: 'bridging',
+            },
+            txPrebuild: {
+                txHex: '00',
+            },
+            wallet: unsignedSendingWallet,
+            verification: {},
+        }), /bridging transaction is missing bridgingParams.sbtc.amount/);
+        coinMock.restore();
+    });
+    it('should still reject the same implicit external output when the intent is not bridging', async () => {
+        // Same shape as the bridging test above, but without type: 'bridging' the implicit external
+        // output is treated as an unintended external recipient and rejected.
+        const coinMock = sinon.stub(coin, 'parseTransaction').resolves({
+            keychains: {},
+            keySignatures: {},
+            outputs: [],
+            missingOutputs: [],
+            explicitExternalOutputs: [],
+            implicitExternalOutputs: [
+                {
+                    address: 'sbtc_deposit_address',
+                    amount: '22000',
+                },
+            ],
+            changeOutputs: [],
+            explicitExternalSpendAmount: 0,
+            implicitExternalSpendAmount: 22000,
+            needsCustomChangeKeySignatureVerification: false,
+        });
+        await assert_1.default.rejects(coin.verifyTransaction({
+            txParams: {
+                walletPassphrase: passphrase,
+            },
+            txPrebuild: {
+                txHex: '00',
+            },
+            wallet: unsignedSendingWallet,
+            verification: {},
+        }), /prebuild attempts to spend to unintended external recipients/);
+        coinMock.restore();
+    });
+    describe('quantum-resistant sweep (qr: true)', function () {
+        it('should reject when explicit external outputs are present', async () => {
+            const coinMock = sinon.stub(coin, 'parseTransaction').resolves({
+                keychains: {},
+                keySignatures: {},
+                outputs: [],
+                missingOutputs: [],
+                explicitExternalOutputs: [{ address: 'external_addr', amount: '5000' }],
+                implicitExternalOutputs: [],
+                changeOutputs: [{ address: 'change_addr', amount: '4000' }],
+                explicitExternalSpendAmount: 5000,
+                implicitExternalSpendAmount: 0,
+                needsCustomChangeKeySignatureVerification: false,
+            });
+            await assert_1.default.rejects(coin.verifyTransaction({
+                txParams: { walletPassphrase: passphrase, qr: true },
+                txPrebuild: {},
+                wallet: unsignedSendingWallet,
+                verification: {},
+            }), /quantum-resistant sweep transactions must only contain wallet-internal outputs/);
+            coinMock.restore();
+        });
+        it('should reject when implicit external outputs are present', async () => {
+            const coinMock = sinon.stub(coin, 'parseTransaction').resolves({
+                keychains: {},
+                keySignatures: {},
+                outputs: [],
+                missingOutputs: [],
+                explicitExternalOutputs: [],
+                implicitExternalOutputs: [{ address: 'paygo_addr', amount: '100' }],
+                changeOutputs: [{ address: 'change_addr', amount: '9900' }],
+                explicitExternalSpendAmount: 0,
+                implicitExternalSpendAmount: 100,
+                needsCustomChangeKeySignatureVerification: false,
+            });
+            await assert_1.default.rejects(coin.verifyTransaction({
+                txParams: { walletPassphrase: passphrase, qr: true },
+                txPrebuild: {},
+                wallet: unsignedSendingWallet,
+                verification: {},
+            }), /quantum-resistant sweep transactions must only contain wallet-internal outputs/);
+            coinMock.restore();
+        });
+        it('should pass when all outputs are internal (change only)', async () => {
+            const coinMock = sinon.stub(coin, 'parseTransaction').resolves({
+                keychains: {},
+                keySignatures: {},
+                outputs: [{ address: 'change_addr', amount: '10000' }],
+                missingOutputs: [],
+                explicitExternalOutputs: [],
+                implicitExternalOutputs: [],
+                changeOutputs: [{ address: 'change_addr', amount: '10000' }],
+                explicitExternalSpendAmount: 0,
+                implicitExternalSpendAmount: 0,
+                needsCustomChangeKeySignatureVerification: false,
+            });
+            const result = await coin.verifyTransaction({
+                txParams: { walletPassphrase: passphrase, qr: true },
+                txPrebuild: {},
+                wallet: unsignedSendingWallet,
+                verification: {},
+            });
+            assert_1.default.strictEqual(result, true);
+            coinMock.restore();
+        });
+        it('should not apply qr check when qr is not set', async () => {
+            const coinMock = sinon.stub(coin, 'parseTransaction').resolves({
+                keychains: {},
+                keySignatures: {},
+                outputs: [],
+                missingOutputs: [],
+                explicitExternalOutputs: [{ address: 'external_addr', amount: '5000' }],
+                implicitExternalOutputs: [],
+                changeOutputs: [],
+                explicitExternalSpendAmount: 5000,
+                implicitExternalSpendAmount: 0,
+                needsCustomChangeKeySignatureVerification: false,
+            });
+            const result = await coin.verifyTransaction({
+                txParams: { walletPassphrase: passphrase },
+                txPrebuild: { txHex: '00' },
+                wallet: unsignedSendingWallet,
+                verification: {},
+            });
+            assert_1.default.strictEqual(result, true);
+            coinMock.restore();
+        });
+    });
+    it('should work with bigint amounts', async () => {
+        // need a coin that uses bigint
+        const bigintCoin = (0, util_1.getUtxoCoin)('tdoge');
+        const coinMock = sinon.stub(bigintCoin, 'parseTransaction').resolves({
+            keychains: {},
+            keySignatures: {},
+            outputs: [],
+            missingOutputs: [],
+            explicitExternalOutputs: [
+                {
+                    address: 'external_address',
+                    amount: '10000',
+                },
+            ],
+            implicitExternalOutputs: [
+                {
+                    address: 'external_address_2',
+                    amount: '15',
+                },
+            ],
+            changeOutputs: [],
+            explicitExternalSpendAmount: BigInt(10000),
+            implicitExternalSpendAmount: BigInt(15),
+            needsCustomChangeKeySignatureVerification: false,
+        });
+        const result = await bigintCoin.verifyTransaction({
+            txParams: {
+                walletPassphrase: passphrase,
+            },
+            txPrebuild: {
+                txHex: '00',
+            },
+            wallet: unsignedSendingWallet,
+            verification: {},
+        });
+        assert_1.default.strictEqual(result, true);
+        coinMock.restore();
+    });
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"verifyTransaction.js","sourceRoot":"","sources":["../../../../test/unit/verifyTransaction.ts"],"names":[],"mappings":"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","sourcesContent":["import assert from 'assert';\n\nimport * as sinon from 'sinon';\nimport { Wallet } from '@bitgo-beta/sdk-core';\n\nimport { defaultBitGo, getUtxoCoin } from './util';\n\ndescribe('Verify Transaction', function () {\n  const coin = getUtxoCoin('tbtc');\n\n  const userKeychain = coin.keychains().create();\n  const otherKeychain = coin.keychains().create();\n\n  const changeKeys = {\n    user: coin.keychains().create(),\n    backup: coin.keychains().create(),\n    bitgo: coin.keychains().create(),\n  };\n\n  // eslint-disable-next-line @typescript-eslint/no-non-null-assertion\n  const sign = async (key, keychain) => (await coin.signMessage(keychain, key.pub!)).toString('hex');\n  const signUser = (key) => sign(key, userKeychain);\n  const signOther = (key) => sign(key, otherKeychain);\n  const passphrase = 'test_passphrase';\n\n  const stubData = {\n    unsignedSendingWallet: {\n      keyIds: sinon.stub().returns(['0', '1', '2']),\n    },\n    parseTransactionData: {\n      badKey: {\n        keychains: {\n          // user public key swapped out\n          user: {\n            pub: otherKeychain.pub,\n            encryptedPrv: defaultBitGo.encrypt({\n              input: userKeychain.prv,\n              password: passphrase,\n            }),\n          },\n        },\n        needsCustomChangeKeySignatureVerification: true,\n      },\n      noCustomChange: {\n        keychains: { user: userKeychain },\n        needsCustomChangeKeySignatureVerification: true,\n      },\n      emptyCustomChange: {\n        keychains: { user: userKeychain },\n        needsCustomChangeKeySignatureVerification: true,\n        customChange: {},\n      },\n      // needs to be async function to create signatures\n      badSigs: async () => ({\n        keychains: { user: userKeychain },\n        needsCustomChangeKeySignatureVerification: true,\n        customChange: {\n          keys: [changeKeys.user, changeKeys.backup, changeKeys.bitgo],\n          signatures: [\n            await signOther(changeKeys.user),\n            await signOther(changeKeys.backup),\n            await signOther(changeKeys.bitgo),\n          ],\n        },\n      }),\n      goodSigs: async () => ({\n        keychains: { user: userKeychain },\n        needsCustomChangeKeySignatureVerification: true,\n        customChange: {\n          keys: [changeKeys.user, changeKeys.backup, changeKeys.bitgo],\n          signatures: [\n            await signUser(changeKeys.user),\n            await signUser(changeKeys.backup),\n            await signUser(changeKeys.bitgo),\n          ],\n        },\n        missingOutputs: 1,\n      }),\n    },\n  };\n\n  const unsignedSendingWallet = sinon.createStubInstance(Wallet, stubData.unsignedSendingWallet as any);\n\n  it('should fail if the user private key cannot be verified to match the user public key', async () => {\n    sinon.stub(coin, 'parseTransaction').resolves(stubData.parseTransactionData.badKey as any);\n    const verifyWallet = sinon.createStubInstance(Wallet, {});\n\n    await assert.rejects(\n      coin.verifyTransaction({\n        txParams: {\n          walletPassphrase: passphrase,\n        },\n        txPrebuild: {},\n        wallet: verifyWallet as any,\n        verification: {},\n      }),\n      /transaction requires verification of user public key, but it was unable to be verified/\n    );\n\n    (coin.parseTransaction as any).restore();\n  });\n\n  it('should fail if the custom change verification data is required but missing', async () => {\n    sinon.stub(coin, 'parseTransaction').resolves(stubData.parseTransactionData.noCustomChange as any);\n\n    await assert.rejects(\n      coin.verifyTransaction({\n        txParams: {\n          walletPassphrase: passphrase,\n        },\n        txPrebuild: {},\n        wallet: unsignedSendingWallet as any,\n        verification: {},\n      }),\n      /parsed transaction is missing required custom change verification data/\n    );\n\n    (coin.parseTransaction as any).restore();\n  });\n\n  it('should fail if the custom change keys or key signatures are missing', async () => {\n    sinon.stub(coin, 'parseTransaction').resolves(stubData.parseTransactionData.emptyCustomChange as any);\n\n    await assert.rejects(\n      coin.verifyTransaction({\n        txParams: {\n          walletPassphrase: passphrase,\n        },\n        txPrebuild: {},\n        wallet: unsignedSendingWallet as any,\n        verification: {},\n      }),\n      /customChange property is missing keys or signatures/\n    );\n\n    (coin.parseTransaction as any).restore();\n  });\n\n  it('should fail if the custom change key signatures cannot be verified', async () => {\n    sinon.stub(coin, 'parseTransaction').resolves((await stubData.parseTransactionData.badSigs()) as any);\n\n    await assert.rejects(\n      coin.verifyTransaction({\n        txParams: {\n          walletPassphrase: passphrase,\n        },\n        txPrebuild: {},\n        wallet: unsignedSendingWallet as any,\n        verification: {},\n      }),\n      /transaction requires verification of custom change key signatures, but they were unable to be verified/\n    );\n\n    (coin.parseTransaction as any).restore();\n  });\n\n  it('should successfully verify a custom change transaction when change keys and signatures are valid', async () => {\n    sinon.stub(coin, 'parseTransaction').resolves((await stubData.parseTransactionData.goodSigs()) as any);\n\n    // if verify transaction gets rejected with the outputs missing error message,\n    // then we know that the verification of the custom change key signatures was successful\n    await assert.rejects(\n      coin.verifyTransaction({\n        txParams: {\n          walletPassphrase: passphrase,\n        },\n        txPrebuild: {},\n        wallet: unsignedSendingWallet as any,\n        verification: {},\n      }),\n      /expected outputs missing in transaction prebuild/\n    );\n\n    (coin.parseTransaction as any).restore();\n  });\n\n  it('should not allow more than 150 basis points of implicit external outputs (for paygo outputs)', async () => {\n    const coinMock = sinon.stub(coin, 'parseTransaction').resolves({\n      keychains: {} as any,\n      keySignatures: {},\n      outputs: [],\n      missingOutputs: [],\n      explicitExternalOutputs: [],\n      implicitExternalOutputs: [],\n      changeOutputs: [],\n      explicitExternalSpendAmount: 10000,\n      implicitExternalSpendAmount: 151,\n      needsCustomChangeKeySignatureVerification: false,\n    });\n\n    await assert.rejects(\n      coin.verifyTransaction({\n        txParams: {\n          walletPassphrase: passphrase,\n        },\n        txPrebuild: {},\n        wallet: unsignedSendingWallet as any,\n      }),\n      /prebuild attempts to spend to unintended external recipients/\n    );\n\n    coinMock.restore();\n  });\n\n  it('should allow 150 basis points of implicit external outputs (for paygo outputs)', async () => {\n    const coinMock = sinon.stub(coin, 'parseTransaction').resolves({\n      keychains: {} as any,\n      keySignatures: {},\n      outputs: [],\n      missingOutputs: [],\n      explicitExternalOutputs: [],\n      implicitExternalOutputs: [],\n      changeOutputs: [],\n      explicitExternalSpendAmount: 1000,\n      implicitExternalSpendAmount: 15,\n      needsCustomChangeKeySignatureVerification: false,\n    });\n\n    const result = await coin.verifyTransaction({\n      txParams: {\n        walletPassphrase: passphrase,\n      },\n      txPrebuild: {\n        txHex: '00',\n      },\n      wallet: unsignedSendingWallet as any,\n    });\n\n    assert.strictEqual(result, true);\n\n    coinMock.restore();\n  });\n\n  it('should not allow any implicit external outputs if paygo outputs are disallowed', async () => {\n    const coinMock = sinon.stub(coin, 'parseTransaction').resolves({\n      keychains: {} as any,\n      keySignatures: {},\n      outputs: [],\n      missingOutputs: [],\n      explicitExternalOutputs: [],\n      implicitExternalOutputs: [],\n      changeOutputs: [],\n      explicitExternalSpendAmount: 0,\n      implicitExternalSpendAmount: 10,\n      needsCustomChangeKeySignatureVerification: false,\n    });\n\n    await assert.rejects(\n      coin.verifyTransaction({\n        txParams: {\n          walletPassphrase: passphrase,\n        },\n        txPrebuild: {\n          txHex: '00',\n        },\n        wallet: unsignedSendingWallet as any,\n        verification: {\n          allowPaygoOutput: false,\n        },\n      }),\n      /prebuild attempts to spend to unintended external recipients/\n    );\n\n    coinMock.restore();\n  });\n\n  it('should allow paygo outputs if empty verification object is passed', async () => {\n    const coinMock = sinon.stub(coin, 'parseTransaction').resolves({\n      keychains: {} as any,\n      keySignatures: {},\n      outputs: [],\n      missingOutputs: [],\n      explicitExternalOutputs: [],\n      implicitExternalOutputs: [],\n      changeOutputs: [],\n      explicitExternalSpendAmount: 1000,\n      implicitExternalSpendAmount: 15,\n      needsCustomChangeKeySignatureVerification: false,\n    });\n\n    const result = await coin.verifyTransaction({\n      txParams: {\n        walletPassphrase: passphrase,\n      },\n      txPrebuild: {\n        txHex: '00',\n      },\n      wallet: unsignedSendingWallet as any,\n      verification: {},\n    });\n\n    assert.strictEqual(result, true);\n\n    coinMock.restore();\n  });\n\n  it('should verify a bridging transaction whose implicit external output matches the bridge amount', async () => {\n    // Bridging intents (e.g. BTC -> sBTC peg-in) carry no recipients; the single external output\n    // is the bridge deposit address computed server-side. With explicitExternalSpendAmount 0 the\n    // paygo limit is 0, so any implicit external output would normally be rejected as an\n    // \"unintended external recipient\". For type: 'bridging' we instead verify that the implicit\n    // external spend equals bridgingParams.sbtc.amount.\n    const coinMock = sinon.stub(coin, 'parseTransaction').resolves({\n      keychains: {} as any,\n      keySignatures: {},\n      outputs: [],\n      missingOutputs: [],\n      explicitExternalOutputs: [],\n      implicitExternalOutputs: [\n        {\n          address: 'sbtc_deposit_address',\n          amount: '22000',\n        },\n      ],\n      changeOutputs: [],\n      explicitExternalSpendAmount: 0,\n      implicitExternalSpendAmount: 22000,\n      needsCustomChangeKeySignatureVerification: false,\n    });\n\n    const result = await coin.verifyTransaction({\n      txParams: {\n        walletPassphrase: passphrase,\n        type: 'bridging',\n        bridgingParams: { sbtc: { amount: '22000', stacksRecipient: 'SM1X', maxFee: '1000', lockTime: 100 } },\n      },\n      txPrebuild: {\n        txHex: '00',\n      },\n      wallet: unsignedSendingWallet as any,\n      verification: {},\n    });\n\n    assert.strictEqual(result, true);\n\n    coinMock.restore();\n  });\n\n  it('should reject a bridging transaction whose implicit external output does not match the bridge amount', async () => {\n    const coinMock = sinon.stub(coin, 'parseTransaction').resolves({\n      keychains: {} as any,\n      keySignatures: {},\n      outputs: [],\n      missingOutputs: [],\n      explicitExternalOutputs: [],\n      implicitExternalOutputs: [\n        {\n          address: 'sbtc_deposit_address',\n          amount: '50000',\n        },\n      ],\n      changeOutputs: [],\n      explicitExternalSpendAmount: 0,\n      implicitExternalSpendAmount: 50000,\n      needsCustomChangeKeySignatureVerification: false,\n    });\n\n    await assert.rejects(\n      coin.verifyTransaction({\n        txParams: {\n          walletPassphrase: passphrase,\n          type: 'bridging',\n          bridgingParams: { sbtc: { amount: '22000', stacksRecipient: 'SM1X', maxFee: '1000', lockTime: 100 } },\n        },\n        txPrebuild: {\n          txHex: '00',\n        },\n        wallet: unsignedSendingWallet as any,\n        verification: {},\n      }),\n      /bridging output amount \\(50000\\) does not match intended bridge amount \\(22000\\)/\n    );\n\n    coinMock.restore();\n  });\n\n  it('should reject a bridging transaction that is missing bridgingParams.sbtc.amount', async () => {\n    const coinMock = sinon.stub(coin, 'parseTransaction').resolves({\n      keychains: {} as any,\n      keySignatures: {},\n      outputs: [],\n      missingOutputs: [],\n      explicitExternalOutputs: [],\n      implicitExternalOutputs: [\n        {\n          address: 'sbtc_deposit_address',\n          amount: '22000',\n        },\n      ],\n      changeOutputs: [],\n      explicitExternalSpendAmount: 0,\n      implicitExternalSpendAmount: 22000,\n      needsCustomChangeKeySignatureVerification: false,\n    });\n\n    await assert.rejects(\n      coin.verifyTransaction({\n        txParams: {\n          walletPassphrase: passphrase,\n          type: 'bridging',\n        },\n        txPrebuild: {\n          txHex: '00',\n        },\n        wallet: unsignedSendingWallet as any,\n        verification: {},\n      }),\n      /bridging transaction is missing bridgingParams.sbtc.amount/\n    );\n\n    coinMock.restore();\n  });\n\n  it('should still reject the same implicit external output when the intent is not bridging', async () => {\n    // Same shape as the bridging test above, but without type: 'bridging' the implicit external\n    // output is treated as an unintended external recipient and rejected.\n    const coinMock = sinon.stub(coin, 'parseTransaction').resolves({\n      keychains: {} as any,\n      keySignatures: {},\n      outputs: [],\n      missingOutputs: [],\n      explicitExternalOutputs: [],\n      implicitExternalOutputs: [\n        {\n          address: 'sbtc_deposit_address',\n          amount: '22000',\n        },\n      ],\n      changeOutputs: [],\n      explicitExternalSpendAmount: 0,\n      implicitExternalSpendAmount: 22000,\n      needsCustomChangeKeySignatureVerification: false,\n    });\n\n    await assert.rejects(\n      coin.verifyTransaction({\n        txParams: {\n          walletPassphrase: passphrase,\n        },\n        txPrebuild: {\n          txHex: '00',\n        },\n        wallet: unsignedSendingWallet as any,\n        verification: {},\n      }),\n      /prebuild attempts to spend to unintended external recipients/\n    );\n\n    coinMock.restore();\n  });\n\n  describe('quantum-resistant sweep (qr: true)', function () {\n    it('should reject when explicit external outputs are present', async () => {\n      const coinMock = sinon.stub(coin, 'parseTransaction').resolves({\n        keychains: {} as any,\n        keySignatures: {},\n        outputs: [],\n        missingOutputs: [],\n        explicitExternalOutputs: [{ address: 'external_addr', amount: '5000' }],\n        implicitExternalOutputs: [],\n        changeOutputs: [{ address: 'change_addr', amount: '4000' }],\n        explicitExternalSpendAmount: 5000,\n        implicitExternalSpendAmount: 0,\n        needsCustomChangeKeySignatureVerification: false,\n      });\n\n      await assert.rejects(\n        coin.verifyTransaction({\n          txParams: { walletPassphrase: passphrase, qr: true },\n          txPrebuild: {},\n          wallet: unsignedSendingWallet as any,\n          verification: {},\n        }),\n        /quantum-resistant sweep transactions must only contain wallet-internal outputs/\n      );\n\n      coinMock.restore();\n    });\n\n    it('should reject when implicit external outputs are present', async () => {\n      const coinMock = sinon.stub(coin, 'parseTransaction').resolves({\n        keychains: {} as any,\n        keySignatures: {},\n        outputs: [],\n        missingOutputs: [],\n        explicitExternalOutputs: [],\n        implicitExternalOutputs: [{ address: 'paygo_addr', amount: '100' }],\n        changeOutputs: [{ address: 'change_addr', amount: '9900' }],\n        explicitExternalSpendAmount: 0,\n        implicitExternalSpendAmount: 100,\n        needsCustomChangeKeySignatureVerification: false,\n      });\n\n      await assert.rejects(\n        coin.verifyTransaction({\n          txParams: { walletPassphrase: passphrase, qr: true },\n          txPrebuild: {},\n          wallet: unsignedSendingWallet as any,\n          verification: {},\n        }),\n        /quantum-resistant sweep transactions must only contain wallet-internal outputs/\n      );\n\n      coinMock.restore();\n    });\n\n    it('should pass when all outputs are internal (change only)', async () => {\n      const coinMock = sinon.stub(coin, 'parseTransaction').resolves({\n        keychains: {} as any,\n        keySignatures: {},\n        outputs: [{ address: 'change_addr', amount: '10000' }],\n        missingOutputs: [],\n        explicitExternalOutputs: [],\n        implicitExternalOutputs: [],\n        changeOutputs: [{ address: 'change_addr', amount: '10000' }],\n        explicitExternalSpendAmount: 0,\n        implicitExternalSpendAmount: 0,\n        needsCustomChangeKeySignatureVerification: false,\n      });\n\n      const result = await coin.verifyTransaction({\n        txParams: { walletPassphrase: passphrase, qr: true },\n        txPrebuild: {},\n        wallet: unsignedSendingWallet as any,\n        verification: {},\n      });\n\n      assert.strictEqual(result, true);\n\n      coinMock.restore();\n    });\n\n    it('should not apply qr check when qr is not set', async () => {\n      const coinMock = sinon.stub(coin, 'parseTransaction').resolves({\n        keychains: {} as any,\n        keySignatures: {},\n        outputs: [],\n        missingOutputs: [],\n        explicitExternalOutputs: [{ address: 'external_addr', amount: '5000' }],\n        implicitExternalOutputs: [],\n        changeOutputs: [],\n        explicitExternalSpendAmount: 5000,\n        implicitExternalSpendAmount: 0,\n        needsCustomChangeKeySignatureVerification: false,\n      });\n\n      const result = await coin.verifyTransaction({\n        txParams: { walletPassphrase: passphrase },\n        txPrebuild: { txHex: '00' },\n        wallet: unsignedSendingWallet as any,\n        verification: {},\n      });\n\n      assert.strictEqual(result, true);\n\n      coinMock.restore();\n    });\n  });\n\n  it('should work with bigint amounts', async () => {\n    // need a coin that uses bigint\n    const bigintCoin = getUtxoCoin('tdoge');\n\n    const coinMock = sinon.stub(bigintCoin, 'parseTransaction').resolves({\n      keychains: {} as any,\n      keySignatures: {},\n      outputs: [],\n      missingOutputs: [],\n      explicitExternalOutputs: [\n        {\n          address: 'external_address',\n          amount: '10000',\n        },\n      ],\n      implicitExternalOutputs: [\n        {\n          address: 'external_address_2',\n          amount: '15',\n        },\n      ],\n      changeOutputs: [],\n      explicitExternalSpendAmount: BigInt(10000),\n      implicitExternalSpendAmount: BigInt(15),\n      needsCustomChangeKeySignatureVerification: false,\n    });\n\n    const result = await bigintCoin.verifyTransaction({\n      txParams: {\n        walletPassphrase: passphrase,\n      },\n      txPrebuild: {\n        txHex: '00',\n      },\n      wallet: unsignedSendingWallet as any,\n      verification: {},\n    });\n\n    assert.strictEqual(result, true);\n\n    coinMock.restore();\n  });\n});\n"]}

package/dist/cjs/test/unit/wallet.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=wallet.d.ts.map

package/dist/cjs/test/unit/wallet.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"wallet.d.ts","sourceRoot":"","sources":["../../../../test/unit/wallet.ts"],"names":[],"mappings":""}