@bitgo-beta/unspents 0.13.2-beta.9 → 0.13.2-beta.91

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

@@ -0,0 +1,75 @@
+/// <reference types="node" />
+import * as utxolib from '@bitgo-beta/utxo-lib';
+import { BIP32Interface } from '@bitgo-beta/utxo-lib';
+import 'lodash.combinations';
+import { Dimensions } from '../../src';
+import { InputScriptType, TestUnspentType } from '../testutils';
+interface IUnspent {
+    scriptPubKey: Buffer;
+    redeemScript?: Buffer;
+    witnessScript?: Buffer;
+    value: number;
+    inputType: utxolib.bitgo.outputScripts.ScriptType;
+}
+/**
+ *
+ * @param keys - Pubkeys to use for generating the address.
+ *               If unspentType is one of UnspentTypePubKeyHash is used, the first key will be used.
+ * @param unspentType {String} - one of UnspentTypeScript2of3 or UnspentTypePubKeyHash
+ * @return {String} address
+ */
+export declare const createScriptPubKey: (keys: BIP32Interface[], unspentType: TestUnspentType) => Buffer;
+declare class TxCombo {
+    walletKeys: BIP32Interface[];
+    inputTypes: string[];
+    outputTypes: TestUnspentType[];
+    expectedDims: Readonly<Dimensions>;
+    signKeys?: utxolib.BIP32Interface[] | undefined;
+    inputValue: number;
+    unspents: IUnspent[];
+    inputTx: any;
+    constructor(walletKeys: BIP32Interface[], inputTypes: string[], outputTypes: TestUnspentType[], expectedDims?: Readonly<Dimensions>, signKeys?: utxolib.BIP32Interface[] | undefined, inputValue?: number);
+    getBuilderWithUnsignedTx(): utxolib.bitgo.UtxoTransactionBuilder;
+    getUnsignedTx(): utxolib.bitgo.UtxoTransaction;
+    getSignedTx(): utxolib.Transaction;
+}
+declare const runCombinations: ({ inputTypes, maxNInputs, outputTypes, maxNOutputs, }: {
+    inputTypes: InputScriptType[];
+    maxNInputs: number;
+    outputTypes: TestUnspentType[];
+    maxNOutputs: number;
+}, callback: (inputCombo: InputScriptType[], outputCombo: TestUnspentType[]) => void) => void;
+declare class Histogram {
+    map: Map<number, number>;
+    total: number;
+    constructor(map?: Map<number, number>);
+    add(size: number): void;
+    asSortedArray(): number[][];
+    asFullSortedArray(): number[][];
+    getPercentile(p: number): number;
+    toString(): string;
+}
+/**
+ *
+ * Calls `callback` with a variety of signed txs, based on input parameters
+ * Callback arguments are
+ *   inputType, inputCount, outputType, txs
+ *  where `txs` implements `forEach()`
+ *
+ * @param inputTypes - input types to test
+ * @param nInputKeyTriplets - number of different input key triples to cycle through
+ * @param outputTypes - output types to test
+ * @param nOutputKeyTriplets - number of different output key triplets to cycle through
+ * @param callback
+ */
+declare const runSignedTransactions: ({ inputTypes, nInputKeyTriplets, outputTypes, nOutputKeyTriplets, }: {
+    inputTypes: Array<{
+        inputType: string;
+        count: number;
+    }>;
+    nInputKeyTriplets: number;
+    outputTypes: TestUnspentType[];
+    nOutputKeyTriplets: number;
+}, callback: (inputType: string, inputCount: number, outputType: TestUnspentType, txs: any) => void) => void;
+export { TxCombo, Histogram, runCombinations, runSignedTransactions };
+//# sourceMappingURL=txGen.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"txGen.d.ts","sourceRoot":"","sources":["../../../test/signedTx/txGen.ts"],"names":[],"mappings":";AAEA,OAAO,KAAK,OAAO,MAAM,sBAAsB,CAAC;AAChD,OAAO,EAAS,cAAc,EAAE,MAAM,sBAAsB,CAAC;AAE7D,OAAO,qBAAqB,CAAC;AAC7B,OAAO,EAAE,UAAU,EAAE,MAAM,WAAW,CAAC;AACvC,OAAO,EACL,eAAe,EACf,eAAe,EAKhB,MAAM,cAAc,CAAC;AAEtB,UAAU,QAAQ;IAChB,YAAY,EAAE,MAAM,CAAC;IACrB,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,KAAK,EAAE,MAAM,CAAC;IACd,SAAS,EAAE,OAAO,CAAC,KAAK,CAAC,aAAa,CAAC,UAAU,CAAC;CACnD;AAoBD;;;;;;GAMG;AACH,eAAO,MAAM,kBAAkB,SAAU,cAAc,EAAE,eAAe,eAAe,KAAG,MAoBzF,CAAC;AAqCF,cAAM,OAAO;IAKF,UAAU,EAAE,cAAc,EAAE;IAC5B,UAAU,EAAE,MAAM,EAAE;IACpB,WAAW,EAAE,eAAe,EAAE;IAC9B,YAAY,EAAE,QAAQ,CAAC,UAAU,CAAC;IAClC,QAAQ,CAAC;IACT,UAAU,EAAE,MAAM;IATpB,QAAQ,EAAE,QAAQ,EAAE,CAAC;IACrB,OAAO,EAAE,GAAG,CAAC;gBAGX,UAAU,EAAE,cAAc,EAAE,EAC5B,UAAU,EAAE,MAAM,EAAE,EACpB,WAAW,EAAE,eAAe,EAAE,EAC9B,YAAY,GAAE,QAAQ,CAAC,UAAU,CAAmB,EACpD,QAAQ,CAAC,sCAAkB,EAC3B,UAAU,GAAE,MAAW;IAYzB,wBAAwB,IAAI,OAAO,CAAC,KAAK,CAAC,sBAAsB;IAShE,aAAa,IAAI,OAAO,CAAC,KAAK,CAAC,eAAe;IAI9C,WAAW,IAAI,OAAO,CAAC,WAAW;CAO1C;AAED,QAAA,MAAM,eAAe;gBAOL,eAAe,EAAE;gBACjB,MAAM;iBACL,eAAe,EAAE;iBACjB,MAAM;0BAEE,eAAe,EAAE,eAAe,eAAe,EAAE,KAAK,IAAI,KAChF,IAgBF,CAAC;AAEF,cAAM,SAAS;IAGM,GAAG,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC;IAFpC,KAAK,SAAK;gBAEE,GAAG,GAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAa;IAEhD,GAAG,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI;IAKvB,aAAa,IAAI,MAAM,EAAE,EAAE;IAI3B,iBAAiB,IAAI,MAAM,EAAE,EAAE;IAI/B,aAAa,CAAC,CAAC,EAAE,MAAM,GAAG,MAAM;IAgBhC,QAAQ,IAAI,MAAM;CAI1B;AAOD;;;;;;;;;;;;GAYG;AACH,QAAA,MAAM,qBAAqB;gBAOX,MAAM;QAAE,SAAS,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,MAAM,CAAA;KAAE,CAAC;uBACpC,MAAM;iBACZ,eAAe,EAAE;wBACV,MAAM;yBAEN,MAAM,cAAc,MAAM,cAAc,eAAe,OAAO,GAAG,KAAK,IAAI,KAC/F,IAyCF,CAAC;AAEF,OAAO,EAAE,OAAO,EAAE,SAAS,EAAE,eAAe,EAAE,qBAAqB,EAAE,CAAC"}

