@bitgo-beta/unspents 0.13.2-beta.49 → 0.13.2-beta.491

package/dist/test/dimensions.js

@@ -0,0 +1,225 @@
+"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 (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+/* eslint-disable @typescript-eslint/ban-ts-comment */
+const should = __importStar(require("should"));
+const utxo_lib_1 = require("@bitgo-beta/utxo-lib");
+const { chainCodes, chainCodesP2sh, chainCodesP2shP2wsh, chainCodesP2tr, chainCodesP2trMusig2, chainCodesP2wsh } = utxo_lib_1.bitgo;
+const src_1 = require("../src");
+const testutils_1 = require("./testutils");
+describe('Dimensions Attributes', function () {
+    it('has read-only nInputs and nOutputs', function () {
+        should.throws(() => (src_1.Dimensions.ZERO.nInputs = 1), /read-only/);
+        should.throws(() => (src_1.Dimensions.ZERO.nOutputs = 1), /read-only/);
+    });
+});
+describe('Output Dimensions', function () {
+    it('instantiates', function () {
+        const dims = new src_1.OutputDimensions({ size: 0, count: 0 });
+        should.throws(() => (dims.count += 1));
+    });
+});
+describe('Dimensions Arithmetic', function () {
+    it('sums correctly', function () {
+        src_1.Dimensions.zero()
+            .plus({ nP2shInputs: 1 })
+            .should.eql(new src_1.Dimensions({
+            nP2shInputs: 1,
+            nP2shP2wshInputs: 0,
+            nP2wshInputs: 0,
+            nP2trKeypathInputs: 0,
+            nP2trScriptPathLevel1Inputs: 0,
+            nP2trScriptPathLevel2Inputs: 0,
+            nP2shP2pkInputs: 0,
+            outputs: { size: 0, count: 0 },
+        }));
+        const components = [
+            { nP2shInputs: 1 },
+            { nP2shP2wshInputs: 2 },
+            { nP2wshInputs: 3 },
+            { nP2trKeypathInputs: 4 },
+            { nP2trScriptPathLevel1Inputs: 5 },
+            { nP2trScriptPathLevel2Inputs: 6 },
+            { outputs: { size: 23, count: 1 } },
+            { outputs: { size: 44, count: 2 } },
+            { outputs: { size: 0, count: 0 } },
+        ];
+        components.forEach((component) => should.doesNotThrow(() => src_1.Dimensions.sum(component)));
+        const sum = components.reduce((a, b) => a.plus(b), src_1.Dimensions.zero());
+        sum.should.eql(src_1.Dimensions.sum(...components));
+        sum.should.eql(new src_1.Dimensions({
+            nP2shInputs: 1,
+            nP2shP2wshInputs: 2,
+            nP2wshInputs: 3,
+            nP2trKeypathInputs: 4,
+            nP2trScriptPathLevel1Inputs: 5,
+            nP2trScriptPathLevel2Inputs: 6,
+            nP2shP2pkInputs: 0,
+            outputs: { size: 67, count: 3 },
+        }));
+        sum.nOutputs.should.eql(sum.outputs.count);
+    });
+    it('provides some typical output sizes', function () {
+        [
+            [src_1.Dimensions.SingleOutput.p2sh, src_1.VirtualSizes.txP2shOutputSize],
+            [src_1.Dimensions.SingleOutput.p2shP2wsh, src_1.VirtualSizes.txP2shP2wshOutputSize],
+            [src_1.Dimensions.SingleOutput.p2wsh, src_1.VirtualSizes.txP2wshOutputSize],
+            [src_1.Dimensions.SingleOutput.p2pkh, src_1.VirtualSizes.txP2pkhOutputSize],
+            [src_1.Dimensions.SingleOutput.p2wpkh, src_1.VirtualSizes.txP2wpkhOutputSize],
+            [src_1.Dimensions.SingleOutput.p2tr, src_1.VirtualSizes.txP2trOutputSize],
+        ].forEach(([dims, size]) => {
+            dims.getOutputsVSize().should.eql(size);
+        });
+    });
+    it('prevents sum of invalid data', function () {
+        should.doesNotThrow(() => src_1.Dimensions.sum({ outputs: { count: 0, size: 0 } }));
+        should.doesNotThrow(() => src_1.Dimensions.sum({ outputs: { count: 1, size: 1 } }));
+        should.throws(() => src_1.Dimensions.sum({ nOutputs: 1 }));
+        should.throws(() => src_1.Dimensions.sum({ nOutputs: 1, outputs: { count: 2, size: 1 } }));
+        // @ts-ignore
+        should.throws(() => src_1.Dimensions.sum({ nP2shInputs: 1 }, { nP2shInputs: 'foo' }));
+        should.throws(() => src_1.Dimensions.sum({ outputs: { count: 1, size: 0 } }));
+        should.throws(() => src_1.Dimensions.sum({ outputs: { count: 0, size: 1 } }));
+        should.throws(() => src_1.Dimensions.sum({ outputs: { count: 1, size: 1 } }, { outputs: { count: 1, size: 0 } }));
+    });
+    it('counts inputs correctly', function () {
+        Object.entries(src_1.Dimensions.SingleInput).forEach(([key, value]) => {
+            value.nInputs.should.eql(1, key);
+        });
+    });
+    it('multiplies correctly', function () {
+        const d = new src_1.Dimensions({
+            nP2shInputs: 1,
+            nP2shP2wshInputs: 2,
+            nP2wshInputs: 3,
+            nP2trKeypathInputs: 4,
+            nP2trScriptPathLevel1Inputs: 5,
+            nP2trScriptPathLevel2Inputs: 6,
+            nP2shP2pkInputs: 7,
+            outputs: { count: 1, size: 22 },
+        }).times(3);
+        d.should.eql(new src_1.Dimensions({
+            nP2shInputs: 3,
+            nP2shP2wshInputs: 6,
+            nP2wshInputs: 9,
+            nP2trKeypathInputs: 12,
+            nP2trScriptPathLevel1Inputs: 15,
+            nP2trScriptPathLevel2Inputs: 18,
+            nP2shP2pkInputs: 21,
+            outputs: { count: 3, size: 66 },
+        }));
+        d.getNInputs().should.eql(84);
+        d.nInputs.should.eql(84);
+    });
+});
+describe('Dimensions from unspent types', function () {
+    it('determines unspent size according to chain', function () {
+        chainCodesP2sh.forEach((chain) => src_1.Dimensions.fromUnspent({ chain }).should.eql(src_1.Dimensions.sum({ nP2shInputs: 1 })));
+        chainCodesP2shP2wsh.forEach((chain) => src_1.Dimensions.fromUnspent({ chain }).should.eql(src_1.Dimensions.sum({ nP2shP2wshInputs: 1 })));
+        chainCodesP2wsh.forEach((chain) => src_1.Dimensions.fromUnspent({ chain }).should.eql(src_1.Dimensions.sum({ nP2wshInputs: 1 })));
+        chainCodesP2tr.forEach((chain) => {
+            src_1.Dimensions.fromUnspent({ chain }).should.eql(src_1.Dimensions.sum({ nP2trScriptPathLevel2Inputs: 1 }));
+            src_1.Dimensions.fromUnspent({ chain }, { p2tr: { scriptPathLevel: 1 }, p2trMusig2: { scriptPathLevel: undefined } }).should.eql(src_1.Dimensions.sum({ nP2trScriptPathLevel1Inputs: 1 }));
+        });
+        chainCodesP2trMusig2.forEach((chain) => {
+            src_1.Dimensions.fromUnspent({ chain }).should.eql(src_1.Dimensions.sum({ nP2trScriptPathLevel1Inputs: 1 }));
+            src_1.Dimensions.fromUnspent({ chain }, { p2tr: { scriptPathLevel: undefined }, p2trMusig2: { scriptPathLevel: undefined } }).should.eql(src_1.Dimensions.sum({ nP2trKeypathInputs: 1 }));
+        });
+        src_1.Dimensions.fromUnspents(chainCodes.map((chain) => ({ chain }))).should.eql(new src_1.Dimensions({
+            nP2shP2wshInputs: 2,
+            nP2shInputs: 2,
+            nP2wshInputs: 2,
+            nP2trKeypathInputs: 0,
+            nP2trScriptPathLevel1Inputs: 2,
+            nP2trScriptPathLevel2Inputs: 2,
+            nP2shP2pkInputs: 0,
+            outputs: { count: 0, size: 0 },
+        }));
+        src_1.Dimensions.fromUnspents(chainCodes.map((chain) => ({ chain })), { p2tr: { scriptPathLevel: 1 }, p2trMusig2: { scriptPathLevel: undefined } }).should.eql(new src_1.Dimensions({
+            nP2shP2wshInputs: 2,
+            nP2shInputs: 2,
+            nP2wshInputs: 2,
+            nP2trKeypathInputs: 2,
+            nP2trScriptPathLevel1Inputs: 2,
+            nP2trScriptPathLevel2Inputs: 0,
+            nP2shP2pkInputs: 0,
+            outputs: { count: 0, size: 0 },
+        }));
+    });
+    it('calculates output dimensions dynamically', function () {
+        const expectedSizes = new Map([
+            [testutils_1.UnspentTypeScript2of3.p2sh, src_1.VirtualSizes.txP2shOutputSize],
+            [testutils_1.UnspentTypeScript2of3.p2shP2wsh, src_1.VirtualSizes.txP2shP2wshOutputSize],
+            [testutils_1.UnspentTypeScript2of3.p2wsh, src_1.VirtualSizes.txP2wshOutputSize],
+            [testutils_1.UnspentTypeScript2of3.p2tr, src_1.VirtualSizes.txP2trOutputSize],
+            [testutils_1.UnspentTypeScript2of3.p2trMusig2, src_1.VirtualSizes.txP2trOutputSize],
+            [testutils_1.UnspentTypeScript2of3.taprootKeyPathSpend, src_1.VirtualSizes.txP2trOutputSize],
+            [testutils_1.UnspentTypePubKeyHash.p2pkh, src_1.VirtualSizes.txP2pkhOutputSize],
+            [testutils_1.UnspentTypePubKeyHash.p2wpkh, src_1.VirtualSizes.txP2wpkhOutputSize],
+        ]);
+        [...Object.keys(testutils_1.UnspentTypeScript2of3), ...Object.keys(testutils_1.UnspentTypePubKeyHash)].forEach((type) => (0, testutils_1.getOutputDimensionsForUnspentType)(type).outputs.size.should.eql(expectedSizes.get(type)));
+    });
+});
+describe('Dimensions estimates', function () {
+    it('calculates vsizes', function () {
+        function dim(nP2shInputs, nP2shP2wshInputs, nP2wshInputs, nOutputs) {
+            return src_1.Dimensions.sum({
+                nP2shInputs,
+                nP2shP2wshInputs,
+                nP2wshInputs,
+            }, (0, testutils_1.getOutputDimensionsForUnspentType)(testutils_1.UnspentTypePubKeyHash.p2pkh).times(nOutputs));
+        }
+        function dimP2tr(nP2trKeypathInputs, nP2trScriptPathLevel1Inputs, nP2trScriptPathLevel2Inputs, nOutputs) {
+            return src_1.Dimensions.sum({
+                nP2trKeypathInputs,
+                nP2trScriptPathLevel1Inputs,
+                nP2trScriptPathLevel2Inputs,
+            }, (0, testutils_1.getOutputDimensionsForUnspentType)(testutils_1.UnspentTypePubKeyHash.p2pkh).times(nOutputs));
+        }
+        const vectors = [
+            [dim(1, 0, 0, 1), [false, 10, 298, 34, 342]],
+            [dim(0, 1, 0, 1), [true, 11, 140, 34, 185]],
+            [dim(0, 0, 1, 1), [true, 11, 105, 34, 150]],
+            [dim(2, 0, 0, 1), [false, 10, 596, 34, 640]],
+            [dim(0, 2, 0, 1), [true, 11, 280, 34, 325]],
+            [dim(0, 0, 2, 1), [true, 11, 210, 34, 255]],
+            [dim(1, 1, 1, 1), [true, 11, 543, 34, 588]],
+            [dim(1, 1, 1, 2), [true, 11, 543, 68, 622]],
+            [dimP2tr(1, 0, 0, 1), [true, 11, 58, 34, 103]],
+            [dimP2tr(0, 1, 0, 1), [true, 11, 108, 34, 153]],
+            [dimP2tr(0, 0, 1, 1), [true, 11, 116, 34, 161]],
+        ];
+        vectors.forEach(([dimensions, props]) => {
+            [
+                dimensions.isSegwit(),
+                dimensions.getOverheadVSize(),
+                dimensions.getInputsVSize(),
+                dimensions.getOutputsVSize(),
+                dimensions.getVSize(),
+            ].should.eql(props);
+        });
+    });
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"dimensions.js","sourceRoot":"","sources":["../../test/dimensions.ts"],"names":[],"mappings":"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","sourcesContent":["/* eslint-disable @typescript-eslint/ban-ts-comment */\nimport * as should from 'should';\nimport { bitgo } from '@bitgo-beta/utxo-lib';\nconst { chainCodes, chainCodesP2sh, chainCodesP2shP2wsh, chainCodesP2tr, chainCodesP2trMusig2, chainCodesP2wsh } =\n  bitgo;\nimport { Dimensions, OutputDimensions, VirtualSizes } from '../src';\n\nimport { getOutputDimensionsForUnspentType, UnspentTypePubKeyHash, UnspentTypeScript2of3 } from './testutils';\n\ndescribe('Dimensions Attributes', function () {\n  it('has read-only nInputs and nOutputs', function () {\n    should.throws(() => ((Dimensions.ZERO as any).nInputs = 1), /read-only/);\n    should.throws(() => ((Dimensions.ZERO as any).nOutputs = 1), /read-only/);\n  });\n});\n\ndescribe('Output Dimensions', function () {\n  it('instantiates', function () {\n    const dims = new OutputDimensions({ size: 0, count: 0 });\n    should.throws(() => (dims.count += 1));\n  });\n});\n\ndescribe('Dimensions Arithmetic', function () {\n  it('sums correctly', function () {\n    Dimensions.zero()\n      .plus({ nP2shInputs: 1 })\n      .should.eql(\n        new Dimensions({\n          nP2shInputs: 1,\n          nP2shP2wshInputs: 0,\n          nP2wshInputs: 0,\n          nP2trKeypathInputs: 0,\n          nP2trScriptPathLevel1Inputs: 0,\n          nP2trScriptPathLevel2Inputs: 0,\n          nP2shP2pkInputs: 0,\n          outputs: { size: 0, count: 0 },\n        })\n      );\n\n    const components = [\n      { nP2shInputs: 1 },\n      { nP2shP2wshInputs: 2 },\n      { nP2wshInputs: 3 },\n      { nP2trKeypathInputs: 4 },\n      { nP2trScriptPathLevel1Inputs: 5 },\n      { nP2trScriptPathLevel2Inputs: 6 },\n      { outputs: { size: 23, count: 1 } },\n      { outputs: { size: 44, count: 2 } },\n      { outputs: { size: 0, count: 0 } },\n    ];\n\n    components.forEach((component) => should.doesNotThrow(() => Dimensions.sum(component)));\n\n    const sum = components.reduce((a, b) => a.plus(b), Dimensions.zero());\n\n    sum.should.eql(Dimensions.sum(...components));\n\n    sum.should.eql(\n      new Dimensions({\n        nP2shInputs: 1,\n        nP2shP2wshInputs: 2,\n        nP2wshInputs: 3,\n        nP2trKeypathInputs: 4,\n        nP2trScriptPathLevel1Inputs: 5,\n        nP2trScriptPathLevel2Inputs: 6,\n        nP2shP2pkInputs: 0,\n        outputs: { size: 67, count: 3 },\n      })\n    );\n\n    sum.nOutputs.should.eql(sum.outputs.count);\n  });\n\n  it('provides some typical output sizes', function () {\n    (\n      [\n        [Dimensions.SingleOutput.p2sh, VirtualSizes.txP2shOutputSize],\n        [Dimensions.SingleOutput.p2shP2wsh, VirtualSizes.txP2shP2wshOutputSize],\n        [Dimensions.SingleOutput.p2wsh, VirtualSizes.txP2wshOutputSize],\n        [Dimensions.SingleOutput.p2pkh, VirtualSizes.txP2pkhOutputSize],\n        [Dimensions.SingleOutput.p2wpkh, VirtualSizes.txP2wpkhOutputSize],\n        [Dimensions.SingleOutput.p2tr, VirtualSizes.txP2trOutputSize],\n      ] as [Dimensions, number][]\n    ).forEach(([dims, size]) => {\n      dims.getOutputsVSize().should.eql(size);\n    });\n  });\n\n  it('prevents sum of invalid data', function () {\n    should.doesNotThrow(() => Dimensions.sum({ outputs: { count: 0, size: 0 } }));\n    should.doesNotThrow(() => Dimensions.sum({ outputs: { count: 1, size: 1 } }));\n    should.throws(() => Dimensions.sum({ nOutputs: 1 }));\n    should.throws(() => Dimensions.sum({ nOutputs: 1, outputs: { count: 2, size: 1 } }));\n    // @ts-ignore\n    should.throws(() => Dimensions.sum({ nP2shInputs: 1 }, { nP2shInputs: 'foo' }));\n    should.throws(() => Dimensions.sum({ outputs: { count: 1, size: 0 } }));\n    should.throws(() => Dimensions.sum({ outputs: { count: 0, size: 1 } }));\n    should.throws(() => Dimensions.sum({ outputs: { count: 1, size: 1 } }, { outputs: { count: 1, size: 0 } }));\n  });\n\n  it('counts inputs correctly', function () {\n    Object.entries(Dimensions.SingleInput).forEach(([key, value]) => {\n      value.nInputs.should.eql(1, key);\n    });\n  });\n\n  it('multiplies correctly', function () {\n    const d = new Dimensions({\n      nP2shInputs: 1,\n      nP2shP2wshInputs: 2,\n      nP2wshInputs: 3,\n      nP2trKeypathInputs: 4,\n      nP2trScriptPathLevel1Inputs: 5,\n      nP2trScriptPathLevel2Inputs: 6,\n      nP2shP2pkInputs: 7,\n      outputs: { count: 1, size: 22 },\n    }).times(3);\n\n    d.should.eql(\n      new Dimensions({\n        nP2shInputs: 3,\n        nP2shP2wshInputs: 6,\n        nP2wshInputs: 9,\n        nP2trKeypathInputs: 12,\n        nP2trScriptPathLevel1Inputs: 15,\n        nP2trScriptPathLevel2Inputs: 18,\n        nP2shP2pkInputs: 21,\n        outputs: { count: 3, size: 66 },\n      })\n    );\n\n    d.getNInputs().should.eql(84);\n    d.nInputs.should.eql(84);\n  });\n});\n\ndescribe('Dimensions from unspent types', function () {\n  it('determines unspent size according to chain', function () {\n    chainCodesP2sh.forEach((chain) => Dimensions.fromUnspent({ chain }).should.eql(Dimensions.sum({ nP2shInputs: 1 })));\n\n    chainCodesP2shP2wsh.forEach((chain) =>\n      Dimensions.fromUnspent({ chain }).should.eql(Dimensions.sum({ nP2shP2wshInputs: 1 }))\n    );\n\n    chainCodesP2wsh.forEach((chain) =>\n      Dimensions.fromUnspent({ chain }).should.eql(Dimensions.sum({ nP2wshInputs: 1 }))\n    );\n\n    chainCodesP2tr.forEach((chain) => {\n      Dimensions.fromUnspent({ chain }).should.eql(Dimensions.sum({ nP2trScriptPathLevel2Inputs: 1 }));\n      Dimensions.fromUnspent(\n        { chain },\n        { p2tr: { scriptPathLevel: 1 }, p2trMusig2: { scriptPathLevel: undefined } }\n      ).should.eql(Dimensions.sum({ nP2trScriptPathLevel1Inputs: 1 }));\n    });\n\n    chainCodesP2trMusig2.forEach((chain) => {\n      Dimensions.fromUnspent({ chain }).should.eql(Dimensions.sum({ nP2trScriptPathLevel1Inputs: 1 }));\n      Dimensions.fromUnspent(\n        { chain },\n        { p2tr: { scriptPathLevel: undefined }, p2trMusig2: { scriptPathLevel: undefined } }\n      ).should.eql(Dimensions.sum({ nP2trKeypathInputs: 1 }));\n    });\n\n    Dimensions.fromUnspents(chainCodes.map((chain) => ({ chain }))).should.eql(\n      new Dimensions({\n        nP2shP2wshInputs: 2,\n        nP2shInputs: 2,\n        nP2wshInputs: 2,\n        nP2trKeypathInputs: 0,\n        nP2trScriptPathLevel1Inputs: 2,\n        nP2trScriptPathLevel2Inputs: 2,\n        nP2shP2pkInputs: 0,\n        outputs: { count: 0, size: 0 },\n      })\n    );\n\n    Dimensions.fromUnspents(\n      chainCodes.map((chain) => ({ chain })),\n      { p2tr: { scriptPathLevel: 1 }, p2trMusig2: { scriptPathLevel: undefined } }\n    ).should.eql(\n      new Dimensions({\n        nP2shP2wshInputs: 2,\n        nP2shInputs: 2,\n        nP2wshInputs: 2,\n        nP2trKeypathInputs: 2,\n        nP2trScriptPathLevel1Inputs: 2,\n        nP2trScriptPathLevel2Inputs: 0,\n        nP2shP2pkInputs: 0,\n        outputs: { count: 0, size: 0 },\n      })\n    );\n  });\n\n  it('calculates output dimensions dynamically', function () {\n    const expectedSizes = new Map([\n      [UnspentTypeScript2of3.p2sh, VirtualSizes.txP2shOutputSize],\n      [UnspentTypeScript2of3.p2shP2wsh, VirtualSizes.txP2shP2wshOutputSize],\n      [UnspentTypeScript2of3.p2wsh, VirtualSizes.txP2wshOutputSize],\n      [UnspentTypeScript2of3.p2tr, VirtualSizes.txP2trOutputSize],\n      [UnspentTypeScript2of3.p2trMusig2, VirtualSizes.txP2trOutputSize],\n      [UnspentTypeScript2of3.taprootKeyPathSpend, VirtualSizes.txP2trOutputSize],\n      [UnspentTypePubKeyHash.p2pkh, VirtualSizes.txP2pkhOutputSize],\n      [UnspentTypePubKeyHash.p2wpkh, VirtualSizes.txP2wpkhOutputSize],\n    ]);\n\n    [...Object.keys(UnspentTypeScript2of3), ...Object.keys(UnspentTypePubKeyHash)].forEach((type) =>\n      getOutputDimensionsForUnspentType(type).outputs.size.should.eql(expectedSizes.get(type as any))\n    );\n  });\n});\n\ndescribe('Dimensions estimates', function () {\n  it('calculates vsizes', function () {\n    function dim(nP2shInputs: number, nP2shP2wshInputs: number, nP2wshInputs: number, nOutputs: number): Dimensions {\n      return Dimensions.sum(\n        {\n          nP2shInputs,\n          nP2shP2wshInputs,\n          nP2wshInputs,\n        },\n        getOutputDimensionsForUnspentType(UnspentTypePubKeyHash.p2pkh).times(nOutputs)\n      );\n    }\n\n    function dimP2tr(\n      nP2trKeypathInputs: number,\n      nP2trScriptPathLevel1Inputs: number,\n      nP2trScriptPathLevel2Inputs: number,\n      nOutputs: number\n    ): Dimensions {\n      return Dimensions.sum(\n        {\n          nP2trKeypathInputs,\n          nP2trScriptPathLevel1Inputs,\n          nP2trScriptPathLevel2Inputs,\n        },\n        getOutputDimensionsForUnspentType(UnspentTypePubKeyHash.p2pkh).times(nOutputs)\n      );\n    }\n\n    const vectors: [Dimensions, unknown[]][] = [\n      [dim(1, 0, 0, 1), [false, 10, 298, 34, 342]],\n      [dim(0, 1, 0, 1), [true, 11, 140, 34, 185]],\n      [dim(0, 0, 1, 1), [true, 11, 105, 34, 150]],\n      [dim(2, 0, 0, 1), [false, 10, 596, 34, 640]],\n      [dim(0, 2, 0, 1), [true, 11, 280, 34, 325]],\n      [dim(0, 0, 2, 1), [true, 11, 210, 34, 255]],\n      [dim(1, 1, 1, 1), [true, 11, 543, 34, 588]],\n      [dim(1, 1, 1, 2), [true, 11, 543, 68, 622]],\n\n      [dimP2tr(1, 0, 0, 1), [true, 11, 58, 34, 103]],\n      [dimP2tr(0, 1, 0, 1), [true, 11, 108, 34, 153]],\n      [dimP2tr(0, 0, 1, 1), [true, 11, 116, 34, 161]],\n    ];\n\n    vectors.forEach(([dimensions, props]) => {\n      [\n        dimensions.isSegwit(),\n        dimensions.getOverheadVSize(),\n        dimensions.getInputsVSize(),\n        dimensions.getOutputsVSize(),\n        dimensions.getVSize(),\n      ].should.eql(props);\n    });\n  });\n});\n"]}

package/dist/test/signedTx/inputWeights.d.ts

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

package/dist/test/signedTx/inputWeights.d.ts.map

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

package/dist/test/signedTx/inputWeights.js

@@ -0,0 +1,117 @@
+"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 (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const assert = __importStar(require("assert"));
+const utxolib = __importStar(require("@bitgo-beta/utxo-lib"));
+const utxo_lib_1 = require("@bitgo-beta/utxo-lib");
+const inputWeights_1 = require("../../src/inputWeights");
+const scriptSizes_1 = require("../../src/scriptSizes");
+const testutils_1 = require("../testutils");
+describe('Input Script Sizes (Worst-Case)', function () {
+    const keys = [1, 2, 3].map((v) => utxo_lib_1.bip32.fromSeed(Buffer.alloc(16, `test/${v}`)));
+    const rootWalletKeys = new utxolib.bitgo.RootWalletKeys([keys[0], keys[1], keys[2]]);
+    function getLargestInputWithType(inputType, signKeys, inputCount = 100) {
+        const signerName = signKeys[0];
+        const cosignerName = signKeys.length > 1 ? signKeys[1] : signerName;
+        const inputScriptTypes = Array.from({ length: inputCount }).fill(inputType);
+        const outputScriptTypes = [testutils_1.UnspentTypeScript2of3.p2sh];
+        return (0, testutils_1.getSignedTransaction)(rootWalletKeys, signerName, cosignerName, inputScriptTypes, outputScriptTypes).ins.reduce((a, b) => ((0, inputWeights_1.getInputWeight)(a) > (0, inputWeights_1.getInputWeight)(b) ? a : b));
+    }
+    function getInputComponents(input) {
+        const decompiled = utxolib.script.decompile(input.script);
+        if (!decompiled) {
+            throw new Error();
+        }
+        const script = decompiled.map((v) => {
+            if (!Buffer.isBuffer(v)) {
+                return { length: 1 };
+            }
+            return { length: v.length + (0, scriptSizes_1.pushdataEncodingLength)(v.length) };
+        });
+        const witness = (input.witness || []).map((v) => ({ length: v.length }));
+        const scriptSize = script.reduce((a, b) => a + b.length, 0);
+        assert.strictEqual(scriptSize, input.script.length, utxolib.script.toASM(decompiled));
+        return {
+            script: script.map((v) => v.length),
+            witness: witness.map((v) => v.length),
+        };
+    }
+    function runTestComponentSizes(inputType, signKeys) {
+        const signKeysStr = signKeys.join(',');
+        describe(`inputType=${inputType} signKeys=${signKeysStr}`, function () {
+            it(`component sizes`, function () {
+                this.timeout(10000);
+                let expectedComponents;
+                switch (inputType) {
+                    case 'p2sh':
+                        expectedComponents = inputWeights_1.inputComponentsP2sh;
+                        break;
+                    case 'p2shP2wsh':
+                        expectedComponents = inputWeights_1.inputComponentsP2shP2wsh;
+                        break;
+                    case 'p2wsh':
+                        expectedComponents = inputWeights_1.inputComponentsP2wsh;
+                        break;
+                    case 'p2shP2pk':
+                        expectedComponents = inputWeights_1.inputComponentsP2shP2pk;
+                        break;
+                    case 'p2tr':
+                        if (signKeys[1] === 'bitgo') {
+                            expectedComponents = inputWeights_1.inputComponentsP2trScriptSpendLevel1;
+                        }
+                        else if (signKeys[1] === 'backup') {
+                            expectedComponents = inputWeights_1.inputComponentsP2trScriptSpendLevel2;
+                        }
+                        else {
+                            throw new Error(`unexpected cosigner`);
+                        }
+                        break;
+                    case 'p2trMusig2':
+                        // assumes only script path
+                        expectedComponents = inputWeights_1.inputComponentsP2trScriptSpendLevel1;
+                        break;
+                    case 'taprootKeyPathSpend':
+                        expectedComponents = inputWeights_1.inputComponentsP2trKeySpend;
+                        break;
+                    default:
+                        throw new Error(`invalid inputType ${inputType}`);
+                }
+                const input = getLargestInputWithType(inputType, signKeys, inputType === 'p2tr' || inputType === 'p2trMusig2' || inputType === 'taprootKeyPathSpend' ? 10 : 100);
+                const components = getInputComponents(input);
+                assert.deepStrictEqual(components, expectedComponents);
+                assert.strictEqual((0, inputWeights_1.getInputComponentsWeight)(components), (0, inputWeights_1.getInputWeight)(input));
+            });
+        });
+    }
+    (0, testutils_1.getInputScriptTypes)().forEach((inputType) => {
+        if (inputType !== 'p2trMusig2') {
+            runTestComponentSizes(inputType, inputType === 'p2shP2pk' ? ['user'] : ['user', 'bitgo']);
+        }
+        if (inputType !== 'p2shP2pk' && inputType !== 'taprootKeyPathSpend') {
+            runTestComponentSizes(inputType, ['user', 'backup']);
+        }
+    });
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"inputWeights.js","sourceRoot":"","sources":["../../../test/signedTx/inputWeights.ts"],"names":[],"mappings":"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","sourcesContent":["import * as assert from 'assert';\n\nimport * as mocha from 'mocha';\nimport * as utxolib from '@bitgo-beta/utxo-lib';\nimport { bip32, BIP32Interface } from '@bitgo-beta/utxo-lib';\nimport {\n  getInputComponentsWeight,\n  getInputWeight,\n  InputComponents,\n  inputComponentsP2sh,\n  inputComponentsP2shP2pk,\n  inputComponentsP2shP2wsh,\n  inputComponentsP2trKeySpend,\n  inputComponentsP2trScriptSpendLevel1,\n  inputComponentsP2trScriptSpendLevel2,\n  inputComponentsP2wsh,\n} from '../../src/inputWeights';\nimport { pushdataEncodingLength } from '../../src/scriptSizes';\nimport {\n  getInputScriptTypes,\n  getSignedTransaction,\n  InputScriptType,\n  TestUnspentType,\n  UnspentTypeScript2of3,\n} from '../testutils';\n\ndescribe('Input Script Sizes (Worst-Case)', function () {\n  const keys = [1, 2, 3].map((v) => bip32.fromSeed(Buffer.alloc(16, `test/${v}`))) as BIP32Interface[];\n  const rootWalletKeys = new utxolib.bitgo.RootWalletKeys([keys[0], keys[1], keys[2]]);\n\n  function getLargestInputWithType(\n    inputType: string,\n    signKeys: utxolib.bitgo.KeyName[],\n    inputCount = 100\n  ): utxolib.TxInput {\n    const signerName = signKeys[0];\n    const cosignerName = signKeys.length > 1 ? signKeys[1] : signerName;\n    const inputScriptTypes = Array.from({ length: inputCount }).fill(inputType) as InputScriptType[];\n    const outputScriptTypes = [UnspentTypeScript2of3.p2sh] as TestUnspentType[];\n    return getSignedTransaction(\n      rootWalletKeys,\n      signerName,\n      cosignerName,\n      inputScriptTypes,\n      outputScriptTypes\n    ).ins.reduce((a, b) => (getInputWeight(a) > getInputWeight(b) ? a : b));\n  }\n\n  function getInputComponents(input: utxolib.TxInput): InputComponents {\n    const decompiled = utxolib.script.decompile(input.script);\n    if (!decompiled) {\n      throw new Error();\n    }\n\n    const script = decompiled.map((v) => {\n      if (!Buffer.isBuffer(v)) {\n        return { length: 1 };\n      }\n      return { length: v.length + pushdataEncodingLength(v.length) };\n    });\n    const witness = (input.witness || []).map((v) => ({ length: v.length }));\n\n    const scriptSize = script.reduce((a, b) => a + b.length, 0);\n    assert.strictEqual(scriptSize, input.script.length, utxolib.script.toASM(decompiled));\n\n    return {\n      script: script.map((v) => v.length),\n      witness: witness.map((v) => v.length),\n    };\n  }\n\n  function runTestComponentSizes(inputType: string, signKeys: utxolib.bitgo.KeyName[]) {\n    const signKeysStr = signKeys.join(',');\n\n    describe(`inputType=${inputType} signKeys=${signKeysStr}`, function () {\n      it(`component sizes`, function (this: mocha.Context) {\n        this.timeout(10_000);\n        let expectedComponents;\n        switch (inputType) {\n          case 'p2sh':\n            expectedComponents = inputComponentsP2sh;\n            break;\n          case 'p2shP2wsh':\n            expectedComponents = inputComponentsP2shP2wsh;\n            break;\n          case 'p2wsh':\n            expectedComponents = inputComponentsP2wsh;\n            break;\n          case 'p2shP2pk':\n            expectedComponents = inputComponentsP2shP2pk;\n            break;\n          case 'p2tr':\n            if (signKeys[1] === 'bitgo') {\n              expectedComponents = inputComponentsP2trScriptSpendLevel1;\n            } else if (signKeys[1] === 'backup') {\n              expectedComponents = inputComponentsP2trScriptSpendLevel2;\n            } else {\n              throw new Error(`unexpected cosigner`);\n            }\n            break;\n          case 'p2trMusig2':\n            // assumes only script path\n            expectedComponents = inputComponentsP2trScriptSpendLevel1;\n            break;\n          case 'taprootKeyPathSpend':\n            expectedComponents = inputComponentsP2trKeySpend;\n            break;\n          default:\n            throw new Error(`invalid inputType ${inputType}`);\n        }\n\n        const input = getLargestInputWithType(\n          inputType,\n          signKeys,\n          inputType === 'p2tr' || inputType === 'p2trMusig2' || inputType === 'taprootKeyPathSpend' ? 10 : 100\n        );\n        const components = getInputComponents(input);\n        assert.deepStrictEqual(components, expectedComponents);\n        assert.strictEqual(getInputComponentsWeight(components), getInputWeight(input));\n      });\n    });\n  }\n\n  getInputScriptTypes().forEach((inputType: string) => {\n    if (inputType !== 'p2trMusig2') {\n      runTestComponentSizes(inputType, inputType === 'p2shP2pk' ? ['user'] : ['user', 'bitgo']);\n    }\n    if (inputType !== 'p2shP2pk' && inputType !== 'taprootKeyPathSpend') {\n      runTestComponentSizes(inputType, ['user', 'backup']);\n    }\n  });\n});\n"]}

package/dist/test/signedTx/txCombinations.d.ts

@@ -0,0 +1,3 @@
+import * as utxolib from '@bitgo-beta/utxo-lib';
+export type InputScriptType = utxolib.bitgo.outputScripts.ScriptType | 'taprootKeyPathSpend';
+//# sourceMappingURL=txCombinations.d.ts.map

package/dist/test/signedTx/txCombinations.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"txCombinations.d.ts","sourceRoot":"","sources":["../../../test/signedTx/txCombinations.ts"],"names":[],"mappings":"AAcA,OAAO,KAAK,OAAO,MAAM,sBAAsB,CAAC;AAEhD,MAAM,MAAM,eAAe,GAAG,OAAO,CAAC,KAAK,CAAC,aAAa,CAAC,UAAU,GAAG,qBAAqB,CAAC"}

package/dist/test/signedTx/txCombinations.js

@@ -0,0 +1,120 @@
+"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 (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __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 should_1 = __importDefault(require("should"));
+const src_1 = require("../../src");
+const testutils_1 = require("../testutils");
+const txGen_1 = require("./txGen");
+const utxolib = __importStar(require("@bitgo-beta/utxo-lib"));
+const keys = [1, 2, 3].map((v) => utxolib.bip32.fromSeed(Buffer.alloc(16, `test/2/${v}`), utxolib.networks.bitcoin));
+const rootWalletKeys = new utxolib.bitgo.RootWalletKeys([keys[0], keys[1], keys[2]]);
+const testDimensionsFromTx = (txCombo) => {
+    const { inputTypes, outputTypes, expectedDims } = txCombo;
+    describe(`Combination inputs=${inputTypes}; outputs=${outputTypes}`, function () {
+        const nInputs = inputTypes.length;
+        const outputDims = src_1.Dimensions.sum(...outputTypes.map(testutils_1.getOutputDimensionsForUnspentType));
+        it(`calculates dimensions from unsigned transaction`, function () {
+            const unsignedTx = txCombo.getUnsignedTx();
+            // does not work for unsigned transactions
+            should_1.default.throws(() => src_1.Dimensions.fromTransaction(unsignedTx));
+            // unless explicitly allowed
+            src_1.Dimensions.fromTransaction(unsignedTx, { assumeUnsigned: src_1.Dimensions.ASSUME_P2SH }).should.eql(src_1.Dimensions.sum({ nP2shInputs: nInputs }, outputDims));
+            src_1.Dimensions.fromTransaction(unsignedTx, { assumeUnsigned: src_1.Dimensions.ASSUME_P2SH_P2WSH }).should.eql(src_1.Dimensions.sum({ nP2shP2wshInputs: nInputs }, outputDims));
+            src_1.Dimensions.fromTransaction(unsignedTx, { assumeUnsigned: src_1.Dimensions.ASSUME_P2WSH }).should.eql(src_1.Dimensions.sum({ nP2wshInputs: nInputs }, outputDims));
+        });
+        it(`calculates dimensions for signed transaction`, function () {
+            const dimensions = src_1.Dimensions.fromTransaction(txCombo.getSignedTx());
+            dimensions.should.eql(expectedDims);
+        });
+        it(`calculates dimensions for signed input of transaction`, function () {
+            const signedTx = txCombo.getSignedTx();
+            // test Dimensions.fromInput()
+            inputTypes.forEach((input, i) => src_1.Dimensions.fromInput(signedTx.ins[i]).should.eql(src_1.Dimensions.sum((0, testutils_1.getInputDimensionsForUnspentType)(input))));
+        });
+    });
+};
+const testDimensionsFromPsbt = (keys, inputTypes, outputTypes, expectedDims) => {
+    describe(`Psbt Combination inputs=${inputTypes}; outputs=${outputTypes}`, function () {
+        ['unsigned', 'halfsigned', 'fullysigned'].forEach((s) => {
+            it(`calculates dimensions from ${s} psbt`, function () {
+                const dimensions = src_1.Dimensions.fromPsbt((0, testutils_1.constructPsbt)(keys, inputTypes, outputTypes, s));
+                dimensions.should.eql(expectedDims);
+            });
+        });
+        it(`calculates dimensions for signed input of psbt`, function () {
+            const signedPsbt = (0, testutils_1.constructPsbt)(keys, inputTypes, outputTypes, 'fullysigned');
+            inputTypes.forEach((input, i) => src_1.Dimensions.fromPsbtInput(signedPsbt.data.inputs[i]).should.eql(src_1.Dimensions.sum((0, testutils_1.getInputDimensionsForUnspentType)(input))));
+        });
+    });
+};
+describe(`Dimensions for transaction combinations`, function () {
+    // p2trMusig2 is supported only with PSBT
+    const scriptTypes = utxolib.bitgo.outputScripts.scriptTypes2Of3.filter((t) => t !== 'p2trMusig2');
+    const params = {
+        inputTypes: [...scriptTypes, testutils_1.UnspentTypeP2shP2pk],
+        maxNInputs: 2,
+        outputTypes: [...scriptTypes, ...Object.keys(testutils_1.UnspentTypePubKeyHash)],
+        maxNOutputs: 2,
+    };
+    (0, txGen_1.runCombinations)(params, (inputTypeCombo, outputTypeCombo) => {
+        const expectedInputDims = src_1.Dimensions.sum(...inputTypeCombo.map(testutils_1.getInputDimensionsForUnspentType));
+        const expectedOutputDims = src_1.Dimensions.sum(...outputTypeCombo.map(testutils_1.getOutputDimensionsForUnspentType));
+        testDimensionsFromTx(new txGen_1.TxCombo(keys, inputTypeCombo, outputTypeCombo, expectedInputDims.plus(expectedOutputDims)));
+        // Doubling the inputs should yield twice the input dims
+        testDimensionsFromTx(new txGen_1.TxCombo(keys, [...inputTypeCombo, ...inputTypeCombo], outputTypeCombo, expectedInputDims.plus(expectedInputDims).plus(expectedOutputDims)));
+        // Same for outputs
+        testDimensionsFromTx(new txGen_1.TxCombo(keys, inputTypeCombo, [...outputTypeCombo, ...outputTypeCombo], expectedInputDims.plus(expectedOutputDims).plus(expectedOutputDims)));
+    });
+});
+describe(`Dimensions for PSBT combinations`, function () {
+    const params = {
+        inputTypes: [
+            ...utxolib.bitgo.outputScripts.scriptTypes2Of3,
+            utxolib.bitgo.outputScripts.scriptTypeP2shP2pk,
+            'taprootKeyPathSpend',
+        ],
+        maxNInputs: 1,
+        outputTypes: [...Object.keys(testutils_1.UnspentTypeScript2of3), ...Object.keys(testutils_1.UnspentTypePubKeyHash)],
+        maxNOutputs: 1,
+    };
+    it(`does not work for unknown psbt input`, function () {
+        const psbt = utxolib.bitgo.createPsbtForNetwork({ network: utxolib.networks.bitcoin });
+        psbt.addInput({ hash: Buffer.alloc(32), index: 0 });
+        should_1.default.throws(() => src_1.Dimensions.fromPsbt(psbt));
+    });
+    (0, txGen_1.runCombinations)(params, (inputTypeCombo, outputTypeCombo) => {
+        const expectedInputDims = src_1.Dimensions.sum(...inputTypeCombo.map(testutils_1.getInputDimensionsForUnspentType));
+        const expectedOutputDims = src_1.Dimensions.sum(...outputTypeCombo.map(testutils_1.getOutputDimensionsForUnspentType));
+        testDimensionsFromPsbt(rootWalletKeys, inputTypeCombo, outputTypeCombo, expectedInputDims.plus(expectedOutputDims));
+        // Doubling the inputs should yield twice the input dims
+        testDimensionsFromPsbt(rootWalletKeys, [...inputTypeCombo, ...inputTypeCombo], outputTypeCombo, expectedInputDims.plus(expectedInputDims).plus(expectedOutputDims));
+        // Same for outputs
+        testDimensionsFromPsbt(rootWalletKeys, inputTypeCombo, [...outputTypeCombo, ...outputTypeCombo], expectedInputDims.plus(expectedOutputDims).plus(expectedOutputDims));
+    });
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"txCombinations.js","sourceRoot":"","sources":["../../../test/signedTx/txCombinations.ts"],"names":[],"mappings":"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","sourcesContent":["import should from 'should';\nimport { Dimensions } from '../../src';\n\nimport {\n  constructPsbt,\n  getInputDimensionsForUnspentType,\n  getOutputDimensionsForUnspentType,\n  TestUnspentType,\n  UnspentTypeP2shP2pk,\n  UnspentTypePubKeyHash,\n  UnspentTypeScript2of3,\n} from '../testutils';\n\nimport { runCombinations, TxCombo } from './txGen';\nimport * as utxolib from '@bitgo-beta/utxo-lib';\n\nexport type InputScriptType = utxolib.bitgo.outputScripts.ScriptType | 'taprootKeyPathSpend';\n\nconst keys = [1, 2, 3].map((v) =>\n  utxolib.bip32.fromSeed(Buffer.alloc(16, `test/2/${v}`), utxolib.networks.bitcoin)\n) as utxolib.BIP32Interface[];\n\nconst rootWalletKeys = new utxolib.bitgo.RootWalletKeys([keys[0], keys[1], keys[2]]);\n\nconst testDimensionsFromTx = (txCombo: any) => {\n  const { inputTypes, outputTypes, expectedDims } = txCombo;\n\n  describe(`Combination inputs=${inputTypes}; outputs=${outputTypes}`, function () {\n    const nInputs = inputTypes.length;\n    const outputDims = Dimensions.sum(...outputTypes.map(getOutputDimensionsForUnspentType));\n\n    it(`calculates dimensions from unsigned transaction`, function () {\n      const unsignedTx = txCombo.getUnsignedTx();\n\n      // does not work for unsigned transactions\n      should.throws(() => Dimensions.fromTransaction(unsignedTx));\n\n      // unless explicitly allowed\n      Dimensions.fromTransaction(unsignedTx, { assumeUnsigned: Dimensions.ASSUME_P2SH }).should.eql(\n        Dimensions.sum({ nP2shInputs: nInputs }, outputDims)\n      );\n\n      Dimensions.fromTransaction(unsignedTx, { assumeUnsigned: Dimensions.ASSUME_P2SH_P2WSH }).should.eql(\n        Dimensions.sum({ nP2shP2wshInputs: nInputs }, outputDims)\n      );\n\n      Dimensions.fromTransaction(unsignedTx, { assumeUnsigned: Dimensions.ASSUME_P2WSH }).should.eql(\n        Dimensions.sum({ nP2wshInputs: nInputs }, outputDims)\n      );\n    });\n\n    it(`calculates dimensions for signed transaction`, function () {\n      const dimensions = Dimensions.fromTransaction(txCombo.getSignedTx());\n      dimensions.should.eql(expectedDims);\n    });\n\n    it(`calculates dimensions for signed input of transaction`, function () {\n      const signedTx = txCombo.getSignedTx();\n\n      // test Dimensions.fromInput()\n      inputTypes.forEach((input: any, i: number) =>\n        Dimensions.fromInput(signedTx.ins[i]).should.eql(Dimensions.sum(getInputDimensionsForUnspentType(input)))\n      );\n    });\n  });\n};\n\nconst testDimensionsFromPsbt = (\n  keys: utxolib.bitgo.RootWalletKeys,\n  inputTypes: InputScriptType[],\n  outputTypes: TestUnspentType[],\n  expectedDims: Dimensions\n) => {\n  describe(`Psbt Combination inputs=${inputTypes}; outputs=${outputTypes}`, function () {\n    (['unsigned', 'halfsigned', 'fullysigned'] as const).forEach((s) => {\n      it(`calculates dimensions from ${s} psbt`, function () {\n        const dimensions = Dimensions.fromPsbt(constructPsbt(keys, inputTypes, outputTypes, s));\n        dimensions.should.eql(expectedDims);\n      });\n    });\n\n    it(`calculates dimensions for signed input of psbt`, function () {\n      const signedPsbt = constructPsbt(keys, inputTypes, outputTypes, 'fullysigned');\n\n      inputTypes.forEach((input: any, i: number) =>\n        Dimensions.fromPsbtInput(signedPsbt.data.inputs[i]).should.eql(\n          Dimensions.sum(getInputDimensionsForUnspentType(input))\n        )\n      );\n    });\n  });\n};\n\ndescribe(`Dimensions for transaction combinations`, function () {\n  // p2trMusig2 is supported only with PSBT\n  const scriptTypes = utxolib.bitgo.outputScripts.scriptTypes2Of3.filter((t) => t !== 'p2trMusig2');\n  const params = {\n    inputTypes: [...scriptTypes, UnspentTypeP2shP2pk] as InputScriptType[],\n    maxNInputs: 2,\n    outputTypes: [...scriptTypes, ...Object.keys(UnspentTypePubKeyHash)] as TestUnspentType[],\n    maxNOutputs: 2,\n  };\n\n  runCombinations(params, (inputTypeCombo: InputScriptType[], outputTypeCombo: TestUnspentType[]) => {\n    const expectedInputDims = Dimensions.sum(...inputTypeCombo.map(getInputDimensionsForUnspentType));\n    const expectedOutputDims = Dimensions.sum(...outputTypeCombo.map(getOutputDimensionsForUnspentType));\n\n    testDimensionsFromTx(\n      new TxCombo(keys, inputTypeCombo, outputTypeCombo, expectedInputDims.plus(expectedOutputDims))\n    );\n\n    // Doubling the inputs should yield twice the input dims\n    testDimensionsFromTx(\n      new TxCombo(\n        keys,\n        [...inputTypeCombo, ...inputTypeCombo],\n        outputTypeCombo,\n        expectedInputDims.plus(expectedInputDims).plus(expectedOutputDims)\n      )\n    );\n\n    // Same for outputs\n    testDimensionsFromTx(\n      new TxCombo(\n        keys,\n        inputTypeCombo,\n        [...outputTypeCombo, ...outputTypeCombo],\n        expectedInputDims.plus(expectedOutputDims).plus(expectedOutputDims)\n      )\n    );\n  });\n});\n\ndescribe(`Dimensions for PSBT combinations`, function () {\n  const params = {\n    inputTypes: [\n      ...utxolib.bitgo.outputScripts.scriptTypes2Of3,\n      utxolib.bitgo.outputScripts.scriptTypeP2shP2pk,\n      'taprootKeyPathSpend',\n    ] as InputScriptType[],\n    maxNInputs: 1,\n    outputTypes: [...Object.keys(UnspentTypeScript2of3), ...Object.keys(UnspentTypePubKeyHash)],\n    maxNOutputs: 1,\n  };\n\n  it(`does not work for unknown psbt input`, function () {\n    const psbt = utxolib.bitgo.createPsbtForNetwork({ network: utxolib.networks.bitcoin });\n    psbt.addInput({ hash: Buffer.alloc(32), index: 0 });\n    should.throws(() => Dimensions.fromPsbt(psbt));\n  });\n\n  runCombinations(params, (inputTypeCombo: InputScriptType[], outputTypeCombo: TestUnspentType[]) => {\n    const expectedInputDims = Dimensions.sum(...inputTypeCombo.map(getInputDimensionsForUnspentType));\n    const expectedOutputDims = Dimensions.sum(...outputTypeCombo.map(getOutputDimensionsForUnspentType));\n\n    testDimensionsFromPsbt(rootWalletKeys, inputTypeCombo, outputTypeCombo, expectedInputDims.plus(expectedOutputDims));\n\n    // Doubling the inputs should yield twice the input dims\n    testDimensionsFromPsbt(\n      rootWalletKeys,\n      [...inputTypeCombo, ...inputTypeCombo],\n      outputTypeCombo,\n      expectedInputDims.plus(expectedInputDims).plus(expectedOutputDims)\n    );\n\n    // Same for outputs\n    testDimensionsFromPsbt(\n      rootWalletKeys,\n      inputTypeCombo,\n      [...outputTypeCombo, ...outputTypeCombo],\n      expectedInputDims.plus(expectedOutputDims).plus(expectedOutputDims)\n    );\n  });\n});\n"]}