@onetokenfe/coinselect 3.1.16

package/third-party/utxo-lib/bs58check.js

@@ -0,0 +1,92 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.decodeBlake = decodeBlake;
+exports.decodeBlake256Key = decodeBlake256Key;
+exports.decodeBlake256 = decodeBlake256;
+exports.encodeBlake256 = encodeBlake256;
+exports.encode = encode;
+exports.decode = decode;
+exports.decodeAddress = decodeAddress;
+exports.encodeAddress = encodeAddress;
+const tslib_1 = require("tslib");
+const bchaddrjs_1 = tslib_1.__importDefault(require("bchaddrjs"));
+const bs58_1 = tslib_1.__importDefault(require("bs58"));
+const bs58check_1 = tslib_1.__importDefault(require("bs58check"));
+const networks_1 = require("./networks");
+const crypto_1 = require("./crypto");
+function decodeBlake(buffer) {
+    const want = buffer.subarray(-4);
+    const payload = buffer.subarray(0, -4);
+    const got = (0, crypto_1.blake256)((0, crypto_1.blake256)(payload)).subarray(0, 4);
+    if ((want[0] ^ got[0]) | (want[1] ^ got[1]) | (want[2] ^ got[2]) | (want[3] ^ got[3]))
+        throw new Error('invalid checksum');
+    return payload;
+}
+function decodeBlake256Key(key) {
+    const bytes = bs58_1.default.decode(key);
+    const buffer = Buffer.from(bytes);
+    return decodeBlake(buffer);
+}
+function decodeBlake256(address) {
+    const bytes = bs58_1.default.decode(address);
+    const buffer = Buffer.from(bytes);
+    if (buffer.length !== 26)
+        throw new Error(`${address} invalid address length`);
+    let payload;
+    try {
+        payload = decodeBlake(buffer);
+    }
+    catch (e) {
+        if (e instanceof Error) {
+            throw new Error(`${address} ${e.message}`);
+        }
+        throw new Error(`${address} ${e}`);
+    }
+    return payload;
+}
+function encodeBlake256(payload) {
+    const checksum = (0, crypto_1.blake256)((0, crypto_1.blake256)(payload)).subarray(0, 4);
+    return bs58_1.default.encode(Buffer.concat([payload, checksum]));
+}
+function encode(payload, network = networks_1.bitcoin) {
+    return (0, networks_1.isNetworkType)('decred', network) ? encodeBlake256(payload) : bs58check_1.default.encode(payload);
+}
+function decode(payload, network = networks_1.bitcoin) {
+    return (0, networks_1.isNetworkType)('decred', network) ? decodeBlake256(payload) : bs58check_1.default.decode(payload);
+}
+function decodeAddress(address, network = networks_1.bitcoin) {
+    let payload;
+    if ((0, networks_1.isNetworkType)('bitcoinCash', network)) {
+        if (!bchaddrjs_1.default.isCashAddress(address))
+            throw Error(`${address} is not a cash address`);
+        payload = Buffer.from(bs58check_1.default.decode(bchaddrjs_1.default.toLegacyAddress(address)));
+    }
+    else {
+        payload = Buffer.from(decode(address, network));
+    }
+    if (payload.length < 21)
+        throw new TypeError(`${address} is too short`);
+    if (payload.length > 22)
+        throw new TypeError(`${address} is too long`);
+    const multibyte = payload.length === 22;
+    const offset = multibyte ? 2 : 1;
+    const version = multibyte ? payload.readUInt16BE(0) : payload[0];
+    const hash = payload.subarray(offset);
+    return { version, hash };
+}
+function encodeAddress(hash, version, network = networks_1.bitcoin) {
+    const multibyte = version > 0xff;
+    const size = multibyte ? 22 : 21;
+    const offset = multibyte ? 2 : 1;
+    const payload = Buffer.allocUnsafe(size);
+    if (multibyte) {
+        payload.writeUInt16BE(version, 0);
+    }
+    else {
+        payload.writeUInt8(version, 0);
+    }
+    hash.copy(payload, offset);
+    const encoded = encode(payload, network);
+    return (0, networks_1.isNetworkType)('bitcoinCash', network) ? bchaddrjs_1.default.toCashAddress(encoded) : encoded;
+}
+//# sourceMappingURL=bs58check.js.map

