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

package/dist/codes.js

@@ -1,168 +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.CodesByType = exports.CodesByPurpose = exports.CodeGroup = exports.isValid = exports.ChainType = exports.Purpose = exports.UnspentType = exports.ErrorInvalidCode = void 0;
-const tcomb = __importStar(require("tcomb"));
-class ErrorInvalidCode extends Error {
-    constructor(code) {
-        super(`invalid code ${code}`);
-    }
-}
-exports.ErrorInvalidCode = ErrorInvalidCode;
-var UnspentType;
-(function (UnspentType) {
-    UnspentType["p2pkh"] = "p2pkh";
-    UnspentType["p2sh"] = "p2sh";
-    UnspentType["p2shP2wsh"] = "p2shP2wsh";
-    UnspentType["p2wpkh"] = "p2wpkh";
-    UnspentType["p2wsh"] = "p2wsh";
-    UnspentType["p2tr"] = "p2tr";
-})(UnspentType = exports.UnspentType || (exports.UnspentType = {}));
-const UnspentTypeTcomb = tcomb.enums.of(Object.keys(UnspentType));
-var Purpose;
-(function (Purpose) {
-    Purpose["internal"] = "internal";
-    Purpose["external"] = "external";
-})(Purpose = exports.Purpose || (exports.Purpose = {}));
-const PurposeTcomb = tcomb.enums.of(Object.keys(Purpose));
-const codeList = Object.freeze([
-    [0, UnspentType.p2sh, Purpose.external],
-    [10, UnspentType.p2shP2wsh, Purpose.external],
-    [20, UnspentType.p2wsh, Purpose.external],
-    [30, UnspentType.p2tr, Purpose.external],
-    [1, UnspentType.p2sh, Purpose.internal],
-    [11, UnspentType.p2shP2wsh, Purpose.internal],
-    [21, UnspentType.p2wsh, Purpose.internal],
-    [31, UnspentType.p2tr, Purpose.internal],
-].map(([id, type, purpose]) => Object.freeze({ id, type, purpose })));
-exports.ChainType = tcomb.irreducible('ChainType', (n) => exports.isValid(n));
-const forType = (u) => {
-    // Do tcomb type checking in js projects that use this lib
-    if (!UnspentTypeTcomb.is(u)) {
-        throw new Error(`invalid unspent type: ${u}`);
-    }
-    return new CodesByPurpose(u);
-};
-const typeForCode = (c) => {
-    const code = codeList.find(({ id }) => id === c);
-    if (!code) {
-        throw new ErrorInvalidCode(c);
-    }
-    return code.type;
-};
-const isValid = (c) => codeList.some(({ id }) => id === c);
-exports.isValid = isValid;
-const throwIfUndefined = (v) => {
-    if (v === undefined) {
-        throw new Error(`expected value to be defined`);
-    }
-    return v;
-};
-class CodeGroup {
-    constructor(values) {
-        this.values = Object.freeze([...values]);
-    }
-    has(code) {
-        if (!exports.isValid(code)) {
-            throw new ErrorInvalidCode(code);
-        }
-        return this.values.includes(code);
-    }
-}
-exports.CodeGroup = CodeGroup;
-class CodesByPurpose extends CodeGroup {
-    constructor(t) {
-        const codeMap = new Map(codeList.filter(({ type }) => type === t).map(({ purpose, id }) => [purpose, id]));
-        if (codeMap.size !== 2) {
-            throw new Error(`unexpected number of codes for type ${t}`);
-        }
-        super(codeMap.values());
-        this.internal = throwIfUndefined(codeMap.get(Purpose.internal));
-        this.external = throwIfUndefined(codeMap.get(Purpose.external));
-    }
-}
-exports.CodesByPurpose = CodesByPurpose;
-class CodesByType extends CodeGroup {
-    constructor(p) {
-        const codeMap = new Map(codeList.filter(({ purpose }) => purpose === p).map(({ type, id }) => [type, id]));
-        if (codeMap.size !== 4) {
-            throw new Error(`unexpected number of codes`);
-        }
-        super(codeMap.values());
-        this.p2sh = throwIfUndefined(codeMap.get(UnspentType.p2sh));
-        this.p2shP2wsh = throwIfUndefined(codeMap.get(UnspentType.p2shP2wsh));
-        this.p2wsh = throwIfUndefined(codeMap.get(UnspentType.p2wsh));
-        this.p2tr = throwIfUndefined(codeMap.get(UnspentType.p2tr));
-    }
-}
-exports.CodesByType = CodesByType;
-const boundHas = (instance) => instance.has.bind(instance);
-const p2sh = Object.freeze(new CodesByPurpose(UnspentType.p2sh));
-const p2shP2wsh = Object.freeze(new CodesByPurpose(UnspentType.p2shP2wsh));
-const p2wsh = Object.freeze(new CodesByPurpose(UnspentType.p2wsh));
-const p2tr = Object.freeze(new CodesByPurpose(UnspentType.p2tr));
-const external = Object.freeze(new CodesByType(Purpose.external));
-const internal = Object.freeze(new CodesByType(Purpose.internal));
-const all = Object.freeze(codeList.map(({ id }) => id));
-/** @deprecated - use utxolib.bitgo */
-exports.default = Object.freeze({
-    /* @deprecated: use ChainCodeTcomb */
-    ChainType: exports.ChainType,
-    /** @deprecated - use utxolib.bitgo */
-    ChainCodeTcomb: exports.ChainType,
-    /** @deprecated - use utxolib.bitgo */
-    PurposeTcomb,
-    /** @deprecated - use utxolib.bitgo */
-    UnspentTypeTcomb,
-    /** @deprecated - use utxolib.bitgo */
-    p2sh,
-    /** @deprecated - use utxolib.bitgo */
-    p2shP2wsh,
-    /** @deprecated - use utxolib.bitgo */
-    p2wsh,
-    /** @deprecated - use utxolib.bitgo */
-    p2tr,
-    /** @deprecated - use utxolib.bitgo */
-    external,
-    /** @deprecated - use utxolib.bitgo */
-    internal,
-    /** @deprecated - use utxolib.bitgo */
-    all,
-    /** @deprecated - use utxolib.bitgo */
-    isP2sh: boundHas(p2sh),
-    /** @deprecated - use utxolib.bitgo */
-    isP2shP2wsh: boundHas(p2shP2wsh),
-    /** @deprecated - use utxolib.bitgo */
-    isP2wsh: boundHas(p2wsh),
-    /** @deprecated - use utxolib.bitgo */
-    isP2tr: boundHas(p2tr),
-    /** @deprecated - use utxolib.bitgo */
-    isExternal: boundHas(external),
-    /** @deprecated - use utxolib.bitgo */
-    isInternal: boundHas(internal),
-    /** @deprecated - use utxolib.bitgo */
-    isValid: exports.isValid,
-    /** @deprecated - use utxolib.bitgo */
-    forType,
-    /** @deprecated - use utxolib.bitgo */
-    typeForCode,
-});
-//# sourceMappingURL=codes.js.map

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/index.js

@@ -1,30 +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;
-};
-var __exportStar = (this && this.__exportStar) || function(m, exports) {
-    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.CodesTypes = exports.Codes = void 0;
-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