package/dist/test/signedTx/txGen.js

@@ -0,0 +1,219 @@
+"use strict";
+/* eslint-disable @typescript-eslint/ban-ts-comment */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (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 });
+exports.runSignedTransactions = exports.runCombinations = exports.Histogram = exports.TxCombo = exports.createScriptPubKey = void 0;
+const utxolib = __importStar(require("@bitgo-beta/utxo-lib"));
+const utxo_lib_1 = require("@bitgo-beta/utxo-lib");
+const lodash_1 = __importDefault(require("lodash"));
+require("lodash.combinations");
+const src_1 = require("../../src");
+const testutils_1 = require("../testutils");
+function createUnspent(pubkeys, inputType, value) {
+    let spendableScript;
+    const scriptType = inputType === 'taprootKeyPathSpend' ? 'p2trMusig2' : inputType;
+    if (scriptType === testutils_1.UnspentTypeP2shP2pk) {
+        spendableScript = utxolib.bitgo.outputScripts.createOutputScriptP2shP2pk(pubkeys[0]);
+    }
+    else if (utxolib.bitgo.outputScripts.isScriptType2Of3(scriptType)) {
+        spendableScript = utxolib.bitgo.outputScripts.createOutputScript2of3(pubkeys, scriptType);
+    }
+    else {
+        throw new Error(`unexpected inputType ${scriptType}`);
+    }
+    return {
+        ...spendableScript,
+        value,
+        inputType: scriptType,
+    };
+}
+/**
+ *
+ * @param keys - Pubkeys to use for generating the address.
+ *               If unspentType is one of UnspentTypePubKeyHash is used, the first key will be used.
+ * @param unspentType {String} - one of UnspentTypeScript2of3 or UnspentTypePubKeyHash
+ * @return {String} address
+ */
+const createScriptPubKey = (keys, unspentType) => {
+    const pubkeys = keys.map((key) => key.publicKey);
+    if (typeof unspentType === 'string' && unspentType in testutils_1.UnspentTypeScript2of3) {
+        return createUnspent(pubkeys, unspentType, 0).scriptPubKey;
+    }
+    const pkHash = utxolib.crypto.hash160(pubkeys[0]);
+    switch (unspentType) {
+        case testutils_1.UnspentTypePubKeyHash.p2pkh:
+            return utxolib.payments.p2pkh({ hash: pkHash }).output;
+        case testutils_1.UnspentTypePubKeyHash.p2wpkh:
+            return utxolib.payments.p2wpkh({ hash: pkHash }).output;
+    }
+    if (unspentType instanceof testutils_1.UnspentTypeOpReturn) {
+        const payload = Buffer.alloc(unspentType.size).fill(pubkeys[0]);
+        return utxolib.script.compile([0x6a, payload]);
+    }
+    throw new Error(`unsupported output type ${unspentType}`);
+};
+exports.createScriptPubKey = createScriptPubKey;
+const createInputTx = (unspents, inputValue) => {
+    const txInputBuilder = new utxolib.bitgo.UtxoTransactionBuilder(utxolib.networks.bitcoin);
+    txInputBuilder.addInput(Array(32).fill('01').join(''), 0);
+    unspents.forEach(({ scriptPubKey }) => txInputBuilder.addOutput(scriptPubKey, inputValue));
+    return txInputBuilder.buildIncomplete();
+};
+function signInput(txBuilder, index, walletKeys, unspent, signKeys = unspent.inputType === 'p2shP2pk' ? [walletKeys[0]] : [walletKeys[0], walletKeys[2]]) {
+    signKeys.forEach((keyPair) => {
+        if (unspent.inputType === 'p2shP2pk') {
+            utxolib.bitgo.signInputP2shP2pk(txBuilder, index, keyPair);
+        }
+        else {
+            if (signKeys.length !== 2) {
+                throw new Error(`invalid signKeys length`);
+            }
+            const cosigner = keyPair === signKeys[0] ? signKeys[1] : signKeys[0];
+            utxolib.bitgo.signInput2Of3(txBuilder, index, unspent.inputType, walletKeys.map((k) => k.publicKey), keyPair, cosigner.publicKey, unspent.value);
+        }
+    });
+}
+class TxCombo {
+    constructor(walletKeys, inputTypes, outputTypes, expectedDims = src_1.Dimensions.ZERO, signKeys, inputValue = 10) {
+        this.walletKeys = walletKeys;
+        this.inputTypes = inputTypes;
+        this.outputTypes = outputTypes;
+        this.expectedDims = expectedDims;
+        this.signKeys = signKeys;
+        this.inputValue = inputValue;
+        this.unspents = inputTypes.map((inputType) => createUnspent(walletKeys.map((key) => key.publicKey), inputType, this.inputValue));
+        this.inputTx = createInputTx(this.unspents, inputValue);
+    }
+    getBuilderWithUnsignedTx() {
+        const txBuilder = utxolib.bitgo.createTransactionBuilderForNetwork(utxolib.networks.bitcoin);
+        this.inputTx.outs.forEach(({}, i) => txBuilder.addInput(this.inputTx, i));
+        this.outputTypes.forEach((unspentType) => txBuilder.addOutput(exports.createScriptPubKey(this.walletKeys, unspentType), this.inputValue));
+        return txBuilder;
+    }
+    getUnsignedTx() {
+        return this.getBuilderWithUnsignedTx().buildIncomplete();
+    }
+    getSignedTx() {
+        const txBuilder = this.getBuilderWithUnsignedTx();
+        this.unspents.forEach((unspent, i) => {
+            signInput(txBuilder, i, this.walletKeys, unspent, this.signKeys);
+        });
+        return txBuilder.build();
+    }
+}
+exports.TxCombo = TxCombo;
+const runCombinations = ({ inputTypes, maxNInputs, outputTypes, maxNOutputs, }, callback) => {
+    // Create combinations of different input and output types. Length between 1 and 3.
+    const inputCombinations = lodash_1.default.flatten(
+    // @ts-ignore
+    [...Array(maxNInputs)].map((__, i) => lodash_1.default.combinations(inputTypes, i + 1)));
+    const outputCombinations = lodash_1.default.flatten(
+    // @ts-ignore
+    [...Array(maxNOutputs)].map((__, i) => lodash_1.default.combinations(outputTypes, i + 1)));
+    inputCombinations.forEach((inputTypeCombo) => outputCombinations.forEach((outputTypeCombo) => {
+        callback(inputTypeCombo, outputTypeCombo);
+    }));
+};
+exports.runCombinations = runCombinations;
+class Histogram {
+    constructor(map = new Map()) {
+        this.map = map;
+        this.total = 0;
+    }
+    add(size) {
+        this.map.set(size, (this.map.get(size) || 0) + 1);
+        this.total++;
+    }
+    asSortedArray() {
+        return [...this.map.entries()].sort(([a], [b]) => a - b);
+    }
+    asFullSortedArray() {
+        return lodash_1.default.range(this.getPercentile(0), this.getPercentile(1)).map((v) => [v, this.map.get(v) || 0]);
+    }
+    getPercentile(p) {
+        if (0 > p || p > 1) {
+            throw new Error(`p must be between 0 and 1`);
+        }
+        let sum = 0;
+        for (const [k, v] of this.asSortedArray()) {
+            sum += v;
+            if (sum / this.total >= p) {
+                return k;
+            }
+        }
+        throw new Error('could not find percentile');
+    }
+    toString() {
+        const keys = [...this.map.keys()].sort((a, b) => a - b);
+        return `[${keys.map((k) => `[${k}, ${this.map.get(k)}]`).join(' ')}]`;
+    }
+}
+exports.Histogram = Histogram;
+const getKeyTriplets = (prefix, count) => [...Array(count)].map((v, i) => [1, 2, 3].map((j) => utxo_lib_1.bip32.fromSeed(Buffer.alloc(16, `${prefix}/${i}/${j}`), utxolib.networks.bitcoin)));
+/**
+ *
+ * Calls `callback` with a variety of signed txs, based on input parameters
+ * Callback arguments are
+ *   inputType, inputCount, outputType, txs
+ *  where `txs` implements `forEach()`
+ *
+ * @param inputTypes - input types to test
+ * @param nInputKeyTriplets - number of different input key triples to cycle through
+ * @param outputTypes - output types to test
+ * @param nOutputKeyTriplets - number of different output key triplets to cycle through
+ * @param callback
+ */
+const runSignedTransactions = ({ inputTypes, nInputKeyTriplets, outputTypes, nOutputKeyTriplets, }, callback) => {
+    const inputKeyTriplets = getKeyTriplets('test/input/', nInputKeyTriplets);
+    const outputKeyTriplets = getKeyTriplets('test/output/', nOutputKeyTriplets);
+    const outputValue = 1e8;
+    inputTypes.forEach(({ inputType, count: inputCount }) => {
+        const inputTxs = inputKeyTriplets.map((inputKeys) => {
+            const unspents = [...Array(inputCount)].map(() => createUnspent(inputKeys.map((key) => key.publicKey), inputType, outputValue));
+            const inputTx = createInputTx(unspents, outputValue);
+            return { inputKeys, unspents, inputTx };
+        });
+        outputTypes.forEach((outputType) => {
+            const outputs = outputKeyTriplets.map((outputKeys) => exports.createScriptPubKey(outputKeys, outputType));
+            const txs = {
+                forEach(cb) {
+                    inputTxs.forEach(({ inputKeys, unspents, inputTx }) => {
+                        outputs.forEach((scriptPubKey) => {
+                            const txBuilder = utxolib.bitgo.createTransactionBuilderForNetwork(utxolib.networks.bitcoin);
+                            inputTx.outs.forEach((v, i) => txBuilder.addInput(inputTx, i));
+                            txBuilder.addOutput(scriptPubKey, outputValue);
+                            unspents.forEach((unspent, i) => {
+                                signInput(txBuilder, i, inputKeys, unspent);
+                            });
+                            cb(txBuilder.build());
+                        });
+                    });
+                },
+            };
+            callback(inputType, inputCount, outputType, txs);
+        });
+    });
+};
+exports.runSignedTransactions = runSignedTransactions;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"txGen.js","sourceRoot":"","sources":["../../../test/signedTx/txGen.ts"],"names":[],"mappings":"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","sourcesContent":["/* eslint-disable @typescript-eslint/ban-ts-comment */\n\nimport * as utxolib from '@bitgo-beta/utxo-lib';\nimport { bip32, BIP32Interface } from '@bitgo-beta/utxo-lib';\nimport _ from 'lodash';\nimport 'lodash.combinations';\nimport { Dimensions } from '../../src';\nimport {\n  InputScriptType,\n  TestUnspentType,\n  UnspentTypeOpReturn,\n  UnspentTypeP2shP2pk,\n  UnspentTypePubKeyHash,\n  UnspentTypeScript2of3,\n} from '../testutils';\n\ninterface IUnspent {\n  scriptPubKey: Buffer;\n  redeemScript?: Buffer;\n  witnessScript?: Buffer;\n  value: number;\n  inputType: utxolib.bitgo.outputScripts.ScriptType;\n}\n\nfunction createUnspent(pubkeys: Buffer[], inputType: string, value: number): IUnspent {\n  let spendableScript;\n  const scriptType = inputType === 'taprootKeyPathSpend' ? 'p2trMusig2' : inputType;\n  if (scriptType === UnspentTypeP2shP2pk) {\n    spendableScript = utxolib.bitgo.outputScripts.createOutputScriptP2shP2pk(pubkeys[0]);\n  } else if (utxolib.bitgo.outputScripts.isScriptType2Of3(scriptType)) {\n    spendableScript = utxolib.bitgo.outputScripts.createOutputScript2of3(pubkeys, scriptType);\n  } else {\n    throw new Error(`unexpected inputType ${scriptType}`);\n  }\n\n  return {\n    ...spendableScript,\n    value,\n    inputType: scriptType,\n  };\n}\n\n/**\n *\n * @param keys - Pubkeys to use for generating the address.\n *               If unspentType is one of UnspentTypePubKeyHash is used, the first key will be used.\n * @param unspentType {String} - one of UnspentTypeScript2of3 or UnspentTypePubKeyHash\n * @return {String} address\n */\nexport const createScriptPubKey = (keys: BIP32Interface[], unspentType: TestUnspentType): Buffer => {\n  const pubkeys = keys.map((key) => key.publicKey);\n  if (typeof unspentType === 'string' && unspentType in UnspentTypeScript2of3) {\n    return createUnspent(pubkeys, unspentType, 0).scriptPubKey;\n  }\n\n  const pkHash = utxolib.crypto.hash160(pubkeys[0]);\n  switch (unspentType) {\n    case UnspentTypePubKeyHash.p2pkh:\n      return utxolib.payments.p2pkh({ hash: pkHash }).output!;\n    case UnspentTypePubKeyHash.p2wpkh:\n      return utxolib.payments.p2wpkh({ hash: pkHash }).output!;\n  }\n\n  if (unspentType instanceof UnspentTypeOpReturn) {\n    const payload = Buffer.alloc(unspentType.size).fill(pubkeys[0]);\n    return utxolib.script.compile([0x6a, payload]);\n  }\n\n  throw new Error(`unsupported output type ${unspentType}`);\n};\n\nconst createInputTx = (unspents: any[], inputValue: number) => {\n  const txInputBuilder = new utxolib.bitgo.UtxoTransactionBuilder(utxolib.networks.bitcoin);\n  txInputBuilder.addInput(Array(32).fill('01').join(''), 0);\n  unspents.forEach(({ scriptPubKey }) => txInputBuilder.addOutput(scriptPubKey, inputValue));\n  return txInputBuilder.buildIncomplete();\n};\n\nfunction signInput(\n  txBuilder: utxolib.bitgo.UtxoTransactionBuilder,\n  index: number,\n  walletKeys: BIP32Interface[],\n  unspent: IUnspent,\n  signKeys: BIP32Interface[] = unspent.inputType === 'p2shP2pk' ? [walletKeys[0]] : [walletKeys[0], walletKeys[2]]\n) {\n  signKeys.forEach((keyPair) => {\n    if (unspent.inputType === 'p2shP2pk') {\n      utxolib.bitgo.signInputP2shP2pk(txBuilder, index, keyPair);\n    } else {\n      if (signKeys.length !== 2) {\n        throw new Error(`invalid signKeys length`);\n      }\n      const cosigner = keyPair === signKeys[0] ? signKeys[1] : signKeys[0];\n      utxolib.bitgo.signInput2Of3(\n        txBuilder,\n        index,\n        unspent.inputType,\n        walletKeys.map((k) => k.publicKey) as utxolib.bitgo.Triple<Buffer>,\n        keyPair,\n        cosigner.publicKey,\n        unspent.value\n      );\n    }\n  });\n}\n\nclass TxCombo {\n  public unspents: IUnspent[];\n  public inputTx: any;\n\n  constructor(\n    public walletKeys: BIP32Interface[],\n    public inputTypes: string[],\n    public outputTypes: TestUnspentType[],\n    public expectedDims: Readonly<Dimensions> = Dimensions.ZERO,\n    public signKeys?: BIP32Interface[],\n    public inputValue: number = 10\n  ) {\n    this.unspents = inputTypes.map((inputType) =>\n      createUnspent(\n        walletKeys.map((key) => key.publicKey),\n        inputType,\n        this.inputValue\n      )\n    );\n    this.inputTx = createInputTx(this.unspents, inputValue);\n  }\n\n  public getBuilderWithUnsignedTx(): utxolib.bitgo.UtxoTransactionBuilder {\n    const txBuilder = utxolib.bitgo.createTransactionBuilderForNetwork(utxolib.networks.bitcoin);\n    this.inputTx.outs.forEach(({}, i: number) => txBuilder.addInput(this.inputTx, i));\n    this.outputTypes.forEach((unspentType) =>\n      txBuilder.addOutput(createScriptPubKey(this.walletKeys, unspentType), this.inputValue)\n    );\n    return txBuilder;\n  }\n\n  public getUnsignedTx(): utxolib.bitgo.UtxoTransaction {\n    return this.getBuilderWithUnsignedTx().buildIncomplete();\n  }\n\n  public getSignedTx(): utxolib.Transaction {\n    const txBuilder = this.getBuilderWithUnsignedTx();\n    this.unspents.forEach((unspent, i) => {\n      signInput(txBuilder, i, this.walletKeys, unspent, this.signKeys);\n    });\n    return txBuilder.build();\n  }\n}\n\nconst runCombinations = (\n  {\n    inputTypes,\n    maxNInputs,\n    outputTypes,\n    maxNOutputs,\n  }: {\n    inputTypes: InputScriptType[];\n    maxNInputs: number;\n    outputTypes: TestUnspentType[];\n    maxNOutputs: number;\n  },\n  callback: (inputCombo: InputScriptType[], outputCombo: TestUnspentType[]) => void\n): void => {\n  // Create combinations of different input and output types. Length between 1 and 3.\n  const inputCombinations = _.flatten(\n    // @ts-ignore\n    [...Array(maxNInputs)].map((__, i) => _.combinations(inputTypes, i + 1))\n  );\n  const outputCombinations = _.flatten(\n    // @ts-ignore\n    [...Array(maxNOutputs)].map((__, i) => _.combinations(outputTypes, i + 1))\n  );\n\n  inputCombinations.forEach((inputTypeCombo) =>\n    outputCombinations.forEach((outputTypeCombo) => {\n      callback(inputTypeCombo, outputTypeCombo);\n    })\n  );\n};\n\nclass Histogram {\n  public total = 0;\n\n  constructor(public map: Map<number, number> = new Map()) {}\n\n  public add(size: number): void {\n    this.map.set(size, (this.map.get(size) || 0) + 1);\n    this.total++;\n  }\n\n  public asSortedArray(): number[][] {\n    return [...this.map.entries()].sort(([a], [b]) => a - b);\n  }\n\n  public asFullSortedArray(): number[][] {\n    return _.range(this.getPercentile(0), this.getPercentile(1)).map((v) => [v, this.map.get(v) || 0]);\n  }\n\n  public getPercentile(p: number): number {\n    if (0 > p || p > 1) {\n      throw new Error(`p must be between 0 and 1`);\n    }\n\n    let sum = 0;\n    for (const [k, v] of this.asSortedArray()) {\n      sum += v;\n      if (sum / this.total >= p) {\n        return k;\n      }\n    }\n\n    throw new Error('could not find percentile');\n  }\n\n  public toString(): string {\n    const keys = [...this.map.keys()].sort((a, b) => a - b);\n    return `[${keys.map((k) => `[${k}, ${this.map.get(k)}]`).join(' ')}]`;\n  }\n}\n\nconst getKeyTriplets = (prefix: string, count: number) =>\n  [...Array(count)].map((v, i) =>\n    [1, 2, 3].map((j) => bip32.fromSeed(Buffer.alloc(16, `${prefix}/${i}/${j}`), utxolib.networks.bitcoin))\n  );\n\n/**\n *\n * Calls `callback` with a variety of signed txs, based on input parameters\n * Callback arguments are\n *   inputType, inputCount, outputType, txs\n *  where `txs` implements `forEach()`\n *\n * @param inputTypes - input types to test\n * @param nInputKeyTriplets - number of different input key triples to cycle through\n * @param outputTypes - output types to test\n * @param nOutputKeyTriplets - number of different output key triplets to cycle through\n * @param callback\n */\nconst runSignedTransactions = (\n  {\n    inputTypes,\n    nInputKeyTriplets,\n    outputTypes,\n    nOutputKeyTriplets,\n  }: {\n    inputTypes: Array<{ inputType: string; count: number }>;\n    nInputKeyTriplets: number;\n    outputTypes: TestUnspentType[];\n    nOutputKeyTriplets: number;\n  },\n  callback: (inputType: string, inputCount: number, outputType: TestUnspentType, txs: any) => void\n): void => {\n  const inputKeyTriplets = getKeyTriplets('test/input/', nInputKeyTriplets);\n  const outputKeyTriplets = getKeyTriplets('test/output/', nOutputKeyTriplets);\n  const outputValue = 1e8;\n\n  inputTypes.forEach(({ inputType, count: inputCount }) => {\n    const inputTxs = inputKeyTriplets.map((inputKeys) => {\n      const unspents = [...Array(inputCount)].map(() =>\n        createUnspent(\n          inputKeys.map((key) => key.publicKey),\n          inputType,\n          outputValue\n        )\n      );\n      const inputTx = createInputTx(unspents, outputValue);\n      return { inputKeys, unspents, inputTx };\n    });\n\n    outputTypes.forEach((outputType) => {\n      const outputs = outputKeyTriplets.map((outputKeys) => createScriptPubKey(outputKeys, outputType));\n\n      const txs = {\n        forEach(cb: (tx: utxolib.Transaction) => void) {\n          inputTxs.forEach(({ inputKeys, unspents, inputTx }) => {\n            outputs.forEach((scriptPubKey) => {\n              const txBuilder = utxolib.bitgo.createTransactionBuilderForNetwork(utxolib.networks.bitcoin);\n              inputTx.outs.forEach((v: any, i: number) => txBuilder.addInput(inputTx, i));\n              txBuilder.addOutput(scriptPubKey, outputValue);\n              unspents.forEach((unspent, i) => {\n                signInput(txBuilder, i, inputKeys, unspent);\n              });\n\n              cb(txBuilder.build());\n            });\n          });\n        },\n      };\n\n      callback(inputType, inputCount, outputType, txs);\n    });\n  });\n};\n\nexport { TxCombo, Histogram, runCombinations, runSignedTransactions };\n"]}