package/third-party/utxo-lib/bufferutils.d.ts

@@ -0,0 +1,59 @@
+import * as varuint from 'varuint-bitcoin';
+export declare function verifuint(value: number, max: number): void;
+export declare function readUInt64LE(buffer: Buffer, offset: number): number;
+export declare function readUInt64LEasString(buffer: Buffer, offset: number): string;
+export declare function readInt64LE(buffer: Buffer, offset: number): number;
+export declare function writeUInt64LE(buffer: Buffer, value: number, offset: number): number;
+export declare function writeUInt64LEasString(buffer: Buffer, value: string | number, offset: number): number;
+export declare function writeInt64LE(buffer: Buffer, value: number, offset: number): number;
+export declare function readVarInt(buffer: Buffer, offset: number): {
+    number: number;
+    size: number;
+};
+export declare function writeVarInt(buffer: Buffer, number: number, offset: number): number;
+export declare function cloneBuffer(buffer: Buffer): Buffer;
+type PushDataSize = (len: number) => number;
+type ReadPushDataInt = (buffer: Buffer, offset: number) => {
+    opcode: number;
+    number: number;
+    size: number;
+};
+type WritePushDataInt = (buffer: Buffer, number: number, offset: number) => number;
+export declare const pushDataSize: PushDataSize;
+export declare const readPushDataInt: ReadPushDataInt;
+export declare const varIntSize: typeof varuint.encodingLength;
+export declare const writePushDataInt: WritePushDataInt;
+export declare const reverseBuffer: (src: Buffer) => Buffer, getChunkSize: (n: number) => Buffer;
+export declare class BufferWriter {
+    buffer: Buffer;
+    offset: number;
+    constructor(buffer: Buffer, offset?: number);
+    writeUInt8(i: number): void;
+    writeUInt16(i: number): void;
+    writeInt32(i: number): void;
+    writeUInt32(i: number): void;
+    writeInt64(i: number): void;
+    writeUInt64(i: number | string): void;
+    writeVarInt(i: number): void;
+    writeSlice(slice: Buffer): void;
+    writeVarSlice(slice: Buffer): void;
+    writeVector(vector: Buffer[]): void;
+}
+export declare class BufferReader {
+    buffer: Buffer;
+    offset: number;
+    constructor(buffer: Buffer, offset?: number);
+    readUInt8(): number;
+    readUInt16(): number;
+    readInt32(): number;
+    readUInt32(): number;
+    readInt64(): number;
+    readUInt64(): number;
+    readUInt64String(): string;
+    readVarInt(): number;
+    readSlice(n: number): Buffer;
+    readVarSlice(): Buffer;
+    readVector(): Buffer[];
+}
+export {};
+//# sourceMappingURL=bufferutils.d.ts.map

package/third-party/utxo-lib/bufferutils.js

