@bitgo-beta/abstract-utxo 1.6.1-alpha.45 → 1.6.1-alpha.450

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

@@ -0,0 +1,327 @@
+"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 bitcoinMock = sinon
+            .stub(coin, 'createTransactionFromHex')
+            .returns({ ins: [] });
+        const result = await coin.verifyTransaction({
+            txParams: {
+                walletPassphrase: passphrase,
+            },
+            txPrebuild: {
+                txHex: '00',
+            },
+            wallet: unsignedSendingWallet,
+        });
+        assert_1.default.strictEqual(result, true);
+        coinMock.restore();
+        bitcoinMock.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 bitcoinMock = sinon
+            .stub(coin, 'createTransactionFromHex')
+            .returns({ ins: [] });
+        const result = await coin.verifyTransaction({
+            txParams: {
+                walletPassphrase: passphrase,
+            },
+            txPrebuild: {
+                txHex: '00',
+            },
+            wallet: unsignedSendingWallet,
+            verification: {},
+        });
+        assert_1.default.strictEqual(result, true);
+        coinMock.restore();
+        bitcoinMock.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 bitcoinMock = sinon
+            .stub(bigintCoin, 'createTransactionFromHex')
+            .returns({ ins: [] });
+        const result = await bigintCoin.verifyTransaction({
+            txParams: {
+                walletPassphrase: passphrase,
+            },
+            txPrebuild: {
+                txHex: '00',
+            },
+            wallet: unsignedSendingWallet,
+            verification: {},
+        });
+        assert_1.default.strictEqual(result, true);
+        coinMock.restore();
+        bitcoinMock.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 utxolib from '@bitgo-beta/utxo-lib';\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 bitcoinMock = sinon\n      .stub(coin, 'createTransactionFromHex')\n      .returns({ ins: [] } as unknown as utxolib.bitgo.UtxoTransaction);\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    bitcoinMock.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 bitcoinMock = sinon\n      .stub(coin, 'createTransactionFromHex')\n      .returns({ ins: [] } as unknown as utxolib.bitgo.UtxoTransaction);\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    bitcoinMock.restore();\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 bitcoinMock = sinon\n      .stub(bigintCoin, 'createTransactionFromHex')\n      .returns({ ins: [] } as unknown as utxolib.bitgo.UtxoTransaction);\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    bitcoinMock.restore();\n  });\n});\n"]}

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

@@ -0,0 +1,2 @@
+import 'should';
+//# 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":"AACA,OAAO,QAAQ,CAAC"}