package/dist/test/testutils.d.ts

@@ -0,0 +1,36 @@
+import * as unspents from '../src';
+import * as utxolib from '@bitgo-beta/utxo-lib';
+export declare const UnspentTypeP2shP2pk = "p2shP2pk";
+export declare const UnspentTypeScript2of3: {
+    p2sh: string;
+    p2shP2wsh: string;
+    p2wsh: string;
+    p2tr: string;
+    p2trMusig2: string;
+    taprootKeyPathSpend: string;
+};
+export declare const UnspentTypePubKeyHash: {
+    p2pkh: 'p2pkh';
+    p2wpkh: 'p2wpkh';
+};
+export declare type TestUnspentType = string | UnspentTypeOpReturn;
+export declare class UnspentTypeOpReturn {
+    size: number;
+    constructor(size: number);
+    toString(): string;
+}
+export declare type InputScriptType = utxolib.bitgo.outputScripts.ScriptType | 'taprootKeyPathSpend';
+export declare function getInputScriptTypes(): InputScriptType[];
+/**
+ * Return the input dimensions based on unspent type
+ * @param unspentType - one of UnspentTypeScript2of3
+ * @return Dimensions
+ */
+export declare const getInputDimensionsForUnspentType: (unspentType: TestUnspentType) => unspents.Dimensions;
+export declare const getOutputDimensionsForUnspentType: (unspentType: TestUnspentType) => unspents.Dimensions;
+export declare function constructPsbt(keys: utxolib.bitgo.RootWalletKeys, inputTypes: InputScriptType[], outputTypes: TestUnspentType[], signatureStatus: 'unsigned' | 'halfsigned' | 'fullysigned', signers?: {
+    signerName: utxolib.bitgo.KeyName;
+    cosignerName: utxolib.bitgo.KeyName;
+}): utxolib.bitgo.UtxoPsbt<utxolib.bitgo.UtxoTransaction<bigint>>;
+export declare function getSignedTransaction(keys: utxolib.bitgo.RootWalletKeys, signerName: utxolib.bitgo.KeyName, cosignerName: utxolib.bitgo.KeyName, inputTypes: InputScriptType[], outputTypes: TestUnspentType[]): utxolib.bitgo.UtxoTransaction;
+//# sourceMappingURL=testutils.d.ts.map

