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

package/dist/src/inputWeights.js

@@ -0,0 +1,97 @@
+"use strict";
+/**
+ * Defines input sizes for BitGo signature scripts.
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.inputComponentsP2shP2pk = exports.inputComponentsP2trScriptSpendLevel2 = exports.inputComponentsP2trScriptSpendLevel1 = exports.inputComponentsP2trKeySpend = exports.inputComponentsP2wsh = exports.inputComponentsP2shP2wsh = exports.inputComponentsP2sh = void 0;
+exports.varSliceSize = varSliceSize;
+exports.getInputByteLength = getInputByteLength;
+exports.getInputWeight = getInputWeight;
+exports.getInputComponentsWeight = getInputComponentsWeight;
+const varuint_bitcoin_1 = __importDefault(require("varuint-bitcoin"));
+function varSliceSize(someScript) {
+    const length = someScript.length;
+    return varuint_bitcoin_1.default.encodingLength(length) + length;
+}
+function vectorSize(someVector) {
+    const length = someVector.length;
+    return (varuint_bitcoin_1.default.encodingLength(length) +
+        someVector.reduce((sum, witness) => {
+            return sum + varSliceSize(witness);
+        }, 0));
+}
+function getInputByteLength(input, allowWitness) {
+    return (40 /* inputId(32), index(4), nSequence(4) */ +
+        varSliceSize(input.script) +
+        (allowWitness ? vectorSize(input.witness) : 0));
+}
+function getInputWeight(input) {
+    return 3 * getInputByteLength(input, false) + getInputByteLength(input, true);
+}
+function getInputComponentsWeight(c) {
+    const scriptSize = c.script.reduce((a, b) => a + b, 0);
+    return getInputWeight({
+        script: { length: scriptSize },
+        witness: c.witness.map((v) => ({ length: v })),
+    });
+}
+const opSize = 1;
+const op0Size = opSize;
+const opPushSize = opSize;
+const opCheckSigVerifySize = opSize;
+const opCheckSigSize = opSize;
+const ecdsaSignatureSize = 72;
+const schnorrPubkeySize = 32;
+const schnorrSignatureNoSighashSize = 64;
+const p2msPubScriptSize = 105; // Note: This is valid for a compressed public key only
+const p2wshPubScriptSize = 34;
+const p2pkPubScriptSize = 35;
+function p2trScriptSpend(level) {
+    return [
+        schnorrSignatureNoSighashSize,
+        schnorrSignatureNoSighashSize,
+        opPushSize + schnorrPubkeySize + opCheckSigSize + opPushSize + schnorrPubkeySize + opCheckSigVerifySize,
+        /* header byte */ 1 + /* inner key */ 32 + /* inner leaf */ 32 * level,
+    ];
+}
+function p2msSigScriptSize(witness) {
+    return [
+        witness ? 0 : op0Size,
+        (witness ? 0 : opPushSize) + ecdsaSignatureSize,
+        (witness ? 0 : opPushSize) + ecdsaSignatureSize,
+        (witness ? 0 : /* OP_PUSHDATA2 */ opPushSize + 1) + p2msPubScriptSize,
+    ];
+}
+exports.inputComponentsP2sh = {
+    script: p2msSigScriptSize(false),
+    witness: [],
+};
+exports.inputComponentsP2shP2wsh = {
+    script: [opSize + p2wshPubScriptSize],
+    witness: p2msSigScriptSize(true),
+};
+exports.inputComponentsP2wsh = {
+    script: [],
+    witness: p2msSigScriptSize(true),
+};
+// See: https://murchandamus.medium.com/2-of-3-multisig-inputs-using-pay-to-taproot-d5faf2312ba3
+exports.inputComponentsP2trKeySpend = {
+    script: [],
+    witness: [schnorrSignatureNoSighashSize],
+};
+exports.inputComponentsP2trScriptSpendLevel1 = {
+    script: [],
+    witness: p2trScriptSpend(1),
+};
+exports.inputComponentsP2trScriptSpendLevel2 = {
+    script: [],
+    witness: p2trScriptSpend(2),
+};
+exports.inputComponentsP2shP2pk = {
+    script: [opPushSize + ecdsaSignatureSize, opPushSize + p2pkPubScriptSize],
+    witness: [],
+};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"inputWeights.js","sourceRoot":"","sources":["../../src/inputWeights.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Defines input sizes for BitGo signature scripts.\n */\n\nimport varuint from 'varuint-bitcoin';\n\nexport function varSliceSize(someScript: Sized): number {\n  const length = someScript.length;\n\n  return varuint.encodingLength(length) + length;\n}\n\nfunction vectorSize(someVector: Sized[]): number {\n  const length = someVector.length;\n\n  return (\n    varuint.encodingLength(length) +\n    someVector.reduce((sum, witness) => {\n      return sum + varSliceSize(witness);\n    }, 0)\n  );\n}\n\nexport type Sized = {\n  length: number;\n};\n\nexport type Input = {\n  script: Sized;\n  witness: Sized[];\n};\n\nexport function getInputByteLength(input: Input, allowWitness: boolean): number {\n  return (\n    40 /* inputId(32), index(4), nSequence(4) */ +\n    varSliceSize(input.script) +\n    (allowWitness ? vectorSize(input.witness) : 0)\n  );\n}\n\nexport function getInputWeight(input: Input): number {\n  return 3 * getInputByteLength(input, false) + getInputByteLength(input, true);\n}\n\nexport type InputComponents = {\n  script: number[];\n  witness: number[];\n};\n\nexport function getInputComponentsWeight(c: InputComponents): number {\n  const scriptSize = c.script.reduce((a, b) => a + b, 0);\n  return getInputWeight({\n    script: { length: scriptSize },\n    witness: c.witness.map((v) => ({ length: v })),\n  });\n}\n\nconst opSize = 1;\nconst op0Size = opSize;\nconst opPushSize = opSize;\nconst opCheckSigVerifySize = opSize;\nconst opCheckSigSize = opSize;\nconst ecdsaSignatureSize = 72;\nconst schnorrPubkeySize = 32;\nconst schnorrSignatureNoSighashSize = 64;\nconst p2msPubScriptSize = 105; // Note: This is valid for a compressed public key only\nconst p2wshPubScriptSize = 34;\nconst p2pkPubScriptSize = 35;\n\nfunction p2trScriptSpend(level: 1 | 2): number[] {\n  return [\n    schnorrSignatureNoSighashSize,\n    schnorrSignatureNoSighashSize,\n    opPushSize + schnorrPubkeySize + opCheckSigSize + opPushSize + schnorrPubkeySize + opCheckSigVerifySize,\n    /* header byte */ 1 + /* inner key */ 32 + /* inner leaf */ 32 * level,\n  ];\n}\n\nfunction p2msSigScriptSize(witness: boolean) {\n  return [\n    witness ? 0 : op0Size,\n    (witness ? 0 : opPushSize) + ecdsaSignatureSize,\n    (witness ? 0 : opPushSize) + ecdsaSignatureSize,\n    (witness ? 0 : /* OP_PUSHDATA2 */ opPushSize + 1) + p2msPubScriptSize,\n  ];\n}\n\nexport const inputComponentsP2sh: InputComponents = {\n  script: p2msSigScriptSize(false),\n  witness: [],\n};\n\nexport const inputComponentsP2shP2wsh: InputComponents = {\n  script: [opSize + p2wshPubScriptSize],\n  witness: p2msSigScriptSize(true),\n};\n\nexport const inputComponentsP2wsh: InputComponents = {\n  script: [],\n  witness: p2msSigScriptSize(true),\n};\n\n// See: https://murchandamus.medium.com/2-of-3-multisig-inputs-using-pay-to-taproot-d5faf2312ba3\nexport const inputComponentsP2trKeySpend: InputComponents = {\n  script: [],\n  witness: [schnorrSignatureNoSighashSize],\n};\n\nexport const inputComponentsP2trScriptSpendLevel1: InputComponents = {\n  script: [],\n  witness: p2trScriptSpend(1),\n};\n\nexport const inputComponentsP2trScriptSpendLevel2: InputComponents = {\n  script: [],\n  witness: p2trScriptSpend(2),\n};\n\nexport const inputComponentsP2shP2pk: InputComponents = {\n  script: [opPushSize + ecdsaSignatureSize, opPushSize + p2pkPubScriptSize],\n  witness: [],\n};\n"]}

