@bitgo-beta/unspents 0.13.2-beta.27 → 0.13.2-beta.270

package/dist/src/dimensions.js

@@ -0,0 +1,488 @@
+"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;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Dimensions = exports.OutputDimensions = exports.VirtualSizes = void 0;
+const utxolib = __importStar(require("@bitgo-beta/utxo-lib"));
+const utxo_lib_1 = require("@bitgo-beta/utxo-lib");
+const { isChainCode, scriptTypeForChain } = utxo_lib_1.bitgo;
+const scriptSizes_1 = require("./scriptSizes");
+const types_1 = require("./types");
+const virtualSizes_1 = require("./virtualSizes");
+Object.defineProperty(exports, "VirtualSizes", { enumerable: true, get: function () { return virtualSizes_1.VirtualSizes; } });
+/**
+ * Apply `f` to all properties of `d`
+ */
+function mapDimensions(d, f) {
+    return new Dimensions(Object.fromEntries(Object.entries(d).map(([key, value]) => [key, f(key, value)])));
+}
+/**
+ * Aggregate count and size of transaction outputs
+ */
+class OutputDimensions {
+    constructor({ count = 0, size = 0 } = { count: 0, size: 0 }) {
+        if (count === 0 || size === 0) {
+            if (count !== 0 || size !== 0) {
+                throw new Error(`count and size must both be zero if one is zero`);
+            }
+        }
+        this.count = count;
+        this.size = size;
+        Object.freeze(this);
+    }
+}
+exports.OutputDimensions = OutputDimensions;
+const defaultUnspentParams = {
+    p2tr: {
+        // Default to recovery script paths, to make it easier for recovery case callers (WRW etc).
+        // WP can explicitly pass scriptPathLevel: 1 to use happy path.
+        scriptPathLevel: 2,
+    },
+    p2trMusig2: {
+        // Default to script path spend, to make it easier for recovery case callers (WRW etc).
+        // WP can explicitly pass scriptPathLevel: undefined to use key path.
+        scriptPathLevel: 1,
+    },
+};
+/**
+ * Dimensions of a BitGo wallet transactions.
+ */
+class Dimensions {
+    constructor(d = {}) {
+        /** Input counts for BitGo wallet multi-signature inputs */
+        this.nP2shInputs = 0;
+        this.nP2shP2wshInputs = 0;
+        this.nP2wshInputs = 0;
+        this.nP2trKeypathInputs = 0;
+        this.nP2trScriptPathLevel1Inputs = 0;
+        this.nP2trScriptPathLevel2Inputs = 0;
+        /* Input count for single-signature inputs (Replay Protection inputs) */
+        this.nP2shP2pkInputs = 0;
+        this.outputs = new OutputDimensions();
+        Object.entries(d).forEach(([key, value]) => this.setProperty(key, value));
+        Object.freeze(this);
+    }
+    setProperty(k, v) {
+        switch (k) {
+            case 'nP2shInputs':
+            case 'nP2shP2wshInputs':
+            case 'nP2wshInputs':
+            case 'nP2trKeypathInputs':
+            case 'nP2trScriptPathLevel1Inputs':
+            case 'nP2trScriptPathLevel2Inputs':
+            case 'nP2shP2pkInputs':
+                if (typeof v !== 'number') {
+                    throw new Error(`property ${k} must be number`);
+                }
+                if (!Number.isSafeInteger(v) || v < 0) {
+                    throw new Error(`property ${k} must be zero or positive integer`);
+                }
+                break;
+            case 'outputs':
+                if (!(v instanceof OutputDimensions)) {
+                    v = new OutputDimensions(v);
+                }
+                break;
+            default:
+                throw new Error(`unknown property ${k}`);
+        }
+        this[k] = v;
+    }
+    /**
+     * @deprecated use ZERO
+     * @return Dimensions for an empty transaction
+     */
+    static zero() {
+        return this.ZERO;
+    }
+    /**
+     * @param size
+     * @return Dimensions for a single output with given size
+     */
+    static singleOutput(size) {
+        return Dimensions.sum({ outputs: { count: 1, size } });
+    }
+    /**
+     * @return Number of total inputs (p2sh + p2shP2wsh + p2wsh + p2tr)
+     */
+    get nInputs() {
+        return (this.nP2shInputs +
+            this.nP2shP2wshInputs +
+            this.nP2wshInputs +
+            this.nP2trKeypathInputs +
+            this.nP2trScriptPathLevel1Inputs +
+            this.nP2trScriptPathLevel2Inputs +
+            this.nP2shP2pkInputs);
+    }
+    set nInputs(_) {
+        throw new Error('read-only property nInputs');
+    }
+    /**
+     * @return Number of total outputs
+     */
+    get nOutputs() {
+        return this.outputs.count;
+    }
+    set nOutputs(_) {
+        throw new Error(`read-only property nOutputs`);
+    }
+    /**
+     * @param args - Dimensions (can be partially defined)
+     * @return {Dimensions} sum of arguments
+     */
+    static sum(...args) {
+        return args.reduce((a, b) => a.plus(b), new Dimensions());
+    }
+    /**
+     * @param chain
+     * @return {Number}
+     */
+    static getOutputScriptLengthForChain(chain) {
+        switch (scriptTypeForChain(chain)) {
+            case 'p2wsh':
+            case 'p2tr':
+            case 'p2trMusig2':
+                return 34;
+            default:
+                return 23;
+        }
+    }
+    /**
+     * @param scriptLength
+     * @return {Number} vSize of an output with script length
+     */
+    static getVSizeForOutputWithScriptLength(scriptLength) {
+        if (!types_1.PositiveInteger.is(scriptLength)) {
+            throw new TypeError(`expected positive integer for scriptLength, got ${scriptLength}`);
+        }
+        return scriptLength + scriptSizes_1.compactSize(scriptLength) + virtualSizes_1.VirtualSizes.txOutputAmountSize;
+    }
+    /**
+     * @return
+     */
+    static fromScriptType(scriptType, params = {}) {
+        switch (scriptType) {
+            case 'p2sh':
+            case 'p2shP2wsh':
+            case 'p2wsh':
+            case 'p2shP2pk':
+                return Dimensions.SingleInput[scriptType];
+            case 'p2tr':
+            case 'taprootScriptPathSpend':
+                switch (params.scriptPathLevel) {
+                    case 1:
+                        return Dimensions.SingleInput.p2trScriptPathLevel1;
+                    case 2:
+                        return Dimensions.SingleInput.p2trScriptPathLevel2;
+                    default:
+                        throw new Error(`unexpected script path level`);
+                }
+            case 'p2trMusig2':
+                switch (params.scriptPathLevel) {
+                    case undefined:
+                        return Dimensions.SingleInput.p2trKeypath;
+                    case 1:
+                        return Dimensions.SingleInput.p2trScriptPathLevel1;
+                    default:
+                        throw new Error(`unexpected script path level`);
+                }
+            case 'taprootKeyPathSpend':
+                return Dimensions.SingleInput.p2trKeypath;
+            default:
+                throw new Error(`unexpected scriptType ${scriptType}`);
+        }
+    }
+    static getAssumedDimension(params = {}, index) {
+        const { assumeUnsigned } = params;
+        if (!assumeUnsigned) {
+            throw new Error(`illegal input ${index}: empty script and assumeUnsigned not set`);
+        }
+        return assumeUnsigned;
+    }
+    /**
+     * @param input - the transaction input to count
+     * @param params
+     *        [param.assumeUnsigned] - default type for unsigned input
+     */
+    static fromInput(input, params = {}) {
+        var _a, _b;
+        if (((_a = input.script) === null || _a === void 0 ? void 0 : _a.length) || ((_b = input.witness) === null || _b === void 0 ? void 0 : _b.length)) {
+            const parsed = utxolib.bitgo.parseSignatureScript(input);
+            return Dimensions.fromScriptType(parsed.scriptType, parsed);
+        }
+        return Dimensions.getAssumedDimension(params, input.index);
+    }
+    /**
+     * Create Dimensions from psbt input
+     * @param input - psbt input
+     */
+    static fromPsbtInput(input) {
+        const parsed = utxo_lib_1.bitgo.parsePsbtInput(input);
+        return Dimensions.fromScriptType(parsed.scriptType, parsed);
+    }
+    /**
+     * @param inputs - Array of inputs
+     * @param params - @see Dimensions.fromInput()
+     * @return {Dimensions} sum of the dimensions for each input (@see Dimensions.fromInput())
+     */
+    static fromInputs(inputs, params) {
+        if (!Array.isArray(inputs)) {
+            throw new TypeError(`inputs must be array`);
+        }
+        return Dimensions.sum(...inputs.map((i) => Dimensions.fromInput(i, params)));
+    }
+    /**
+     * Create Dimensions from multiple psbt inputs
+     * @param inputs psbt input array
+     * @return {Dimensions} sum of the dimensions for each input (@see Dimensions.fromPsbtInput())
+     */
+    static fromPsbtInputs(inputs) {
+        if (!Array.isArray(inputs)) {
+            throw new TypeError(`inputs must be array`);
+        }
+        return Dimensions.sum(...inputs.map((input, _) => Dimensions.fromPsbtInput(input)));
+    }
+    /**
+     * @param scriptLength {number} - size of the output script in bytes
+     * @return {Dimensions} - Dimensions of the output
+     */
+    static fromOutputScriptLength(scriptLength) {
+        return Dimensions.sum({
+            outputs: {
+                count: 1,
+                size: Dimensions.getVSizeForOutputWithScriptLength(scriptLength),
+            },
+        });
+    }
+    /**
+     * @param output - a tx output
+     * @return Dimensions - the dimensions of the given output
+     */
+    static fromOutput({ script }) {
+        if (!script) {
+            throw new Error('expected output script to be defined');
+        }
+        if (!Buffer.isBuffer(script)) {
+            throw new TypeError('expected script to be buffer, got ' + typeof script);
+        }
+        return Dimensions.fromOutputScriptLength(script.length);
+    }
+    /**
+     * @param outputs - Array of outputs
+     * @return {Dimensions} sum of the dimensions for each output (@see Dimensions.fromOutput())
+     */
+    static fromOutputs(outputs) {
+        if (!Array.isArray(outputs)) {
+            throw new TypeError(`outputs must be array`);
+        }
+        return Dimensions.sum(...outputs.map(Dimensions.fromOutput));
+    }
+    /**
+     * Returns the dimensions of an output that will be created on a specific chain.
+     * Currently, this simply adds a default output.
+     *
+     * @param chain - Chain code as defined by utxolib.bitgo
+     * @return {Dimensions} - Dimensions for a single output on the given chain.
+     */
+    static fromOutputOnChain(chain) {
+        return Dimensions.fromOutputScriptLength(Dimensions.getOutputScriptLengthForChain(chain));
+    }
+    /**
+     * Return dimensions of an unspent according to `chain` parameter
+     * @param chain - Chain code as defined by utxo.chain
+     * @param params - Hint for unspents with variable input sizes (p2tr, p2trMusig2)
+     * @return {Dimensions} of the unspent
+     * @throws if the chain code is invalid or unsupported
+     */
+    static fromUnspent({ chain }, params = defaultUnspentParams) {
+        if (!isChainCode(chain)) {
+            throw new TypeError('invalid chain code');
+        }
+        const scriptType = scriptTypeForChain(chain);
+        return Dimensions.fromScriptType(scriptType, scriptType === 'p2tr' ? params.p2tr : scriptType === 'p2trMusig2' ? params.p2trMusig2 : {});
+    }
+    /**
+     * @param unspents
+     * @param params - Hint for unspents with variable input sizes (p2tr, p2trMusig2)
+     * @return {Dimensions} sum of the dimensions for each unspent (@see Dimensions.fromUnspent())
+     */
+    static fromUnspents(unspents, params = defaultUnspentParams) {
+        if (!Array.isArray(unspents)) {
+            throw new TypeError(`unspents must be array`);
+        }
+        // Convert the individual unspents into dimensions and sum them up
+        return Dimensions.sum(...unspents.map((u) => Dimensions.fromUnspent(u, params)));
+    }
+    /**
+     * @param transaction - bitcoin-like transaction
+     * @param [param.assumeUnsigned] - default type for unsigned inputs
+     * @return {Dimensions}
+     */
+    static fromTransaction({ ins, outs, }, params) {
+        return Dimensions.fromInputs(ins, params).plus(Dimensions.fromOutputs(outs));
+    }
+    /**
+     * Create Dimensions from psbt inputs and outputs
+     * @param psbt
+     * @return {Dimensions}
+     */
+    static fromPsbt(psbt) {
+        return Dimensions.fromPsbtInputs(psbt.data.inputs).plus(Dimensions.fromOutputs(psbt.getUnsignedTx().outs));
+    }
+    /**
+     * @param dimensions (can be partially defined)
+     * @return new dimensions with argument added
+     */
+    plus(dimensions) {
+        if (typeof dimensions !== 'object') {
+            throw new TypeError(`expected argument to be object`);
+        }
+        if (!(dimensions instanceof Dimensions)) {
+            dimensions = new Dimensions(dimensions);
+        }
+        // Catch instances where we try to initialize Dimensions from partial data using deprecated parameters
+        // using only "nOutputs".
+        if ('nOutputs' in dimensions) {
+            if (!('outputs' in dimensions)) {
+                throw new Error('deprecated partial addition: argument has key "nOutputs" but no "outputs"');
+            }
+            const { outputs, nOutputs } = dimensions;
+            if (outputs.count !== nOutputs) {
+                throw new Error('deprecated partial addition: inconsistent values for "nOutputs" and "outputs.count"');
+            }
+        }
+        return mapDimensions(this, (key, v) => {
+            var _a;
+            const w = (_a = dimensions[key]) !== null && _a !== void 0 ? _a : Dimensions.ZERO[key];
+            if (key === 'outputs') {
+                const vOutputs = v;
+                const wOutputs = w;
+                return new OutputDimensions({
+                    count: vOutputs.count + wOutputs.count,
+                    size: vOutputs.size + wOutputs.size,
+                });
+            }
+            return v + w;
+        });
+    }
+    /**
+     * Multiply dimensions by a given factor
+     * @param factor - Positive integer
+     * @return {Dimensions}
+     */
+    times(factor) {
+        if (!types_1.PositiveInteger.is(factor)) {
+            throw new TypeError(`expected factor to be positive integer`);
+        }
+        return mapDimensions(this, (key, value) => {
+            if (key === 'outputs') {
+                const vOutputs = value;
+                return {
+                    count: vOutputs.count * factor,
+                    size: vOutputs.size * factor,
+                };
+            }
+            return value * factor;
+        });
+    }
+    /**
+     * @return Number of total inputs (p2sh, p2shP2wsh and p2wsh)
+     * @deprecated use `dimension.nInputs` instead
+     */
+    getNInputs() {
+        return this.nInputs;
+    }
+    /**
+     * @returns {boolean} true iff dimensions have one or more (p2sh)p2wsh inputs
+     */
+    isSegwit() {
+        return (this.nP2wshInputs +
+            this.nP2shP2wshInputs +
+            this.nP2trKeypathInputs +
+            this.nP2trScriptPathLevel1Inputs +
+            this.nP2trScriptPathLevel2Inputs >
+            0);
+    }
+    /**
+     * @return {Number} overhead vsize, based on result isSegwit().
+     */
+    getOverheadVSize() {
+        return this.isSegwit() ? virtualSizes_1.VirtualSizes.txSegOverheadVSize : virtualSizes_1.VirtualSizes.txOverheadSize;
+    }
+    /**
+     * @returns {number} vsize of inputs, without transaction overhead
+     */
+    getInputsVSize() {
+        const { txP2shInputSize, txP2shP2wshInputSize, txP2wshInputSize, txP2trKeypathInputSize, txP2trScriptPathLevel1InputSize, txP2trScriptPathLevel2InputSize, txP2shP2pkInputSize, } = virtualSizes_1.VirtualSizes;
+        const { nP2shInputs, nP2shP2wshInputs, nP2wshInputs, nP2trKeypathInputs, nP2trScriptPathLevel1Inputs, nP2trScriptPathLevel2Inputs, nP2shP2pkInputs, } = this;
+        const size = nP2shInputs * txP2shInputSize +
+            nP2shP2wshInputs * txP2shP2wshInputSize +
+            nP2wshInputs * txP2wshInputSize +
+            nP2trKeypathInputs * txP2trKeypathInputSize +
+            nP2shP2pkInputs * txP2shP2pkInputSize +
+            nP2trScriptPathLevel1Inputs * txP2trScriptPathLevel1InputSize +
+            nP2trScriptPathLevel2Inputs * txP2trScriptPathLevel2InputSize;
+        if (Number.isNaN(size)) {
+            throw new Error(`invalid size`);
+        }
+        return size;
+    }
+    /**
+     * @returns {number} return vsize of outputs, without overhead
+     */
+    getOutputsVSize() {
+        return this.outputs.size;
+    }
+    /**
+     * Estimates the virtual size (1/4 weight) of a signed transaction as sum of
+     * overhead vsize, input vsize and output vsize.
+     * @returns {Number} The estimated vsize of the transaction dimensions.
+     */
+    getVSize() {
+        return this.getOverheadVSize() + this.getInputsVSize() + this.getOutputsVSize();
+    }
+}
+exports.Dimensions = Dimensions;
+Dimensions.ZERO = Object.freeze(new Dimensions());
+Dimensions.SingleOutput = Object.freeze({
+    p2sh: Dimensions.singleOutput(virtualSizes_1.VirtualSizes.txP2shOutputSize),
+    p2shP2wsh: Dimensions.singleOutput(virtualSizes_1.VirtualSizes.txP2shP2wshOutputSize),
+    p2wsh: Dimensions.singleOutput(virtualSizes_1.VirtualSizes.txP2wshOutputSize),
+    p2tr: Dimensions.singleOutput(virtualSizes_1.VirtualSizes.txP2trOutputSize),
+    p2pkh: Dimensions.singleOutput(virtualSizes_1.VirtualSizes.txP2pkhOutputSize),
+    p2wpkh: Dimensions.singleOutput(virtualSizes_1.VirtualSizes.txP2wpkhOutputSize),
+});
+Dimensions.SingleInput = Object.freeze({
+    p2sh: Dimensions.sum({ nP2shInputs: 1 }),
+    p2shP2wsh: Dimensions.sum({ nP2shP2wshInputs: 1 }),
+    p2wsh: Dimensions.sum({ nP2wshInputs: 1 }),
+    p2trKeypath: Dimensions.sum({ nP2trKeypathInputs: 1 }),
+    p2trScriptPathLevel1: Dimensions.sum({ nP2trScriptPathLevel1Inputs: 1 }),
+    p2trScriptPathLevel2: Dimensions.sum({ nP2trScriptPathLevel2Inputs: 1 }),
+    p2shP2pk: Dimensions.sum({ nP2shP2pkInputs: 1 }),
+});
+Dimensions.ASSUME_P2SH = Dimensions.SingleInput.p2sh;
+Dimensions.ASSUME_P2SH_P2WSH = Dimensions.SingleInput.p2shP2wsh;
+Dimensions.ASSUME_P2WSH = Dimensions.SingleInput.p2wsh;
+Dimensions.ASSUME_P2TR_KEYPATH = Dimensions.SingleInput.p2trKeypath;
+Dimensions.ASSUME_P2TR_SCRIPTPATH_LEVEL1 = Dimensions.SingleInput.p2trScriptPathLevel1;
+Dimensions.ASSUME_P2TR_SCRIPTPATH_LEVEL2 = Dimensions.SingleInput.p2trScriptPathLevel2;
+Dimensions.ASSUME_P2SH_P2PK_INPUT = Dimensions.SingleInput.p2shP2pk;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"dimensions.js","sourceRoot":"","sources":["../../src/dimensions.ts"],"names":[],"mappings":"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","sourcesContent":["import * as utxolib from '@bitgo-beta/utxo-lib';\nimport { bitgo } from '@bitgo-beta/utxo-lib';\nconst { isChainCode, scriptTypeForChain } = bitgo;\ntype ChainCode = bitgo.ChainCode;\n\nimport { compactSize } from './scriptSizes';\nimport { PositiveInteger } from './types';\n\nimport { VirtualSizes } from './virtualSizes';\nexport { VirtualSizes };\n\n/**\n * Apply `f` to all properties of `d`\n */\nfunction mapDimensions(\n  d: Partial<Dimensions>,\n  f: <T extends keyof Dimensions>(key: T, v: Dimensions[T] | undefined) => unknown\n): Dimensions {\n  return new Dimensions(\n    Object.fromEntries(Object.entries(d).map(([key, value]) => [key, f(key as keyof Dimensions, value)]))\n  );\n}\n\n/**\n * Aggregate count and size of transaction outputs\n */\nexport class OutputDimensions {\n  /**\n   * Number of outputs\n   */\n  count: number;\n  /**\n   * Aggregate vSize\n   */\n  size: number;\n\n  constructor({ count = 0, size = 0 }: OutputDimensions = { count: 0, size: 0 }) {\n    if (count === 0 || size === 0) {\n      if (count !== 0 || size !== 0) {\n        throw new Error(`count and size must both be zero if one is zero`);\n      }\n    }\n\n    this.count = count;\n    this.size = size;\n\n    Object.freeze(this);\n  }\n}\n\ninterface FromInputParams {\n  // In cases where the input type is ambiguous, we must provide a hint about spend script type.\n  assumeUnsigned?: Dimensions;\n}\n\nexport interface FromUnspentParams {\n  p2tr: {\n    scriptPathLevel?: number;\n  };\n  p2trMusig2: {\n    scriptPathLevel?: number;\n  };\n}\n\nconst defaultUnspentParams: FromUnspentParams = {\n  p2tr: {\n    // Default to recovery script paths, to make it easier for recovery case callers (WRW etc).\n    // WP can explicitly pass scriptPathLevel: 1 to use happy path.\n    scriptPathLevel: 2,\n  },\n  p2trMusig2: {\n    // Default to script path spend, to make it easier for recovery case callers (WRW etc).\n    // WP can explicitly pass scriptPathLevel: undefined to use key path.\n    scriptPathLevel: 1,\n  },\n};\n\n/**\n * Dimensions of a BitGo wallet transactions.\n */\nexport class Dimensions {\n  /** Input counts for BitGo wallet multi-signature inputs */\n  public readonly nP2shInputs: number = 0;\n  public readonly nP2shP2wshInputs: number = 0;\n  public readonly nP2wshInputs: number = 0;\n  public readonly nP2trKeypathInputs: number = 0;\n  public readonly nP2trScriptPathLevel1Inputs: number = 0;\n  public readonly nP2trScriptPathLevel2Inputs: number = 0;\n\n  /* Input count for single-signature inputs (Replay Protection inputs) */\n  public readonly nP2shP2pkInputs: number = 0;\n\n  public readonly outputs: OutputDimensions = new OutputDimensions();\n\n  constructor(d: Partial<Dimensions> = {}) {\n    Object.entries(d).forEach(([key, value]) => this.setProperty(key, value));\n\n    Object.freeze(this);\n  }\n\n  private setProperty(k: string, v: unknown): void {\n    switch (k) {\n      case 'nP2shInputs':\n      case 'nP2shP2wshInputs':\n      case 'nP2wshInputs':\n      case 'nP2trKeypathInputs':\n      case 'nP2trScriptPathLevel1Inputs':\n      case 'nP2trScriptPathLevel2Inputs':\n      case 'nP2shP2pkInputs':\n        if (typeof v !== 'number') {\n          throw new Error(`property ${k} must be number`);\n        }\n        if (!Number.isSafeInteger(v) || v < 0) {\n          throw new Error(`property ${k} must be zero or positive integer`);\n        }\n        break;\n      case 'outputs':\n        if (!(v instanceof OutputDimensions)) {\n          v = new OutputDimensions(v as OutputDimensions);\n        }\n        break;\n      default:\n        throw new Error(`unknown property ${k}`);\n    }\n\n    (this as any)[k] = v;\n  }\n\n  static readonly ZERO = Object.freeze(new Dimensions());\n\n  /**\n   * @deprecated use ZERO\n   * @return Dimensions for an empty transaction\n   */\n  static zero(): Readonly<Dimensions> {\n    return this.ZERO;\n  }\n\n  /**\n   * @param size\n   * @return Dimensions for a single output with given size\n   */\n  static singleOutput(size: number): Dimensions {\n    return Dimensions.sum({ outputs: { count: 1, size } });\n  }\n\n  static readonly SingleOutput = Object.freeze({\n    p2sh: Dimensions.singleOutput(VirtualSizes.txP2shOutputSize),\n    p2shP2wsh: Dimensions.singleOutput(VirtualSizes.txP2shP2wshOutputSize),\n    p2wsh: Dimensions.singleOutput(VirtualSizes.txP2wshOutputSize),\n    p2tr: Dimensions.singleOutput(VirtualSizes.txP2trOutputSize),\n\n    p2pkh: Dimensions.singleOutput(VirtualSizes.txP2pkhOutputSize),\n    p2wpkh: Dimensions.singleOutput(VirtualSizes.txP2wpkhOutputSize),\n  });\n\n  /**\n   * @return Number of total inputs (p2sh + p2shP2wsh + p2wsh + p2tr)\n   */\n  get nInputs(): number {\n    return (\n      this.nP2shInputs +\n      this.nP2shP2wshInputs +\n      this.nP2wshInputs +\n      this.nP2trKeypathInputs +\n      this.nP2trScriptPathLevel1Inputs +\n      this.nP2trScriptPathLevel2Inputs +\n      this.nP2shP2pkInputs\n    );\n  }\n\n  set nInputs(_: number) {\n    throw new Error('read-only property nInputs');\n  }\n\n  /**\n   * @return Number of total outputs\n   */\n  get nOutputs(): number {\n    return this.outputs.count;\n  }\n\n  set nOutputs(_: number) {\n    throw new Error(`read-only property nOutputs`);\n  }\n\n  /**\n   * @param args - Dimensions (can be partially defined)\n   * @return {Dimensions} sum of arguments\n   */\n  static sum(...args: Partial<Dimensions>[]): Dimensions {\n    return args.reduce((a: Dimensions, b: Partial<Dimensions>) => a.plus(b), new Dimensions());\n  }\n\n  /**\n   * @param chain\n   * @return {Number}\n   */\n  static getOutputScriptLengthForChain(chain: ChainCode): number {\n    switch (scriptTypeForChain(chain)) {\n      case 'p2wsh':\n      case 'p2tr':\n      case 'p2trMusig2':\n        return 34;\n      default:\n        return 23;\n    }\n  }\n\n  /**\n   * @param scriptLength\n   * @return {Number} vSize of an output with script length\n   */\n  static getVSizeForOutputWithScriptLength(scriptLength: number): number {\n    if (!PositiveInteger.is(scriptLength)) {\n      throw new TypeError(`expected positive integer for scriptLength, got ${scriptLength}`);\n    }\n    return scriptLength + compactSize(scriptLength) + VirtualSizes.txOutputAmountSize;\n  }\n\n  static readonly SingleInput = Object.freeze({\n    p2sh: Dimensions.sum({ nP2shInputs: 1 }),\n    p2shP2wsh: Dimensions.sum({ nP2shP2wshInputs: 1 }),\n    p2wsh: Dimensions.sum({ nP2wshInputs: 1 }),\n    p2trKeypath: Dimensions.sum({ nP2trKeypathInputs: 1 }),\n    p2trScriptPathLevel1: Dimensions.sum({ nP2trScriptPathLevel1Inputs: 1 }),\n    p2trScriptPathLevel2: Dimensions.sum({ nP2trScriptPathLevel2Inputs: 1 }),\n    p2shP2pk: Dimensions.sum({ nP2shP2pkInputs: 1 }),\n  });\n\n  /**\n   * @return\n   */\n  static fromScriptType(\n    scriptType: utxolib.bitgo.outputScripts.ScriptType | utxolib.bitgo.ParsedScriptType2Of3 | 'p2pkh',\n    params: {\n      scriptPathLevel?: number;\n    } = {}\n  ): Dimensions {\n    switch (scriptType) {\n      case 'p2sh':\n      case 'p2shP2wsh':\n      case 'p2wsh':\n      case 'p2shP2pk':\n        return Dimensions.SingleInput[scriptType];\n      case 'p2tr':\n      case 'taprootScriptPathSpend':\n        switch (params.scriptPathLevel) {\n          case 1:\n            return Dimensions.SingleInput.p2trScriptPathLevel1;\n          case 2:\n            return Dimensions.SingleInput.p2trScriptPathLevel2;\n          default:\n            throw new Error(`unexpected script path level`);\n        }\n      case 'p2trMusig2':\n        switch (params.scriptPathLevel) {\n          case undefined:\n            return Dimensions.SingleInput.p2trKeypath;\n          case 1:\n            return Dimensions.SingleInput.p2trScriptPathLevel1;\n          default:\n            throw new Error(`unexpected script path level`);\n        }\n      case 'taprootKeyPathSpend':\n        return Dimensions.SingleInput.p2trKeypath;\n      default:\n        throw new Error(`unexpected scriptType ${scriptType}`);\n    }\n  }\n\n  static readonly ASSUME_P2SH = Dimensions.SingleInput.p2sh;\n  static readonly ASSUME_P2SH_P2WSH = Dimensions.SingleInput.p2shP2wsh;\n  static readonly ASSUME_P2WSH = Dimensions.SingleInput.p2wsh;\n  static readonly ASSUME_P2TR_KEYPATH = Dimensions.SingleInput.p2trKeypath;\n  static readonly ASSUME_P2TR_SCRIPTPATH_LEVEL1 = Dimensions.SingleInput.p2trScriptPathLevel1;\n  static readonly ASSUME_P2TR_SCRIPTPATH_LEVEL2 = Dimensions.SingleInput.p2trScriptPathLevel2;\n  static readonly ASSUME_P2SH_P2PK_INPUT = Dimensions.SingleInput.p2shP2pk;\n\n  private static getAssumedDimension(params: FromInputParams = {}, index: number) {\n    const { assumeUnsigned } = params;\n    if (!assumeUnsigned) {\n      throw new Error(`illegal input ${index}: empty script and assumeUnsigned not set`);\n    }\n    return assumeUnsigned;\n  }\n\n  /**\n   * @param input - the transaction input to count\n   * @param params\n   *        [param.assumeUnsigned] - default type for unsigned input\n   */\n  static fromInput(input: utxolib.TxInput, params: FromInputParams = {}): Dimensions {\n    if (input.script?.length || input.witness?.length) {\n      const parsed = utxolib.bitgo.parseSignatureScript(input);\n      return Dimensions.fromScriptType(parsed.scriptType, parsed as { scriptPathLevel?: number });\n    }\n\n    return Dimensions.getAssumedDimension(params, input.index);\n  }\n\n  /**\n   * Create Dimensions from psbt input\n   * @param input - psbt input\n   */\n  static fromPsbtInput(input: bitgo.PsbtInputType): Dimensions {\n    const parsed = bitgo.parsePsbtInput(input);\n    return Dimensions.fromScriptType(parsed.scriptType, parsed as { scriptPathLevel?: number });\n  }\n\n  /**\n   * @param inputs - Array of inputs\n   * @param params - @see Dimensions.fromInput()\n   * @return {Dimensions} sum of the dimensions for each input (@see Dimensions.fromInput())\n   */\n  static fromInputs(inputs: utxolib.TxInput[], params?: FromInputParams): Dimensions {\n    if (!Array.isArray(inputs)) {\n      throw new TypeError(`inputs must be array`);\n    }\n    return Dimensions.sum(...inputs.map((i) => Dimensions.fromInput(i, params)));\n  }\n\n  /**\n   * Create Dimensions from multiple psbt inputs\n   * @param inputs psbt input array\n   * @return {Dimensions} sum of the dimensions for each input (@see Dimensions.fromPsbtInput())\n   */\n  static fromPsbtInputs(inputs: bitgo.PsbtInputType[]): Dimensions {\n    if (!Array.isArray(inputs)) {\n      throw new TypeError(`inputs must be array`);\n    }\n    return Dimensions.sum(...inputs.map((input, _) => Dimensions.fromPsbtInput(input)));\n  }\n\n  /**\n   * @param scriptLength {number} - size of the output script in bytes\n   * @return {Dimensions} - Dimensions of the output\n   */\n  static fromOutputScriptLength(scriptLength: number): Dimensions {\n    return Dimensions.sum({\n      outputs: {\n        count: 1,\n        size: Dimensions.getVSizeForOutputWithScriptLength(scriptLength),\n      },\n    });\n  }\n\n  /**\n   * @param output - a tx output\n   * @return Dimensions - the dimensions of the given output\n   */\n  static fromOutput({ script }: { script: Buffer }): Dimensions {\n    if (!script) {\n      throw new Error('expected output script to be defined');\n    }\n    if (!Buffer.isBuffer(script)) {\n      throw new TypeError('expected script to be buffer, got ' + typeof script);\n    }\n    return Dimensions.fromOutputScriptLength(script.length);\n  }\n\n  /**\n   * @param outputs - Array of outputs\n   * @return {Dimensions} sum of the dimensions for each output (@see Dimensions.fromOutput())\n   */\n  static fromOutputs(outputs: { script: Buffer }[]): Dimensions {\n    if (!Array.isArray(outputs)) {\n      throw new TypeError(`outputs must be array`);\n    }\n    return Dimensions.sum(...outputs.map(Dimensions.fromOutput));\n  }\n\n  /**\n   * Returns the dimensions of an output that will be created on a specific chain.\n   * Currently, this simply adds a default output.\n   *\n   * @param chain - Chain code as defined by utxolib.bitgo\n   * @return {Dimensions} - Dimensions for a single output on the given chain.\n   */\n  static fromOutputOnChain(chain: ChainCode): Dimensions {\n    return Dimensions.fromOutputScriptLength(Dimensions.getOutputScriptLengthForChain(chain));\n  }\n\n  /**\n   * Return dimensions of an unspent according to `chain` parameter\n   * @param chain - Chain code as defined by utxo.chain\n   * @param params - Hint for unspents with variable input sizes (p2tr, p2trMusig2)\n   * @return {Dimensions} of the unspent\n   * @throws if the chain code is invalid or unsupported\n   */\n  static fromUnspent({ chain }: { chain: number }, params: FromUnspentParams = defaultUnspentParams): Dimensions {\n    if (!isChainCode(chain)) {\n      throw new TypeError('invalid chain code');\n    }\n\n    const scriptType = scriptTypeForChain(chain);\n\n    return Dimensions.fromScriptType(\n      scriptType,\n      scriptType === 'p2tr' ? params.p2tr : scriptType === 'p2trMusig2' ? params.p2trMusig2 : {}\n    );\n  }\n\n  /**\n   * @param unspents\n   * @param params - Hint for unspents with variable input sizes (p2tr, p2trMusig2)\n   * @return {Dimensions} sum of the dimensions for each unspent (@see Dimensions.fromUnspent())\n   */\n  static fromUnspents(unspents: { chain: ChainCode }[], params: FromUnspentParams = defaultUnspentParams): Dimensions {\n    if (!Array.isArray(unspents)) {\n      throw new TypeError(`unspents must be array`);\n    }\n    // Convert the individual unspents into dimensions and sum them up\n    return Dimensions.sum(...unspents.map((u) => Dimensions.fromUnspent(u, params)));\n  }\n\n  /**\n   * @param transaction - bitcoin-like transaction\n   * @param [param.assumeUnsigned] - default type for unsigned inputs\n   * @return {Dimensions}\n   */\n  static fromTransaction(\n    {\n      ins,\n      outs,\n    }: {\n      ins: utxolib.TxInput[];\n      outs: utxolib.TxOutput[];\n    },\n    params?: FromInputParams\n  ): Dimensions {\n    return Dimensions.fromInputs(ins, params).plus(Dimensions.fromOutputs(outs));\n  }\n\n  /**\n   * Create Dimensions from psbt inputs and outputs\n   * @param psbt\n   * @return {Dimensions}\n   */\n  static fromPsbt(psbt: bitgo.UtxoPsbt): Dimensions {\n    return Dimensions.fromPsbtInputs(psbt.data.inputs).plus(Dimensions.fromOutputs(psbt.getUnsignedTx().outs));\n  }\n\n  /**\n   * @param dimensions (can be partially defined)\n   * @return new dimensions with argument added\n   */\n  plus(dimensions: Partial<Dimensions>): Dimensions {\n    if (typeof dimensions !== 'object') {\n      throw new TypeError(`expected argument to be object`);\n    }\n\n    if (!(dimensions instanceof Dimensions)) {\n      dimensions = new Dimensions(dimensions);\n    }\n\n    // Catch instances where we try to initialize Dimensions from partial data using deprecated parameters\n    // using only \"nOutputs\".\n    if ('nOutputs' in dimensions) {\n      if (!('outputs' in dimensions)) {\n        throw new Error('deprecated partial addition: argument has key \"nOutputs\" but no \"outputs\"');\n      }\n\n      const { outputs, nOutputs } = dimensions as Dimensions;\n\n      if (outputs.count !== nOutputs) {\n        throw new Error('deprecated partial addition: inconsistent values for \"nOutputs\" and \"outputs.count\"');\n      }\n    }\n\n    return mapDimensions(this, (key, v) => {\n      const w = dimensions[key] ?? Dimensions.ZERO[key];\n      if (key === 'outputs') {\n        const vOutputs = v as OutputDimensions;\n        const wOutputs = w as OutputDimensions;\n        return new OutputDimensions({\n          count: vOutputs.count + wOutputs.count,\n          size: vOutputs.size + wOutputs.size,\n        });\n      }\n      return (v as number) + (w as number);\n    });\n  }\n\n  /**\n   * Multiply dimensions by a given factor\n   * @param factor - Positive integer\n   * @return {Dimensions}\n   */\n  times(factor: number): Dimensions {\n    if (!PositiveInteger.is(factor)) {\n      throw new TypeError(`expected factor to be positive integer`);\n    }\n\n    return mapDimensions(this, (key, value) => {\n      if (key === 'outputs') {\n        const vOutputs = value as OutputDimensions;\n        return {\n          count: vOutputs.count * factor,\n          size: vOutputs.size * factor,\n        };\n      }\n      return (value as number) * factor;\n    });\n  }\n\n  /**\n   * @return Number of total inputs (p2sh, p2shP2wsh and p2wsh)\n   * @deprecated use `dimension.nInputs` instead\n   */\n  getNInputs(): number {\n    return this.nInputs;\n  }\n\n  /**\n   * @returns {boolean} true iff dimensions have one or more (p2sh)p2wsh inputs\n   */\n  isSegwit(): boolean {\n    return (\n      this.nP2wshInputs +\n        this.nP2shP2wshInputs +\n        this.nP2trKeypathInputs +\n        this.nP2trScriptPathLevel1Inputs +\n        this.nP2trScriptPathLevel2Inputs >\n      0\n    );\n  }\n\n  /**\n   * @return {Number} overhead vsize, based on result isSegwit().\n   */\n  getOverheadVSize(): number {\n    return this.isSegwit() ? VirtualSizes.txSegOverheadVSize : VirtualSizes.txOverheadSize;\n  }\n\n  /**\n   * @returns {number} vsize of inputs, without transaction overhead\n   */\n  getInputsVSize(): number {\n    const {\n      txP2shInputSize,\n      txP2shP2wshInputSize,\n      txP2wshInputSize,\n      txP2trKeypathInputSize,\n      txP2trScriptPathLevel1InputSize,\n      txP2trScriptPathLevel2InputSize,\n      txP2shP2pkInputSize,\n    } = VirtualSizes;\n\n    const {\n      nP2shInputs,\n      nP2shP2wshInputs,\n      nP2wshInputs,\n      nP2trKeypathInputs,\n      nP2trScriptPathLevel1Inputs,\n      nP2trScriptPathLevel2Inputs,\n      nP2shP2pkInputs,\n    } = this;\n\n    const size =\n      nP2shInputs * txP2shInputSize +\n      nP2shP2wshInputs * txP2shP2wshInputSize +\n      nP2wshInputs * txP2wshInputSize +\n      nP2trKeypathInputs * txP2trKeypathInputSize +\n      nP2shP2pkInputs * txP2shP2pkInputSize +\n      nP2trScriptPathLevel1Inputs * txP2trScriptPathLevel1InputSize +\n      nP2trScriptPathLevel2Inputs * txP2trScriptPathLevel2InputSize;\n    if (Number.isNaN(size)) {\n      throw new Error(`invalid size`);\n    }\n\n    return size;\n  }\n\n  /**\n   * @returns {number} return vsize of outputs, without overhead\n   */\n  getOutputsVSize(): number {\n    return this.outputs.size;\n  }\n\n  /**\n   * Estimates the virtual size (1/4 weight) of a signed transaction as sum of\n   * overhead vsize, input vsize and output vsize.\n   * @returns {Number} The estimated vsize of the transaction dimensions.\n   */\n  getVSize(): number {\n    return this.getOverheadVSize() + this.getInputsVSize() + this.getOutputsVSize();\n  }\n}\n"]}

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