package/dist/test/testutils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"testutils.d.ts","sourceRoot":"","sources":["../../test/testutils.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,QAAQ,MAAM,QAAQ,CAAC;AACnC,OAAO,KAAK,OAAO,MAAM,sBAAsB,CAAC;AAYhD,eAAO,MAAM,mBAAmB,aAAa,CAAC;AAG9C,eAAO,MAAM,qBAAqB,EAAE;IAClC,IAAI,EAAE,MAAM,CAAC;IACb,SAAS,EAAE,MAAM,CAAC;IAClB,KAAK,EAAE,MAAM,CAAC;IACd,IAAI,EAAE,MAAM,CAAC;IACb,UAAU,EAAE,MAAM,CAAC;IACnB,mBAAmB,EAAE,MAAM,CAAC;CACyD,CAAC;AAExF,eAAO,MAAM,qBAAqB,EAAE;IAClC,KAAK,EAAE,OAAO,CAAC;IACf,MAAM,EAAE,QAAQ,CAAC;CACY,CAAC;AAEhC,oBAAY,eAAe,GAAG,MAAM,GAAG,mBAAmB,CAAC;AAE3D,qBAAa,mBAAmB;IACX,IAAI,EAAE,MAAM;gBAAZ,IAAI,EAAE,MAAM;IAExB,QAAQ,IAAI,MAAM;CAG1B;AAED,oBAAY,eAAe,GAAG,OAAO,CAAC,KAAK,CAAC,aAAa,CAAC,UAAU,GAAG,qBAAqB,CAAC;AAE7F,wBAAgB,mBAAmB,IAAI,eAAe,EAAE,CAEvD;AAED;;;;GAIG;AACH,eAAO,MAAM,gCAAgC,gBAAiB,eAAe,KAAG,SAAS,UAiBxF,CAAC;AAEF,eAAO,MAAM,iCAAiC,gBAAiB,eAAe,KAAG,SAAS,UAuBzF,CAAC;AAkBF,wBAAgB,aAAa,CAC3B,IAAI,EAAE,OAAO,CAAC,KAAK,CAAC,cAAc,EAClC,UAAU,EAAE,eAAe,EAAE,EAC7B,WAAW,EAAE,eAAe,EAAE,EAC9B,eAAe,EAAE,UAAU,GAAG,YAAY,GAAG,aAAa,EAC1D,OAAO,CAAC,EAAE;IAAE,UAAU,EAAE,OAAO,CAAC,KAAK,CAAC,OAAO,CAAC;IAAC,YAAY,EAAE,OAAO,CAAC,KAAK,CAAC,OAAO,CAAA;CAAE,GACnF,OAAO,CAAC,KAAK,CAAC,QAAQ,CAAC,OAAO,CAAC,KAAK,CAAC,eAAe,CAAC,MAAM,CAAC,CAAC,CAwD/D;AAED,wBAAgB,oBAAoB,CAClC,IAAI,EAAE,OAAO,CAAC,KAAK,CAAC,cAAc,EAClC,UAAU,EAAE,OAAO,CAAC,KAAK,CAAC,OAAO,EACjC,YAAY,EAAE,OAAO,CAAC,KAAK,CAAC,OAAO,EACnC,UAAU,EAAE,eAAe,EAAE,EAC7B,WAAW,EAAE,eAAe,EAAE,GAC7B,OAAO,CAAC,KAAK,CAAC,eAAe,CAI/B"}