package/dist/{scriptSizes.d.ts → src/scriptSizes.d.ts}

@@ -10,3 +10,4 @@ export declare function pushdataEncodingLength(i: number): number;
  * @return {number} - The compact size the integer requires when serialized in a transaction
  */
 export declare function compactSize(integer: number): number;
+//# sourceMappingURL=scriptSizes.d.ts.map

package/dist/src/scriptSizes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"scriptSizes.d.ts","sourceRoot":"","sources":["../../src/scriptSizes.ts"],"names":[],"mappings":"AAEA;;;GAGG;AACH,wBAAgB,sBAAsB,CAAC,CAAC,EAAE,MAAM,GAAG,MAAM,CAkBxD;AAED;;;;;GAKG;AACH,wBAAgB,WAAW,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,CAcnD"}

package/dist/src/scriptSizes.js

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.pushdataEncodingLength = pushdataEncodingLength;
+exports.compactSize = compactSize;
+const types_1 = require("./types");
+/**
+ * Overhead size for a pushdata element in a script
+ * @param i
+ */
+function pushdataEncodingLength(i) {
+    /*
+     * https://github.com/bitcoin/bips/blob/master/bip-0062.mediawiki#push-operators
+     * Pushing any other byte sequence up to 75 bytes must use the normal data push (opcode byte n, with n the number of bytes, followed n bytes of data being pushed).
+     * Pushing 76 to 255 bytes must use OP_PUSHDATA1.
+     * Pushing 256 to 520 bytes must use OP_PUSHDATA2.
+     * OP_PUSHDATA4 can never be used, as pushes over 520 bytes are not allowed, and those below can be done using other operators.
+     */
+    if (i < 76) {
+        return 1;
+    }
+    if (i < 255) {
+        return 2;
+    }
+    if (i < 520) {
+        return 3;
+    }
+    throw new Error(`invalid pushdata size`);
+}
+/**
+ * https://developer.bitcoin.org/reference/transactions.html#compactsize-unsigned-integers
+ * https://github.com/bitcoinjs/varuint-bitcoin/blob/1d5b253/index.js#L79
+ * @param integer
+ * @return {number} - The compact size the integer requires when serialized in a transaction
+ */
+function compactSize(integer) {
+    if (!types_1.PositiveInteger.is(integer)) {
+        throw new TypeError(`expected positive integer`);
+    }
+    if (integer <= 252) {
+        return 1;
+    }
+    if (integer <= 0xffff) {
+        return 3;
+    }
+    if (integer <= 0xffffffff) {
+        return 5;
+    }
+    return 9;
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/{types.d.ts → src/types.d.ts}

@@ -1,2 +1,3 @@
 import * as t from 'tcomb';
 export declare const PositiveInteger: t.Refinement<number>;
+//# sourceMappingURL=types.d.ts.map

package/dist/src/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,OAAO,CAAC;AAE3B,eAAO,MAAM,eAAe,sBAA4D,CAAC"}

package/dist/src/types.js

@@ -0,0 +1,39 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PositiveInteger = void 0;
+const t = __importStar(require("tcomb"));
+exports.PositiveInteger = t.refinement(t.Integer, (n) => n >= 0, 'PositiveInteger');
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidHlwZXMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvdHlwZXMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7O0FBQUEseUNBQTJCO0FBRWQsUUFBQSxlQUFlLEdBQUcsQ0FBQyxDQUFDLFVBQVUsQ0FBQyxDQUFDLENBQUMsT0FBTyxFQUFFLENBQUMsQ0FBQyxFQUFFLEVBQUUsQ0FBQyxDQUFDLElBQUksQ0FBQyxFQUFFLGlCQUFpQixDQUFDLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgKiBhcyB0IGZyb20gJ3Rjb21iJztcblxuZXhwb3J0IGNvbnN0IFBvc2l0aXZlSW50ZWdlciA9IHQucmVmaW5lbWVudCh0LkludGVnZXIsIChuKSA9PiBuID49IDAsICdQb3NpdGl2ZUludGVnZXInKTtcbiJdfQ==

package/dist/{virtualSizes.d.ts → src/virtualSizes.d.ts}

@@ -1,8 +1,8 @@
 export declare const VirtualSizes: Readonly<{
     /** @deprecated */
-    txP2pkhInputSizeCompressedKey: number;
+    txP2pkhInputSizeCompressedKey: 148;
     /** @deprecated */
-    txP2pkhInputSizeUncompressedKey: number;
+    txP2pkhInputSizeUncompressedKey: 180;
     txP2shInputSize: number;
     txP2shP2wshInputSize: number;
     txP2wshInputSize: number;
@@ -10,15 +10,16 @@ export declare const VirtualSizes: Readonly<{
     txP2shP2pkInputSize: number;
     txP2trScriptPathLevel1InputSize: number;
     txP2trScriptPathLevel2InputSize: number;
-    txOutputAmountSize: number;
-    txP2shOutputSize: number;
-    txP2shP2wshOutputSize: number;
-    txP2wshOutputSize: number;
-    txP2trOutputSize: number;
-    txP2pkhOutputSize: number;
-    txP2wpkhOutputSize: number;
+    txOutputAmountSize: 8;
+    txP2shOutputSize: 32;
+    txP2shP2wshOutputSize: 32;
+    txP2wshOutputSize: 43;
+    txP2trOutputSize: 43;
+    txP2pkhOutputSize: 34;
+    txP2wpkhOutputSize: 31;
     /** @deprecated - use txP2pkhOutputSize instead */
-    txOutputSize: number;
-    txOverheadSize: number;
-    txSegOverheadVSize: number;
+    txOutputSize: 34;
+    txOverheadSize: 10;
+    txSegOverheadVSize: 11;
 }>;
+//# sourceMappingURL=virtualSizes.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"virtualSizes.d.ts","sourceRoot":"","sources":["../../src/virtualSizes.ts"],"names":[],"mappings":"AA0EA,eAAO,MAAM,YAAY;IAIvB,kBAAkB;;IAElB,kBAAkB;;;;;;;;;;;;;;;;IAwClB,kDAAkD;;;;EAWlD,CAAC"}

package/dist/src/virtualSizes.js

@@ -0,0 +1,114 @@
+"use strict";
+/*
+This is a reference implementation for calculating weights and vSizes from bitcoinjs-lib 3.3.2.
+https://github.com/bitcoinjs/bitcoinjs-lib/blob/v3.3.2/src/transaction.js#L194-L219
+
+```
+  function encodingLength (number) {
+    checkUInt53(number)
+
+    return (
+      number < 0xfd ? 1
+    : number <= 0xffff ? 3
+    : number <= 0xffffffff ? 5
+    : 9
+    )
+  }
+
+  function varSliceSize (someScript) {
+    var length = someScript.length
+
+    return encodingLength(length) + length
+  }
+
+  function vectorSize (someVector) {
+    var length = someVector.length
+
+    return varuint.encodingLength(length) + someVector.reduce(function (sum, witness) {
+      return sum + varSliceSize(witness)
+    }, 0)
+  }
+
+  Transaction.prototype.__byteLength = function (__allowWitness) {
+    var hasWitnesses = __allowWitness && this.hasWitnesses()
+
+    return (
+      (hasWitnesses ? 10 : 8) +
+      varuint.encodingLength(this.ins.length) +
+      varuint.encodingLength(this.outs.length) +
+      this.ins.reduce(function (sum, input) { return sum + 40 + varSliceSize(input.script) }, 0) +
+      this.outs.reduce(function (sum, output) { return sum + 8 + varSliceSize(output.script) }, 0) +
+      (hasWitnesses ? this.ins.reduce(function (sum, input) { return sum + vectorSize(input.witness) }, 0) : 0)
+    )
+  }
+
+  Transaction.prototype.weight = function () {
+    var base = this.__byteLength(false)
+    var total = this.__byteLength(true)
+    return base * 3 + total
+  }
+
+  Transaction.prototype.virtualSize = function () {
+    return Math.ceil(this.weight() / 4)
+  }
+```
+*/
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VirtualSizes = void 0;
+const inputWeights_1 = require("./inputWeights");
+function getVirtualInputSizeFromComponents(components) {
+    return Math.ceil((0, inputWeights_1.getInputComponentsWeight)(components) / 4);
+}
+// Constants for signed TX input and output vsizes.
+// See https://bitcoincore.org/en/segwit_wallet_dev/#transaction-serialization for full description
+// FIXME(BG-9233): use weight units instead
+exports.VirtualSizes = Object.freeze({
+    // FIXME(BG-7873): add support for signature grinding
+    // Size of a P2PKH input with (un)compressed key
+    /** @deprecated */
+    txP2pkhInputSizeCompressedKey: 148,
+    /** @deprecated */
+    txP2pkhInputSizeUncompressedKey: 180,
+    // Input sizes
+    txP2shInputSize: getVirtualInputSizeFromComponents(inputWeights_1.inputComponentsP2sh),
+    txP2shP2wshInputSize: getVirtualInputSizeFromComponents(inputWeights_1.inputComponentsP2shP2wsh),
+    txP2wshInputSize: getVirtualInputSizeFromComponents(inputWeights_1.inputComponentsP2wsh),
+    txP2trKeypathInputSize: getVirtualInputSizeFromComponents(inputWeights_1.inputComponentsP2trKeySpend),
+    txP2shP2pkInputSize: getVirtualInputSizeFromComponents(inputWeights_1.inputComponentsP2shP2pk),
+    txP2trScriptPathLevel1InputSize: getVirtualInputSizeFromComponents(inputWeights_1.inputComponentsP2trScriptSpendLevel1),
+    txP2trScriptPathLevel2InputSize: getVirtualInputSizeFromComponents(inputWeights_1.inputComponentsP2trScriptSpendLevel2),
+    //
+    // Output sizes
+    //
+    // The size is calculated as
+    //
+    //    scriptLength + compactSize(scriptLength) + txOutputAmountSize
+    //
+    // Since compactSize(scriptLength) is 1 for all scripts considered here, we can simplify this to
+    //
+    //    scriptLength + 9
+    //
+    // Size of single output amount
+    txOutputAmountSize: 8,
+    // https://github.com/bitcoinjs/bitcoinjs-lib/blob/v4.0.2/src/templates/scripthash/output.js#L9
+    txP2shOutputSize: 32,
+    txP2shP2wshOutputSize: 32,
+    // https://github.com/bitcoinjs/bitcoinjs-lib/blob/v4.0.2/src/templates/witnessscripthash/output.js#L9
+    txP2wshOutputSize: 43,
+    // OP_1 OP_PUSH32 <schnorr_public_key>
+    txP2trOutputSize: 43,
+    // https://github.com/bitcoinjs/bitcoinjs-lib/blob/v4.0.2/src/templates/pubkeyhash/output.js#L9
+    txP2pkhOutputSize: 34,
+    // https://github.com/bitcoinjs/bitcoinjs-lib/blob/v4.0.2/src/templates/witnesspubkeyhash/output.js#L9
+    txP2wpkhOutputSize: 31,
+    /** @deprecated - use txP2pkhOutputSize instead */
+    txOutputSize: 34,
+    //
+    // General tx size constants
+    //
+    txOverheadSize: 10,
+    // Segwit adds one byte each for marker and flag to the witness section.
+    // Thus, the vsize is only increased by one.
+    txSegOverheadVSize: 11,
+});
+//# sourceMappingURL=data:application/json;base64,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

package/dist/src/zcash.d.ts

@@ -0,0 +1,9 @@
+import { Dimensions } from './dimensions';
+export declare function getLogicalActions(params: {
+    txInTotalSize: number;
+    txOutTotalSize: number;
+} | Dimensions): number;
+export declare function getConventionalFeeForDimensions(dimensions: Dimensions, params?: {
+    marginalFeeZatPerAction?: number;
+}): number;
+//# sourceMappingURL=zcash.d.ts.map

package/dist/src/zcash.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"zcash.d.ts","sourceRoot":"","sources":["../../src/zcash.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC;AAO1C,wBAAgB,iBAAiB,CAAC,MAAM,EAAE;IAAE,aAAa,EAAE,MAAM,CAAC;IAAC,cAAc,EAAE,MAAM,CAAA;CAAE,GAAG,UAAU,GAAG,MAAM,CAUhH;AAED,wBAAgB,+BAA+B,CAC7C,UAAU,EAAE,UAAU,EACtB,MAAM,GAAE;IACN,uBAAuB,CAAC,EAAE,MAAM,CAAC;CAC7B,GACL,MAAM,CAIR"}

package/dist/src/zcash.js

@@ -0,0 +1,22 @@
+"use strict";
+// https://zips.z.cash/zip-0317
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getLogicalActions = getLogicalActions;
+exports.getConventionalFeeForDimensions = getConventionalFeeForDimensions;
+const dimensions_1 = require("./dimensions");
+const marginalFeeZatPerAction = 5000;
+const graceActions = 2;
+const p2pkhStandardInputSize = 150;
+const p2pkhStandardOutputSize = 34;
+function getLogicalActions(params) {
+    if (params instanceof dimensions_1.Dimensions) {
+        return getLogicalActions({ txInTotalSize: params.getInputsVSize(), txOutTotalSize: params.getOutputsVSize() });
+    }
+    // The ZIP includes nJoinSplits, nSpendsSapling, nOutputsSapling, nActionsOrchard
+    // which are not relevant for BitGo transactions.
+    return Math.max(Math.ceil(params.txInTotalSize / p2pkhStandardInputSize), Math.ceil(params.txOutTotalSize / p2pkhStandardOutputSize));
+}
+function getConventionalFeeForDimensions(dimensions, params = {}) {
+    return (Math.max(getLogicalActions(dimensions), graceActions) * (params.marginalFeeZatPerAction ?? marginalFeeZatPerAction));
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/test/chain.d.ts

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

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

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

package/dist/test/chain.js

@@ -0,0 +1,92 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+/* eslint-disable @typescript-eslint/ban-ts-comment */
+const should_1 = __importDefault(require("should"));
+const src_1 = require("../src");
+describe('chain codes', function () {
+    const externalList = [src_1.Codes.external.p2sh, src_1.Codes.external.p2shP2wsh, src_1.Codes.external.p2wsh, src_1.Codes.external.p2tr];
+    const internalList = [src_1.Codes.internal.p2sh, src_1.Codes.internal.p2shP2wsh, src_1.Codes.internal.p2wsh, src_1.Codes.internal.p2tr];
+    const purposeByScriptTypeList = [src_1.Codes.p2sh, src_1.Codes.p2shP2wsh, src_1.Codes.p2wsh, src_1.Codes.p2tr];
+    const supportedUnspentTypeList = [
+        src_1.CodesTypes.UnspentType.p2sh,
+        src_1.CodesTypes.UnspentType.p2shP2wsh,
+        src_1.CodesTypes.UnspentType.p2wsh,
+        src_1.CodesTypes.UnspentType.p2tr,
+    ];
+    const unsupportedUnspentTypeList = [src_1.CodesTypes.UnspentType.p2pkh, src_1.CodesTypes.UnspentType.p2wpkh];
+    it(`is immutable`, function () {
+        const p2sh = src_1.Codes.internal.p2sh;
+        should_1.default.throws(() => {
+            // @ts-ignore
+            src_1.Codes.internal.p2sh = -1;
+        }, TypeError);
+        src_1.Codes.internal.p2sh.should.eql(p2sh);
+        should_1.default.throws(() => {
+            // @ts-ignore
+            src_1.Codes.internal.values.push(-1);
+        }, TypeError);
+        should_1.default.throws(() => {
+            // @ts-ignore
+            src_1.Codes.internal.values = [];
+        }, TypeError);
+        src_1.Codes.internal.values.should.eql([1, 11, 21, 31]);
+        should_1.default.throws(() => {
+            // @ts-ignore
+            src_1.Codes.all = [];
+        });
+        src_1.Codes.all.should.not.be.empty();
+    });
+    it('matches expected values', function () {
+        externalList.should.eql([src_1.Codes.p2sh.external, src_1.Codes.p2shP2wsh.external, src_1.Codes.p2wsh.external, src_1.Codes.p2tr.external]);
+        externalList.should.eql([0, 10, 20, 30]);
+        externalList.should.eql([...src_1.Codes.external.values]);
+        src_1.Codes.all.should.eql([...externalList, ...internalList]);
+        internalList.should.eql([src_1.Codes.p2sh.internal, src_1.Codes.p2shP2wsh.internal, src_1.Codes.p2wsh.internal, src_1.Codes.p2tr.internal]);
+        internalList.should.eql([1, 11, 21, 31]);
+        internalList.should.eql([...src_1.Codes.internal.values]);
+    });
+    it('are grouped correctly', function () {
+        internalList.should.matchEach(src_1.Codes.isInternal);
+        externalList.should.matchEach(src_1.Codes.isExternal);
+        // all are either internal or external, never none or both
+        src_1.Codes.all.should.matchEach((code) => !!(src_1.Codes.isExternal(code) !== src_1.Codes.isInternal(code)));
+        src_1.Codes.p2sh.values.should.matchEach(src_1.Codes.isP2sh);
+        src_1.Codes.p2shP2wsh.values.should.matchEach(src_1.Codes.isP2shP2wsh);
+        src_1.Codes.p2wsh.values.should.matchEach(src_1.Codes.isP2wsh);
+        src_1.Codes.p2tr.values.should.matchEach(src_1.Codes.isP2tr);
+        // every code has exactly one address type
+        src_1.Codes.all.should.matchEach((code) => 1 ===
+            [src_1.Codes.isP2sh(code), src_1.Codes.isP2wsh(code), src_1.Codes.isP2shP2wsh(code), src_1.Codes.isP2tr(code)].reduce((sum, v) => sum + Number(v), 0));
+        src_1.Codes.all.should.matchEach(src_1.Codes.isValid);
+    });
+    const invalidInputs = [undefined, null, 'lol', -1, 42];
+    it('throws correct error for invalid input', function () {
+        [
+            src_1.Codes.isInternal,
+            src_1.Codes.isExternal,
+            src_1.Codes.isP2sh,
+            src_1.Codes.isP2shP2wsh,
+            src_1.Codes.isP2wsh,
+            src_1.Codes.isP2tr,
+            src_1.Codes.typeForCode,
+        ].forEach((func) => 
+        // @ts-ignore
+        invalidInputs.forEach((input) => should_1.default.throws(() => func(input), src_1.Codes.ErrorInvalidCode)));
+        invalidInputs.should.matchEach((input) => !src_1.Codes.isValid(input));
+    });
+    it('map to unspent types', function () {
+        [...externalList, ...internalList].forEach((code, index) => src_1.Codes.typeForCode(code).should.equal([...supportedUnspentTypeList, ...supportedUnspentTypeList][index]));
+    });
+    it('map from unspent types', function () {
+        supportedUnspentTypeList.forEach((type, index) => src_1.Codes.forType(type).should.eql(purposeByScriptTypeList[index]));
+        unsupportedUnspentTypeList.forEach((type) => should_1.default.throws(() => src_1.Codes.forType(type)));
+    });
+    it(`has chain type`, function () {
+        src_1.Codes.all.should.matchEach((code) => src_1.Codes.ChainCodeTcomb(code) === code && src_1.Codes.ChainCodeTcomb.is(code));
+        invalidInputs.forEach((code) => should_1.default.throws(() => src_1.Codes.ChainCodeTcomb(code)));
+    });
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"chain.js","sourceRoot":"","sources":["../../test/chain.ts"],"names":[],"mappings":"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","sourcesContent":["/* eslint-disable @typescript-eslint/ban-ts-comment */\nimport should from 'should';\nimport { Codes, CodesTypes } from '../src';\n\ndescribe('chain codes', function () {\n  const externalList = [Codes.external.p2sh, Codes.external.p2shP2wsh, Codes.external.p2wsh, Codes.external.p2tr];\n\n  const internalList = [Codes.internal.p2sh, Codes.internal.p2shP2wsh, Codes.internal.p2wsh, Codes.internal.p2tr];\n\n  const purposeByScriptTypeList = [Codes.p2sh, Codes.p2shP2wsh, Codes.p2wsh, Codes.p2tr];\n\n  const supportedUnspentTypeList = [\n    CodesTypes.UnspentType.p2sh,\n    CodesTypes.UnspentType.p2shP2wsh,\n    CodesTypes.UnspentType.p2wsh,\n    CodesTypes.UnspentType.p2tr,\n  ];\n\n  const unsupportedUnspentTypeList = [CodesTypes.UnspentType.p2pkh, CodesTypes.UnspentType.p2wpkh];\n\n  it(`is immutable`, function () {\n    const p2sh = Codes.internal.p2sh;\n    should.throws(() => {\n      // @ts-ignore\n      Codes.internal.p2sh = -1;\n    }, TypeError);\n    Codes.internal.p2sh.should.eql(p2sh);\n\n    should.throws(() => {\n      // @ts-ignore\n      Codes.internal.values.push(-1);\n    }, TypeError);\n\n    should.throws(() => {\n      // @ts-ignore\n      Codes.internal.values = [];\n    }, TypeError);\n    Codes.internal.values.should.eql([1, 11, 21, 31]);\n\n    should.throws(() => {\n      // @ts-ignore\n      Codes.all = [];\n    });\n    Codes.all.should.not.be.empty();\n  });\n\n  it('matches expected values', function () {\n    externalList.should.eql([Codes.p2sh.external, Codes.p2shP2wsh.external, Codes.p2wsh.external, Codes.p2tr.external]);\n    externalList.should.eql([0, 10, 20, 30]);\n    externalList.should.eql([...Codes.external.values]);\n\n    Codes.all.should.eql([...externalList, ...internalList]);\n    internalList.should.eql([Codes.p2sh.internal, Codes.p2shP2wsh.internal, Codes.p2wsh.internal, Codes.p2tr.internal]);\n    internalList.should.eql([1, 11, 21, 31]);\n    internalList.should.eql([...Codes.internal.values]);\n  });\n\n  it('are grouped correctly', function () {\n    internalList.should.matchEach(Codes.isInternal);\n    externalList.should.matchEach(Codes.isExternal);\n\n    // all are either internal or external, never none or both\n    Codes.all.should.matchEach((code) => !!(Codes.isExternal(code) !== Codes.isInternal(code)));\n\n    Codes.p2sh.values.should.matchEach(Codes.isP2sh);\n    Codes.p2shP2wsh.values.should.matchEach(Codes.isP2shP2wsh);\n    Codes.p2wsh.values.should.matchEach(Codes.isP2wsh);\n    Codes.p2tr.values.should.matchEach(Codes.isP2tr);\n\n    // every code has exactly one address type\n    Codes.all.should.matchEach(\n      (code) =>\n        1 ===\n        [Codes.isP2sh(code), Codes.isP2wsh(code), Codes.isP2shP2wsh(code), Codes.isP2tr(code)].reduce(\n          (sum, v) => sum + Number(v),\n          0\n        )\n    );\n\n    Codes.all.should.matchEach(Codes.isValid);\n  });\n\n  const invalidInputs = [undefined, null, 'lol', -1, 42];\n\n  it('throws correct error for invalid input', function () {\n    [\n      Codes.isInternal,\n      Codes.isExternal,\n      Codes.isP2sh,\n      Codes.isP2shP2wsh,\n      Codes.isP2wsh,\n      Codes.isP2tr,\n      Codes.typeForCode,\n    ].forEach((func) =>\n      // @ts-ignore\n      invalidInputs.forEach((input) => should.throws(() => func(input), Codes.ErrorInvalidCode))\n    );\n\n    invalidInputs.should.matchEach((input) => !Codes.isValid(input));\n  });\n\n  it('map to unspent types', function () {\n    [...externalList, ...internalList].forEach((code, index) =>\n      Codes.typeForCode(code).should.equal([...supportedUnspentTypeList, ...supportedUnspentTypeList][index])\n    );\n  });\n\n  it('map from unspent types', function () {\n    supportedUnspentTypeList.forEach((type, index) => Codes.forType(type).should.eql(purposeByScriptTypeList[index]));\n\n    unsupportedUnspentTypeList.forEach((type) => should.throws(() => Codes.forType(type)));\n  });\n\n  it(`has chain type`, function () {\n    Codes.all.should.matchEach((code) => Codes.ChainCodeTcomb(code) === code && Codes.ChainCodeTcomb.is(code));\n    invalidInputs.forEach((code: any) => should.throws(() => Codes.ChainCodeTcomb(code)));\n  });\n});\n"]}

package/dist/test/dimensions.d.ts

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

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

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