@@ -5,3 +5,4 @@ Codes,
 /** @deprecated - use utxolib.bitgo */
 CodesTypes, };
 export * from './dimensions';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,UAAU,MAAM,SAAS,CAAC;AAC7C,OAAO;AACL,sCAAsC;AACtC,KAAK;AACL,sCAAsC;AACtC,UAAU,GACX,CAAC;AAEF,cAAc,cAAc,CAAC"}

package/dist/{index.js → src/index.js}

@@ -27,4 +27,4 @@ const codes_1 = __importStar(require("./codes")), CodesTypes = codes_1;
 exports.Codes = codes_1.default;
 exports.CodesTypes = CodesTypes;
 __exportStar(require("./dimensions"), exports);
-//# sourceMappingURL=index.js.map
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7OztBQUFBLHVFQUE2QztBQUczQyxnQkFISyxlQUFLLENBR0w7QUFFTCxnQ0FBVTtBQUdaLCtDQUE2QiIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCBDb2RlcywgKiBhcyBDb2Rlc1R5cGVzIGZyb20gJy4vY29kZXMnO1xuZXhwb3J0IHtcbiAgLyoqIEBkZXByZWNhdGVkIC0gdXNlIHV0eG9saWIuYml0Z28gKi9cbiAgQ29kZXMsXG4gIC8qKiBAZGVwcmVjYXRlZCAtIHVzZSB1dHhvbGliLmJpdGdvICovXG4gIENvZGVzVHlwZXMsXG59O1xuXG5leHBvcnQgKiBmcm9tICcuL2RpbWVuc2lvbnMnO1xuIl19

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