package/dist/test/testutils.js

@@ -0,0 +1,176 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (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 });
+exports.getSignedTransaction = exports.constructPsbt = exports.getOutputDimensionsForUnspentType = exports.getInputDimensionsForUnspentType = exports.getInputScriptTypes = exports.UnspentTypeOpReturn = exports.UnspentTypePubKeyHash = exports.UnspentTypeScript2of3 = exports.UnspentTypeP2shP2pk = void 0;
+const unspents = __importStar(require("../src"));
+const utxolib = __importStar(require("@bitgo-beta/utxo-lib"));
+const assert_1 = __importDefault(require("assert"));
+const txGen_1 = require("./signedTx/txGen");
+/**
+ * makeEnum('a', 'b') returns `{ a: 'a', b: 'b' }`
+ *
+ * @param args
+ * @return map with string keys and symbol values
+ */
+const makeEnum = (...args) => args.reduce((obj, key) => Object.assign(obj, { [key]: key }), {});
+exports.UnspentTypeP2shP2pk = 'p2shP2pk';
+// p2trMusig2 is assumed to be script path only. taprootKeyPathSpend is for p2trMusig2 key path
+exports.UnspentTypeScript2of3 = makeEnum('p2sh', 'p2shP2wsh', 'p2wsh', 'p2tr', 'p2trMusig2', 'taprootKeyPathSpend');
+exports.UnspentTypePubKeyHash = makeEnum('p2pkh', 'p2wpkh');
+class UnspentTypeOpReturn {
+    constructor(size) {
+        this.size = size;
+    }
+    toString() {
+        return `opReturn(${this.size})`;
+    }
+}
+exports.UnspentTypeOpReturn = UnspentTypeOpReturn;
+function getInputScriptTypes() {
+    return [...utxolib.bitgo.outputScripts.scriptTypes2Of3, 'p2shP2pk', 'taprootKeyPathSpend'];
+}
+exports.getInputScriptTypes = getInputScriptTypes;
+/**
+ * Return the input dimensions based on unspent type
+ * @param unspentType - one of UnspentTypeScript2of3
+ * @return Dimensions
+ */
+const getInputDimensionsForUnspentType = (unspentType) => {
+    switch (unspentType) {
+        case exports.UnspentTypeScript2of3.p2sh:
+            return unspents.Dimensions.sum({ nP2shInputs: 1 });
+        case exports.UnspentTypeScript2of3.p2shP2wsh:
+            return unspents.Dimensions.sum({ nP2shP2wshInputs: 1 });
+        case exports.UnspentTypeScript2of3.p2wsh:
+            return unspents.Dimensions.sum({ nP2wshInputs: 1 });
+        case exports.UnspentTypeScript2of3.p2tr:
+        case exports.UnspentTypeScript2of3.p2trMusig2:
+            return unspents.Dimensions.sum({ nP2trScriptPathLevel1Inputs: 1 });
+        case exports.UnspentTypeScript2of3.taprootKeyPathSpend:
+            return unspents.Dimensions.sum({ nP2trKeypathInputs: 1 });
+        case exports.UnspentTypeP2shP2pk:
+            return unspents.Dimensions.sum({ nP2shP2pkInputs: 1 });
+    }
+    throw new Error(`no input dimensions for ${unspentType}`);
+};
+exports.getInputDimensionsForUnspentType = getInputDimensionsForUnspentType;
+const getOutputDimensionsForUnspentType = (unspentType) => {
+    /* The values here are validated in the test 'calculates output dimensions dynamically' */
+    switch (unspentType) {
+        case exports.UnspentTypeScript2of3.p2sh:
+        case exports.UnspentTypeScript2of3.p2shP2wsh:
+        case exports.UnspentTypeP2shP2pk:
+            return unspents.Dimensions.fromOutputScriptLength(23);
+        case exports.UnspentTypeScript2of3.p2wsh:
+            return unspents.Dimensions.fromOutputScriptLength(34);
+        case exports.UnspentTypeScript2of3.p2tr:
+        case exports.UnspentTypeScript2of3.p2trMusig2:
+        case exports.UnspentTypeScript2of3.taprootKeyPathSpend:
+            return unspents.Dimensions.fromOutputScriptLength(34);
+        case exports.UnspentTypePubKeyHash.p2pkh:
+            return unspents.Dimensions.fromOutputScriptLength(25);
+        case exports.UnspentTypePubKeyHash.p2wpkh:
+            return unspents.Dimensions.fromOutputScriptLength(22);
+        default:
+            if (unspentType instanceof UnspentTypeOpReturn) {
+                return unspents.Dimensions.fromOutputScriptLength(1 + unspentType.size);
+            }
+            throw new TypeError(`unknown unspentType ${unspentType}`);
+    }
+};
+exports.getOutputDimensionsForUnspentType = getOutputDimensionsForUnspentType;
+function getDefaultSignerNames(inputType, signers) {
+    if (signers) {
+        return [signers.signerName, signers.cosignerName];
+    }
+    if (inputType === 'p2shP2pk') {
+        return ['user'];
+    }
+    if (inputType === 'p2trMusig2') {
+        return ['user', 'backup'];
+    }
+    return ['user', 'bitgo'];
+}
+function constructPsbt(keys, inputTypes, outputTypes, signatureStatus, signers) {
+    const psbt = utxolib.bitgo.createPsbtForNetwork({ network: utxolib.networks.bitcoin });
+    inputTypes.forEach((t, i) => {
+        if (t === 'p2shP2pk') {
+            const signer = keys[getDefaultSignerNames(t, signers)[0]];
+            const unspent = utxolib.testutil.mockReplayProtectionUnspent(utxolib.networks.bitcoin, BigInt(10), {
+                key: signer,
+                vout: i,
+            });
+            const { redeemScript } = utxolib.bitgo.outputScripts.createOutputScriptP2shP2pk(signer.publicKey);
+            assert_1.default.ok(redeemScript);
+            utxolib.bitgo.addReplayProtectionUnspentToPsbt(psbt, unspent, redeemScript);
+        }
+        else {
+            const unspent = utxolib.testutil.mockWalletUnspent(utxolib.networks.bitcoin, BigInt(10), {
+                keys,
+                chain: utxolib.bitgo.getExternalChainCode(t === 'taprootKeyPathSpend' ? 'p2trMusig2' : t),
+                vout: i,
+                index: i,
+            });
+            const signerNames = getDefaultSignerNames(t, signers);
+            utxolib.bitgo.addWalletUnspentToPsbt(psbt, unspent, keys, signerNames[0], signerNames[1]);
+        }
+    });
+    outputTypes.forEach((t, index) => {
+        psbt.addOutput({
+            script: txGen_1.createScriptPubKey(keys.triple, t),
+            value: BigInt(10),
+        });
+    });
+    if (signatureStatus === 'unsigned') {
+        return psbt;
+    }
+    psbt.setAllInputsMusig2NonceHD(keys['user']);
+    psbt.setAllInputsMusig2NonceHD(keys['bitgo']);
+    inputTypes.forEach((t, i) => {
+        const signerNames = getDefaultSignerNames(t, signers);
+        if (t === 'p2shP2pk') {
+            if (signatureStatus === 'fullysigned') {
+                psbt.signInput(i, keys[signerNames[0]]);
+            }
+        }
+        else {
+            psbt.signInputHD(i, keys[signerNames[0]]);
+            if (signatureStatus === 'fullysigned') {
+                psbt.signInputHD(i, keys[signerNames[1]]);
+            }
+        }
+    });
+    if (signatureStatus === 'fullysigned') {
+        assert_1.default.ok(psbt.validateSignaturesOfAllInputs());
+    }
+    return psbt;
+}
+exports.constructPsbt = constructPsbt;
+function getSignedTransaction(keys, signerName, cosignerName, inputTypes, outputTypes) {
+    const psbt = constructPsbt(keys, inputTypes, outputTypes, 'fullysigned', { signerName, cosignerName });
+    psbt.finalizeAllInputs();
+    return psbt.extractTransaction().clone('number');
+}
+exports.getSignedTransaction = getSignedTransaction;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"testutils.js","sourceRoot":"","sources":["../../test/testutils.ts"],"names":[],"mappings":"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","sourcesContent":["import * as unspents from '../src';\nimport * as utxolib from '@bitgo-beta/utxo-lib';\nimport assert from 'assert';\nimport { createScriptPubKey } from './signedTx/txGen';\n\n/**\n * makeEnum('a', 'b') returns `{ a: 'a', b: 'b' }`\n *\n * @param args\n * @return map with string keys and symbol values\n */\nconst makeEnum = (...args: string[]): any => args.reduce((obj, key) => Object.assign(obj, { [key]: key }), {});\n\nexport const UnspentTypeP2shP2pk = 'p2shP2pk';\n\n// p2trMusig2 is assumed to be script path only. taprootKeyPathSpend is for p2trMusig2 key path\nexport const UnspentTypeScript2of3: {\n  p2sh: string;\n  p2shP2wsh: string;\n  p2wsh: string;\n  p2tr: string;\n  p2trMusig2: string;\n  taprootKeyPathSpend: string;\n} = makeEnum('p2sh', 'p2shP2wsh', 'p2wsh', 'p2tr', 'p2trMusig2', 'taprootKeyPathSpend');\n\nexport const UnspentTypePubKeyHash: {\n  p2pkh: 'p2pkh';\n  p2wpkh: 'p2wpkh';\n} = makeEnum('p2pkh', 'p2wpkh');\n\nexport type TestUnspentType = string | UnspentTypeOpReturn;\n\nexport class UnspentTypeOpReturn {\n  constructor(public size: number) {}\n\n  public toString(): string {\n    return `opReturn(${this.size})`;\n  }\n}\n\nexport type InputScriptType = utxolib.bitgo.outputScripts.ScriptType | 'taprootKeyPathSpend';\n\nexport function getInputScriptTypes(): InputScriptType[] {\n  return [...utxolib.bitgo.outputScripts.scriptTypes2Of3, 'p2shP2pk', 'taprootKeyPathSpend'];\n}\n\n/**\n * Return the input dimensions based on unspent type\n * @param unspentType - one of UnspentTypeScript2of3\n * @return Dimensions\n */\nexport const getInputDimensionsForUnspentType = (unspentType: TestUnspentType): unspents.Dimensions => {\n  switch (unspentType) {\n    case UnspentTypeScript2of3.p2sh:\n      return unspents.Dimensions.sum({ nP2shInputs: 1 });\n    case UnspentTypeScript2of3.p2shP2wsh:\n      return unspents.Dimensions.sum({ nP2shP2wshInputs: 1 });\n    case UnspentTypeScript2of3.p2wsh:\n      return unspents.Dimensions.sum({ nP2wshInputs: 1 });\n    case UnspentTypeScript2of3.p2tr:\n    case UnspentTypeScript2of3.p2trMusig2:\n      return unspents.Dimensions.sum({ nP2trScriptPathLevel1Inputs: 1 });\n    case UnspentTypeScript2of3.taprootKeyPathSpend:\n      return unspents.Dimensions.sum({ nP2trKeypathInputs: 1 });\n    case UnspentTypeP2shP2pk:\n      return unspents.Dimensions.sum({ nP2shP2pkInputs: 1 });\n  }\n  throw new Error(`no input dimensions for ${unspentType}`);\n};\n\nexport const getOutputDimensionsForUnspentType = (unspentType: TestUnspentType): unspents.Dimensions => {\n  /* The values here are validated in the test 'calculates output dimensions dynamically' */\n  switch (unspentType) {\n    case UnspentTypeScript2of3.p2sh:\n    case UnspentTypeScript2of3.p2shP2wsh:\n    case UnspentTypeP2shP2pk:\n      return unspents.Dimensions.fromOutputScriptLength(23);\n    case UnspentTypeScript2of3.p2wsh:\n      return unspents.Dimensions.fromOutputScriptLength(34);\n    case UnspentTypeScript2of3.p2tr:\n    case UnspentTypeScript2of3.p2trMusig2:\n    case UnspentTypeScript2of3.taprootKeyPathSpend:\n      return unspents.Dimensions.fromOutputScriptLength(34);\n    case UnspentTypePubKeyHash.p2pkh:\n      return unspents.Dimensions.fromOutputScriptLength(25);\n    case UnspentTypePubKeyHash.p2wpkh:\n      return unspents.Dimensions.fromOutputScriptLength(22);\n    default:\n      if (unspentType instanceof UnspentTypeOpReturn) {\n        return unspents.Dimensions.fromOutputScriptLength(1 + unspentType.size);\n      }\n      throw new TypeError(`unknown unspentType ${unspentType}`);\n  }\n};\n\nfunction getDefaultSignerNames(\n  inputType: InputScriptType,\n  signers?: { signerName: utxolib.bitgo.KeyName; cosignerName: utxolib.bitgo.KeyName }\n): utxolib.bitgo.KeyName[] {\n  if (signers) {\n    return [signers.signerName, signers.cosignerName];\n  }\n  if (inputType === 'p2shP2pk') {\n    return ['user'];\n  }\n  if (inputType === 'p2trMusig2') {\n    return ['user', 'backup'];\n  }\n  return ['user', 'bitgo'];\n}\n\nexport function constructPsbt(\n  keys: utxolib.bitgo.RootWalletKeys,\n  inputTypes: InputScriptType[],\n  outputTypes: TestUnspentType[],\n  signatureStatus: 'unsigned' | 'halfsigned' | 'fullysigned',\n  signers?: { signerName: utxolib.bitgo.KeyName; cosignerName: utxolib.bitgo.KeyName }\n): utxolib.bitgo.UtxoPsbt<utxolib.bitgo.UtxoTransaction<bigint>> {\n  const psbt = utxolib.bitgo.createPsbtForNetwork({ network: utxolib.networks.bitcoin });\n\n  inputTypes.forEach((t, i) => {\n    if (t === 'p2shP2pk') {\n      const signer = keys[getDefaultSignerNames(t, signers)[0]];\n      const unspent = utxolib.testutil.mockReplayProtectionUnspent(utxolib.networks.bitcoin, BigInt(10), {\n        key: signer,\n        vout: i,\n      });\n      const { redeemScript } = utxolib.bitgo.outputScripts.createOutputScriptP2shP2pk(signer.publicKey);\n      assert.ok(redeemScript);\n      utxolib.bitgo.addReplayProtectionUnspentToPsbt(psbt, unspent, redeemScript);\n    } else {\n      const unspent = utxolib.testutil.mockWalletUnspent(utxolib.networks.bitcoin, BigInt(10), {\n        keys,\n        chain: utxolib.bitgo.getExternalChainCode(t === 'taprootKeyPathSpend' ? 'p2trMusig2' : t),\n        vout: i,\n        index: i,\n      });\n      const signerNames = getDefaultSignerNames(t, signers);\n      utxolib.bitgo.addWalletUnspentToPsbt(psbt, unspent, keys, signerNames[0], signerNames[1]);\n    }\n  });\n\n  outputTypes.forEach((t, index) => {\n    psbt.addOutput({\n      script: createScriptPubKey(keys.triple, t),\n      value: BigInt(10),\n    });\n  });\n\n  if (signatureStatus === 'unsigned') {\n    return psbt;\n  }\n\n  psbt.setAllInputsMusig2NonceHD(keys['user']);\n  psbt.setAllInputsMusig2NonceHD(keys['bitgo']);\n\n  inputTypes.forEach((t, i) => {\n    const signerNames = getDefaultSignerNames(t, signers);\n    if (t === 'p2shP2pk') {\n      if (signatureStatus === 'fullysigned') {\n        psbt.signInput(i, keys[signerNames[0]]);\n      }\n    } else {\n      psbt.signInputHD(i, keys[signerNames[0]]);\n      if (signatureStatus === 'fullysigned') {\n        psbt.signInputHD(i, keys[signerNames[1]]);\n      }\n    }\n  });\n  if (signatureStatus === 'fullysigned') {\n    assert.ok(psbt.validateSignaturesOfAllInputs());\n  }\n  return psbt;\n}\n\nexport function getSignedTransaction(\n  keys: utxolib.bitgo.RootWalletKeys,\n  signerName: utxolib.bitgo.KeyName,\n  cosignerName: utxolib.bitgo.KeyName,\n  inputTypes: InputScriptType[],\n  outputTypes: TestUnspentType[]\n): utxolib.bitgo.UtxoTransaction {\n  const psbt = constructPsbt(keys, inputTypes, outputTypes, 'fullysigned', { signerName, cosignerName });\n  psbt.finalizeAllInputs();\n  return (psbt.extractTransaction() as utxolib.bitgo.UtxoTransaction<bigint>).clone<number>('number');\n}\n"]}