@@ -0,0 +1,219 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BufferReader = exports.BufferWriter = exports.getChunkSize = exports.reverseBuffer = exports.writePushDataInt = exports.varIntSize = exports.readPushDataInt = exports.pushDataSize = void 0;
+exports.verifuint = verifuint;
+exports.readUInt64LE = readUInt64LE;
+exports.readUInt64LEasString = readUInt64LEasString;
+exports.readInt64LE = readInt64LE;
+exports.writeUInt64LE = writeUInt64LE;
+exports.writeUInt64LEasString = writeUInt64LEasString;
+exports.writeInt64LE = writeInt64LE;
+exports.readVarInt = readVarInt;
+exports.writeVarInt = writeVarInt;
+exports.cloneBuffer = cloneBuffer;
+const tslib_1 = require("tslib");
+const bn_js_1 = tslib_1.__importDefault(require("bn.js"));
+const pushdata_bitcoin_1 = tslib_1.__importDefault(require("pushdata-bitcoin"));
+const varuint = tslib_1.__importStar(require("varuint-bitcoin"));
+const int64_buffer_1 = require("int64-buffer");
+const utils_1 = require("../utils");
+const types = tslib_1.__importStar(require("./types"));
+const OUT_OF_RANGE_ERROR = 'value out of range';
+function verifuint(value, max) {
+    if (typeof value !== 'number')
+        throw new Error('cannot write a non-number as a number');
+    if (value < 0)
+        throw new Error('specified a negative value for writing an unsigned value');
+    if (value > max)
+        throw new Error(OUT_OF_RANGE_ERROR);
+    if (Math.floor(value) !== value)
+        throw new Error('value has a fractional component');
+}
+function readUInt64LE(buffer, offset) {
+    const a = buffer.readUInt32LE(offset);
+    let b = buffer.readUInt32LE(offset + 4);
+    b *= 0x100000000;
+    verifuint(b + a, 0x001fffffffffffff);
+    return b + a;
+}
+function readUInt64LEasString(buffer, offset) {
+    try {
+        const result = readUInt64LE(buffer, offset);
+        return result.toString();
+    }
+    catch (_a) {
+        const aUint = buffer.readUInt32LE(offset);
+        const bUint = buffer.readUInt32LE(offset + 4);
+        const m = new bn_js_1.default(0x100000000);
+        const a = new bn_js_1.default(aUint);
+        const b = new bn_js_1.default(bUint).mul(m);
+        return a.add(b).toString();
+    }
+}
+function readInt64LE(buffer, offset) {
+    const a = buffer.readUInt32LE(offset);
+    let b = buffer.readInt32LE(offset + 4);
+    b *= 0x100000000;
+    return b + a;
+}
+function writeUInt64LE(buffer, value, offset) {
+    verifuint(value, 0x001fffffffffffff);
+    buffer.writeInt32LE(value & -1, offset);
+    buffer.writeUInt32LE(Math.floor(value / 0x100000000), offset + 4);
+    return offset + 8;
+}
+function writeUInt64LEasString(buffer, value, offset) {
+    if (typeof value !== 'string') {
+        return writeUInt64LE(buffer, value, offset);
+    }
+    const v = new int64_buffer_1.Int64LE(value);
+    v.toBuffer().copy(buffer, offset);
+    return offset + 8;
+}
+function writeInt64LE(buffer, value, offset) {
+    const v = new int64_buffer_1.Int64LE(value);
+    const a = v.toArray();
+    for (let i = 0; i < 8; i++) {
+        buffer.writeUInt8(a[i], offset + i);
+    }
+    return offset + 8;
+}
+function readVarInt(buffer, offset) {
+    const { numberValue, bytes } = varuint.decode(buffer, offset);
+    if (numberValue === null)
+        throw new Error(OUT_OF_RANGE_ERROR);
+    return {
+        number: numberValue,
+        size: bytes,
+    };
+}
+function writeVarInt(buffer, number, offset) {
+    const { bytes } = varuint.encode(number, buffer, offset);
+    return bytes;
+}
+function cloneBuffer(buffer) {
+    const clone = Buffer.allocUnsafe(buffer.length);
+    buffer.copy(clone);
+    return clone;
+}
+exports.pushDataSize = pushdata_bitcoin_1.default.encodingLength;
+exports.readPushDataInt = pushdata_bitcoin_1.default.decode;
+exports.varIntSize = varuint.encodingLength;
+exports.writePushDataInt = pushdata_bitcoin_1.default.encode;
+exports.reverseBuffer = utils_1.bufferUtils.reverseBuffer, exports.getChunkSize = utils_1.bufferUtils.getChunkSize;
+class BufferWriter {
+    constructor(buffer, offset = 0) {
+        this.buffer = buffer;
+        this.offset = offset;
+        types.typeforce(types.tuple(types.Buffer, types.UInt32), [buffer, offset]);
+    }
+    writeUInt8(i) {
+        this.offset = this.buffer.writeUInt8(i, this.offset);
+    }
+    writeUInt16(i) {
+        this.offset = this.buffer.writeUInt16LE(i, this.offset);
+    }
+    writeInt32(i) {
+        this.offset = this.buffer.writeInt32LE(i, this.offset);
+    }
+    writeUInt32(i) {
+        this.offset = this.buffer.writeUInt32LE(i, this.offset);
+    }
+    writeInt64(i) {
+        this.offset = writeInt64LE(this.buffer, i, this.offset);
+    }
+    writeUInt64(i) {
+        this.offset =
+            typeof i === 'string'
+                ? writeUInt64LEasString(this.buffer, i, this.offset)
+                : writeUInt64LE(this.buffer, i, this.offset);
+    }
+    writeVarInt(i) {
+        const { bytes } = varuint.encode(i, this.buffer, this.offset);
+        this.offset += bytes;
+    }
+    writeSlice(slice) {
+        if (this.buffer.length < this.offset + slice.length) {
+            throw new Error('Cannot write slice out of bounds');
+        }
+        this.offset += slice.copy(this.buffer, this.offset);
+    }
+    writeVarSlice(slice) {
+        this.writeVarInt(slice.length);
+        this.writeSlice(slice);
+    }
+    writeVector(vector) {
+        this.writeVarInt(vector.length);
+        vector.forEach((buf) => this.writeVarSlice(buf));
+    }
+}
+exports.BufferWriter = BufferWriter;
+class BufferReader {
+    constructor(buffer, offset = 0) {
+        this.buffer = buffer;
+        this.offset = offset;
+        types.typeforce(types.tuple(types.Buffer, types.UInt32), [buffer, offset]);
+    }
+    readUInt8() {
+        const result = this.buffer.readUInt8(this.offset);
+        this.offset++;
+        return result;
+    }
+    readUInt16() {
+        const result = this.buffer.readUInt16LE(this.offset);
+        this.offset += 2;
+        return result;
+    }
+    readInt32() {
+        const result = this.buffer.readInt32LE(this.offset);
+        this.offset += 4;
+        return result;
+    }
+    readUInt32() {
+        const result = this.buffer.readUInt32LE(this.offset);
+        this.offset += 4;
+        return result;
+    }
+    readInt64() {
+        const result = readInt64LE(this.buffer, this.offset);
+        this.offset += 8;
+        return result;
+    }
+    readUInt64() {
+        const result = readUInt64LE(this.buffer, this.offset);
+        this.offset += 8;
+        return result;
+    }
+    readUInt64String() {
+        const result = readUInt64LEasString(this.buffer, this.offset);
+        this.offset += 8;
+        return result;
+    }
+    readVarInt() {
+        const { numberValue, bytes } = varuint.decode(this.buffer, this.offset);
+        if (numberValue === null)
+            throw new Error(OUT_OF_RANGE_ERROR);
+        this.offset += bytes;
+        return numberValue;
+    }
+    readSlice(n) {
+        if (this.buffer.length < this.offset + n) {
+            throw new Error('Cannot read slice out of bounds');
+        }
+        const result = this.buffer.subarray(this.offset, this.offset + n);
+        this.offset += n;
+        return result;
+    }
+    readVarSlice() {
+        return this.readSlice(this.readVarInt());
+    }
+    readVector() {
+        const count = this.readVarInt();
+        const vector = [];
+        for (let i = 0; i < count; i++)
+            vector.push(this.readVarSlice());
+        return vector;
+    }
+}
+exports.BufferReader = BufferReader;
+//# sourceMappingURL=bufferutils.js.map