@@ -23,3 +23,4 @@ export declare const inputComponentsP2trKeySpend: InputComponents;
 export declare const inputComponentsP2trScriptSpendLevel1: InputComponents;
 export declare const inputComponentsP2trScriptSpendLevel2: InputComponents;
 export declare const inputComponentsP2shP2pk: InputComponents;
+//# sourceMappingURL=inputWeights.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"inputWeights.d.ts","sourceRoot":"","sources":["../../src/inputWeights.ts"],"names":[],"mappings":"AAAA;;GAEG;AAIH,wBAAgB,YAAY,CAAC,UAAU,EAAE,KAAK,GAAG,MAAM,CAItD;AAaD,oBAAY,KAAK,GAAG;IAClB,MAAM,EAAE,MAAM,CAAC;CAChB,CAAC;AAEF,oBAAY,KAAK,GAAG;IAClB,MAAM,EAAE,KAAK,CAAC;IACd,OAAO,EAAE,KAAK,EAAE,CAAC;CAClB,CAAC;AAEF,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,KAAK,EAAE,YAAY,EAAE,OAAO,GAAG,MAAM,CAM9E;AAED,wBAAgB,cAAc,CAAC,KAAK,EAAE,KAAK,GAAG,MAAM,CAEnD;AAED,oBAAY,eAAe,GAAG;IAC5B,MAAM,EAAE,MAAM,EAAE,CAAC;IACjB,OAAO,EAAE,MAAM,EAAE,CAAC;CACnB,CAAC;AAEF,wBAAgB,wBAAwB,CAAC,CAAC,EAAE,eAAe,GAAG,MAAM,CAMnE;AAgCD,eAAO,MAAM,mBAAmB,EAAE,eAGjC,CAAC;AAEF,eAAO,MAAM,wBAAwB,EAAE,eAGtC,CAAC;AAEF,eAAO,MAAM,oBAAoB,EAAE,eAGlC,CAAC;AAGF,eAAO,MAAM,2BAA2B,EAAE,eAGzC,CAAC;AAEF,eAAO,MAAM,oCAAoC,EAAE,eAGlD,CAAC;AAEF,eAAO,MAAM,oCAAoC,EAAE,eAGlD,CAAC;AAEF,eAAO,MAAM,uBAAuB,EAAE,eAGrC,CAAC"}