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

package/dist/dimensions.js

@@ -1,490 +0,0 @@
-"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: {
-        scriptPathLevel: 1,
-    },
-    p2trMusig2: {
-        // Default to script path spend, to make it easier for recovery case callers (WRW etc).
-        // WP can explicitly pass 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 psbt - psbt
-     * @param inputIndex - psbt input index
-     */
-    static fromPsbtInput(psbt, inputIndex) {
-        const parsed = utxolib.bitgo.parsePsbtInput(psbt, inputIndex);
-        if (parsed && parsed.scriptType) {
-            return Dimensions.fromScriptType(parsed.scriptType, parsed);
-        }
-        throw new Error(`illegal input ${inputIndex}: empty script`);
-    }
-    /**
-     * @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 psbt
-     * @param params - @see Dimensions.fromInput()
-     * @return {Dimensions} sum of the dimensions for each input (@see Dimensions.fromInput())
-     */
-    static fromPsbtInputs(psbt) {
-        if (!Array.isArray(psbt.txInputs)) {
-            throw new TypeError(`psbt must have inputs`);
-        }
-        return Dimensions.sum(...psbt.txInputs.map((input, inputIndex) => Dimensions.fromPsbtInput(psbt, inputIndex)));
-    }
-    /**
-     * @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).
-     * @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
-     * @return {Dimensions} sum of the dimensions for each unspent (@see Dimensions.fromUnspent())
-     */
-    static fromUnspents(unspents) {
-        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)));
-    }
-    /**
-     * @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).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=dimensions.js.map

package/dist/inputWeights.js

@@ -1,97 +0,0 @@
-"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 = exports.getInputComponentsWeight = exports.getInputWeight = exports.getInputByteLength = exports.varSliceSize = void 0;
-const varuint_bitcoin_1 = __importDefault(require("varuint-bitcoin"));
-function varSliceSize(someScript) {
-    const length = someScript.length;
-    return varuint_bitcoin_1.default.encodingLength(length) + length;
-}
-exports.varSliceSize = varSliceSize;
-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));
-}
-exports.getInputByteLength = getInputByteLength;
-function getInputWeight(input) {
-    return 3 * getInputByteLength(input, false) + getInputByteLength(input, true);
-}
-exports.getInputWeight = getInputWeight;
-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 })),
-    });
-}
-exports.getInputComponentsWeight = getInputComponentsWeight;
-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;
-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=inputWeights.js.map

package/dist/scriptSizes.js

@@ -1,51 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.compactSize = exports.pushdataEncodingLength = void 0;
-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`);
-}
-exports.pushdataEncodingLength = pushdataEncodingLength;
-/**
- * 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;
-}
-exports.compactSize = compactSize;
-//# sourceMappingURL=scriptSizes.js.map