package/third-party/utxo-lib/coinselect/coinselectUtils.d.ts

@@ -0,0 +1,53 @@
+import BN from 'bn.js';
+import { CoinSelectPaymentType, CoinSelectAlgorithm, CoinSelectOptions, CoinSelectInput, CoinSelectOutput, CoinSelectOutputFinal } from '../types';
+import { Network } from '../networks';
+export declare const ZERO: BN;
+export declare const INPUT_SCRIPT_LENGTH: Record<CoinSelectPaymentType, number>;
+export declare const OUTPUT_SCRIPT_LENGTH: Record<CoinSelectPaymentType, number>;
+type Vin = {
+    type: CoinSelectInput['type'];
+    script: {
+        length: number;
+    };
+    weight?: number;
+};
+type VinVout = {
+    script: {
+        length: number;
+    };
+    weight?: number;
+};
+export declare function getVarIntSize(length: number): 5 | 1 | 3 | 9;
+export declare function inputWeight(input: Vin): number;
+export declare function inputBytes(input: Vin): number;
+export declare function outputWeight(output: VinVout): number;
+export declare function outputBytes(output: VinVout): number;
+export declare function getFeeForBytes(feeRate: number, bytes: number): number;
+export declare function transactionWeight(inputs: Vin[], outputs: VinVout[]): number;
+export declare function transactionBytes(inputs: Vin[], outputs: VinVout[]): number;
+export declare function getDustAmount(feeRate: number, { txType, longTermFeeRate, dustThreshold, }: Pick<CoinSelectOptions, 'txType' | 'longTermFeeRate' | 'dustThreshold'>): number;
+export declare function bignumberOrNaN(v?: BN | string): BN | undefined;
+export declare function bignumberOrNaN<F extends boolean>(v?: BN | string, forgiving?: F): F extends true ? BN : BN | undefined;
+export declare function sumOrNaN(range: {
+    value?: BN;
+}[]): BN | undefined;
+export declare function sumOrNaN<F extends boolean>(range: {
+    value?: BN;
+}[], forgiving: F): F extends true ? BN : BN | undefined;
+export declare function getFeePolicy(network?: Network): "bitcoin" | "doge" | "zcash";
+export declare function getFee(inputs: CoinSelectInput[], outputs: CoinSelectOutput[], feeRate: number, { feePolicy, ...options }?: Partial<CoinSelectOptions>): number;
+export declare function finalize(inputs: CoinSelectInput[], outputs: CoinSelectOutput[], feeRate: number, options: CoinSelectOptions): {
+    fee: number;
+    inputs?: undefined;
+    outputs?: undefined;
+} | {
+    inputs: CoinSelectInput[];
+    outputs: CoinSelectOutputFinal[];
+    fee: number;
+};
+export declare function anyOf(algorithms: CoinSelectAlgorithm[]): CoinSelectAlgorithm;
+export declare function utxoScore(x: CoinSelectInput, feeRate: number): BN;
+export declare function sortByScore(feeRate: number): (a: CoinSelectInput, b: CoinSelectInput) => number;
+export declare function filterCoinbase(utxos: CoinSelectInput[], minConfCoinbase: number): CoinSelectInput[];
+export {};
+//# sourceMappingURL=coinselectUtils.d.ts.map