package/dist/test/virtualSizes.d.ts

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

package/dist/test/virtualSizes.d.ts.map

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

package/dist/test/virtualSizes.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const src_1 = require("../src");
+describe('VirtualSizes', function () {
+    it('have expected values', function () {
+        src_1.VirtualSizes.should.match({
+            // check computed values only
+            txP2shInputSize: 298,
+            txP2shP2wshInputSize: 140,
+            txP2wshInputSize: 105,
+            txP2trKeypathInputSize: 58,
+            txP2trScriptPathLevel1InputSize: 108,
+            txP2trScriptPathLevel2InputSize: 116,
+            txP2shP2pkInputSize: 151,
+        });
+    });
+});
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidmlydHVhbFNpemVzLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vdGVzdC92aXJ0dWFsU2l6ZXMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7QUFBQSxnQ0FBc0M7QUFFdEMsUUFBUSxDQUFDLGNBQWMsRUFBRTtJQUN2QixFQUFFLENBQUMsc0JBQXNCLEVBQUU7UUFDekIsa0JBQVksQ0FBQyxNQUFNLENBQUMsS0FBSyxDQUFDO1lBQ3hCLDZCQUE2QjtZQUM3QixlQUFlLEVBQUUsR0FBRztZQUNwQixvQkFBb0IsRUFBRSxHQUFHO1lBQ3pCLGdCQUFnQixFQUFFLEdBQUc7WUFDckIsc0JBQXNCLEVBQUUsRUFBRTtZQUMxQiwrQkFBK0IsRUFBRSxHQUFHO1lBQ3BDLCtCQUErQixFQUFFLEdBQUc7WUFDcEMsbUJBQW1CLEVBQUUsR0FBRztTQUN6QixDQUFDLENBQUM7SUFDTCxDQUFDLENBQUMsQ0FBQztBQUNMLENBQUMsQ0FBQyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgVmlydHVhbFNpemVzIH0gZnJvbSAnLi4vc3JjJztcblxuZGVzY3JpYmUoJ1ZpcnR1YWxTaXplcycsIGZ1bmN0aW9uICgpIHtcbiAgaXQoJ2hhdmUgZXhwZWN0ZWQgdmFsdWVzJywgZnVuY3Rpb24gKCkge1xuICAgIFZpcnR1YWxTaXplcy5zaG91bGQubWF0Y2goe1xuICAgICAgLy8gY2hlY2sgY29tcHV0ZWQgdmFsdWVzIG9ubHlcbiAgICAgIHR4UDJzaElucHV0U2l6ZTogMjk4LFxuICAgICAgdHhQMnNoUDJ3c2hJbnB1dFNpemU6IDE0MCxcbiAgICAgIHR4UDJ3c2hJbnB1dFNpemU6IDEwNSxcbiAgICAgIHR4UDJ0cktleXBhdGhJbnB1dFNpemU6IDU4LFxuICAgICAgdHhQMnRyU2NyaXB0UGF0aExldmVsMUlucHV0U2l6ZTogMTA4LFxuICAgICAgdHhQMnRyU2NyaXB0UGF0aExldmVsMklucHV0U2l6ZTogMTE2LFxuICAgICAgdHhQMnNoUDJwa0lucHV0U2l6ZTogMTUxLFxuICAgIH0pO1xuICB9KTtcbn0pO1xuIl19