package/third-party/utxo-lib/coinselect/coinselectUtils.js

@@ -0,0 +1,232 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OUTPUT_SCRIPT_LENGTH = exports.INPUT_SCRIPT_LENGTH = exports.ZERO = void 0;
+exports.getVarIntSize = getVarIntSize;
+exports.inputWeight = inputWeight;
+exports.inputBytes = inputBytes;
+exports.outputWeight = outputWeight;
+exports.outputBytes = outputBytes;
+exports.getFeeForBytes = getFeeForBytes;
+exports.transactionWeight = transactionWeight;
+exports.transactionBytes = transactionBytes;
+exports.getDustAmount = getDustAmount;
+exports.bignumberOrNaN = bignumberOrNaN;
+exports.sumOrNaN = sumOrNaN;
+exports.getFeePolicy = getFeePolicy;
+exports.getFee = getFee;
+exports.finalize = finalize;
+exports.anyOf = anyOf;
+exports.utxoScore = utxoScore;
+exports.sortByScore = sortByScore;
+exports.filterCoinbase = filterCoinbase;
+const tslib_1 = require("tslib");
+const bn_js_1 = tslib_1.__importDefault(require("bn.js"));
+const networks_1 = require("../networks");
+exports.ZERO = new bn_js_1.default(0);
+exports.INPUT_SCRIPT_LENGTH = {
+    p2pkh: 108,
+    p2sh: 107,
+    p2tr: 65,
+    p2wpkh: 107,
+    p2wsh: 107,
+};
+exports.OUTPUT_SCRIPT_LENGTH = {
+    p2pkh: 25,
+    p2sh: 23,
+    p2tr: 34,
+    p2wpkh: 22,
+    p2wsh: 34,
+};
+const SEGWIT_INPUT_SCRIPT_TYPES = ['p2sh', 'p2tr', 'p2wpkh', 'p2wsh'];
+const TX_BASE = 32;
+const INPUT_SIZE = 160;
+const DUST_RELAY_FEE_RATE = 3;
+function getVarIntSize(length) {
+    if (length < 253)
+        return 1;
+    if (length < 65536)
+        return 3;
+    if (length < 4294967296)
+        return 5;
+    return 9;
+}
+function inputWeight(input) {
+    if (input.weight)
+        return input.weight;
+    let weight = INPUT_SIZE;
+    if (!SEGWIT_INPUT_SCRIPT_TYPES.includes(input.type)) {
+        weight += 4 * input.script.length;
+    }
+    else {
+        if (input.type === 'p2sh') {
+            weight += 4 * (2 + 22);
+        }
+        else {
+            weight += 4;
+        }
+        weight += 1 + input.script.length;
+    }
+    return weight;
+}
+function inputBytes(input) {
+    return Math.ceil(inputWeight(input) / 4);
+}
+function outputWeight(output) {
+    if (output.weight)
+        return output.weight;
+    return 4 * (8 + 1 + output.script.length);
+}
+function outputBytes(output) {
+    return Math.ceil(outputWeight(output) / 4);
+}
+function getFeeForBytes(feeRate, bytes) {
+    return Math.ceil(feeRate * bytes);
+}
+function transactionWeight(inputs, outputs) {
+    const segwitInputs = inputs.filter(i => SEGWIT_INPUT_SCRIPT_TYPES.includes(i.type)).length;
+    return (TX_BASE +
+        4 * getVarIntSize(inputs.length) +
+        inputs.reduce((x, i) => x + inputWeight(i), 0) +
+        4 * getVarIntSize(outputs.length) +
+        outputs.reduce((x, o) => x + outputWeight(o), 0) +
+        (segwitInputs ? 2 + (inputs.length - segwitInputs) : 0));
+}
+function transactionBytes(inputs, outputs) {
+    return Math.ceil(transactionWeight(inputs, outputs) / 4);
+}
+function getDustAmount(feeRate, { txType, longTermFeeRate, dustThreshold, }) {
+    const inputSize = inputBytes({
+        type: txType,
+        script: {
+            length: exports.INPUT_SCRIPT_LENGTH[txType],
+        },
+    });
+    const longTermFee = longTermFeeRate ? Math.min(feeRate, longTermFeeRate) : 0;
+    const dustRelayFeeRate = Math.max(longTermFee, DUST_RELAY_FEE_RATE);
+    return Math.max(dustThreshold || 0, getFeeForBytes(dustRelayFeeRate, inputSize));
+}
+function bignumberOrNaN(v, forgiving = false) {
+    if (bn_js_1.default.isBN(v))
+        return v;
+    const defaultValue = forgiving ? exports.ZERO : undefined;
+    if (!v || typeof v !== 'string' || !/^\d+$/.test(v))
+        return defaultValue;
+    try {
+        return new bn_js_1.default(v);
+    }
+    catch (_a) {
+        return defaultValue;
+    }
+}
+function sumOrNaN(range, forgiving = false) {
+    return range.reduce((a, x) => {
+        if (!a)
+            return a;
+        const value = bignumberOrNaN(x.value);
+        if (!value)
+            return forgiving ? exports.ZERO.add(a) : undefined;
+        return value.add(a);
+    }, exports.ZERO);
+}
+function getFeePolicy(network) {
+    if ((0, networks_1.isNetworkType)('doge', network))
+        return 'doge';
+    if ((0, networks_1.isNetworkType)('zcash', network))
+        return 'zcash';
+    return 'bitcoin';
+}
+function getBitcoinFee(inputs, outputs, feeRate, { baseFee = 0, floorBaseFee }) {
+    const bytes = transactionBytes(inputs, outputs);
+    const defaultFee = getFeeForBytes(feeRate, bytes);
+    return baseFee && floorBaseFee
+        ?
+            baseFee * (1 + Math.floor(defaultFee / baseFee))
+        :
+            baseFee + defaultFee;
+}
+function getDogeFee(inputs, outputs, feeRate, _a) {
+    var { dustThreshold = 0 } = _a, options = tslib_1.__rest(_a, ["dustThreshold"]);
+    const fee = getBitcoinFee(inputs, outputs, feeRate, options);
+    const limit = new bn_js_1.default(dustThreshold);
+    const dustOutputsCount = outputs.filter(({ value }) => value && value.lt(limit)).length;
+    return fee + dustOutputsCount * dustThreshold;
+}
+const MARGINAL_FEE_ZAT_PER_ACTION = 5000;
+const GRACE_ACTIONS = 2;
+const P2PKH_STANDARD_INPUT_SIZE = 150;
+const P2PKH_STANDARD_OUTPUT_SIZE = 34;
+function getZcashFee(inputs, outputs, feeRate, options) {
+    const fee = getBitcoinFee(inputs, outputs, feeRate, options);
+    const txInTotalBytes = inputs.reduce((sum, i) => sum + inputBytes(i), 0);
+    const txOutTotalBytes = outputs.reduce((sum, o) => sum + outputBytes(o), 0);
+    const actions = Math.max(GRACE_ACTIONS, Math.ceil(txInTotalBytes / P2PKH_STANDARD_INPUT_SIZE), Math.ceil(txOutTotalBytes / P2PKH_STANDARD_OUTPUT_SIZE));
+    return Math.max(actions * MARGINAL_FEE_ZAT_PER_ACTION, fee);
+}
+function getFee(inputs, outputs, feeRate, _a = {}) {
+    var { feePolicy } = _a, options = tslib_1.__rest(_a, ["feePolicy"]);
+    switch (feePolicy) {
+        case 'doge':
+            return getDogeFee(inputs, outputs, feeRate, options);
+        case 'zcash':
+            return getZcashFee(inputs, outputs, feeRate, options);
+        default:
+            return getBitcoinFee(inputs, outputs, feeRate, options);
+    }
+}
+function finalize(inputs, outputs, feeRate, options) {
+    const changeOutput = options.changeOutput || {
+        script: { length: exports.OUTPUT_SCRIPT_LENGTH[options.txType] },
+    };
+    const fee = getFee(inputs, outputs, feeRate, options);
+    const feeAfterExtraOutput = getFee(inputs, [...outputs, changeOutput], feeRate, options);
+    const sumInputs = sumOrNaN(inputs);
+    const sumOutputs = sumOrNaN(outputs);
+    if (!sumInputs || !sumOutputs || sumInputs.sub(sumOutputs).lt(new bn_js_1.default(fee))) {
+        return { fee };
+    }
+    const remainderAfterExtraOutput = sumInputs.sub(sumOutputs.add(new bn_js_1.default(feeAfterExtraOutput)));
+    const dustAmount = getDustAmount(feeRate, options);
+    const finalOutputs = [...outputs];
+    if (remainderAfterExtraOutput.gte(new bn_js_1.default(dustAmount))) {
+        finalOutputs.push(Object.assign(Object.assign({}, changeOutput), { value: remainderAfterExtraOutput }));
+    }
+    return {
+        inputs,
+        outputs: finalOutputs,
+        fee: sumInputs.sub(sumOrNaN(finalOutputs, true)).toNumber(),
+    };
+}
+function anyOf(algorithms) {
+    return (utxos, outputs, feeRate, options) => {
+        let result = { fee: 0 };
+        for (let i = 0; i < algorithms.length; i++) {
+            const algorithm = algorithms[i];
+            result = algorithm(utxos, outputs, feeRate, options);
+            if (result.inputs) {
+                return result;
+            }
+        }
+        return result;
+    };
+}
+function utxoScore(x, feeRate) {
+    return x.value.sub(new bn_js_1.default(getFeeForBytes(feeRate, inputBytes(x))));
+}
+function sortByScore(feeRate) {
+    return (a, b) => {
+        const difference = utxoScore(a, feeRate).sub(utxoScore(b, feeRate));
+        if (difference.eq(exports.ZERO)) {
+            return a.i - b.i;
+        }
+        return difference.isNeg() ? 1 : -1;
+    };
+}
+function filterCoinbase(utxos, minConfCoinbase) {
+    return utxos.filter(utxo => {
+        if (utxo.coinbase && !utxo.required) {
+            return utxo.confirmations >= minConfCoinbase;
+        }
+        return true;
+    });
+}
+//# sourceMappingURL=coinselectUtils.js.map

package/third-party/utxo-lib/coinselect/index.d.ts

@@ -0,0 +1,3 @@
+import { CoinSelectRequest } from '../types';
+export declare function coinselect({ inputs, outputs, feeRate, ...options }: CoinSelectRequest): import("../types").CoinSelectResult;
+//# sourceMappingURL=index.d.ts.map

package/third-party/utxo-lib/coinselect/index.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.coinselect = coinselect;
+const tslib_1 = require("tslib");
+const accumulative_1 = require("./inputs/accumulative");
+const branchAndBound_1 = require("./inputs/branchAndBound");
+const split_1 = require("./outputs/split");
+const coinselectUtils_1 = require("./coinselectUtils");
+const tryconfirmed_1 = require("./tryconfirmed");
+function coinselect(_a) {
+    var { inputs, outputs, feeRate } = _a, options = tslib_1.__rest(_a, ["inputs", "outputs", "feeRate"]);
+    if (options.sendMaxOutputIndex >= 0) {
+        return (0, split_1.split)(inputs, outputs, feeRate, options);
+    }
+    const sortedInputs = options.sortingStrategy === 'none' ? inputs : inputs.sort((0, coinselectUtils_1.sortByScore)(feeRate));
+    const algorithm = (0, tryconfirmed_1.tryConfirmed)((0, coinselectUtils_1.anyOf)([branchAndBound_1.branchAndBound, accumulative_1.accumulative]), options);
+    return algorithm(sortedInputs, outputs, feeRate, options);
+}
+//# sourceMappingURL=index.js.map

package/third-party/utxo-lib/coinselect/inputs/accumulative.d.ts

@@ -0,0 +1,3 @@
+import { CoinSelectAlgorithm } from '../../types';
+export declare const accumulative: CoinSelectAlgorithm;
+//# sourceMappingURL=accumulative.d.ts.map