@onetokenfe/coinselect 3.1.16

package/third-party/utxo-lib/coinselect/inputs/accumulative.js

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.accumulative = void 0;
+const tslib_1 = require("tslib");
+const bn_js_1 = tslib_1.__importDefault(require("bn.js"));
+const coinselectUtils_1 = require("../coinselectUtils");
+const accumulative = (utxos0, outputs, feeRate, options) => {
+    let inAccum = coinselectUtils_1.ZERO;
+    const inputs = [];
+    const outAccum = (0, coinselectUtils_1.sumOrNaN)(outputs);
+    const requiredUtxos = [];
+    const utxos = [];
+    utxos0.forEach(u => {
+        if (u.required) {
+            requiredUtxos.push(u);
+            const utxoValue = (0, coinselectUtils_1.bignumberOrNaN)(u.value, true);
+            inAccum = inAccum.add(utxoValue);
+            inputs.push(u);
+        }
+        else {
+            utxos.push(u);
+        }
+    });
+    if (requiredUtxos.length > 0) {
+        const requiredIsEnough = (0, coinselectUtils_1.finalize)(requiredUtxos, outputs, feeRate, options);
+        if (requiredIsEnough.inputs) {
+            return requiredIsEnough;
+        }
+    }
+    for (let i = 0; i < utxos.length; ++i) {
+        const utxo = utxos[i];
+        const utxoBytes = (0, coinselectUtils_1.inputBytes)(utxo);
+        const utxoFee = (0, coinselectUtils_1.getFeeForBytes)(feeRate, utxoBytes);
+        const utxoValue = (0, coinselectUtils_1.bignumberOrNaN)(utxo.value);
+        if (!utxoValue || utxoValue.lt(new bn_js_1.default(utxoFee))) {
+            if (i === utxos.length - 1) {
+                const fee = (0, coinselectUtils_1.getFee)([...inputs, utxo], outputs, feeRate, options);
+                return { fee };
+            }
+        }
+        else {
+            inAccum = inAccum.add(utxoValue);
+            inputs.push(utxo);
+            const fee = (0, coinselectUtils_1.getFee)(inputs, outputs, feeRate, options);
+            const outAccumWithFee = outAccum ? outAccum.add(new bn_js_1.default(fee)) : coinselectUtils_1.ZERO;
+            if (inAccum.gte(outAccumWithFee)) {
+                return (0, coinselectUtils_1.finalize)(inputs, outputs, feeRate, options);
+            }
+        }
+    }
+    const fee = (0, coinselectUtils_1.getFee)(inputs, outputs, feeRate, options);
+    return { fee };
+};
+exports.accumulative = accumulative;
+//# sourceMappingURL=accumulative.js.map

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

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

package/third-party/utxo-lib/coinselect/inputs/branchAndBound.js

@@ -0,0 +1,123 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.branchAndBound = void 0;
+const tslib_1 = require("tslib");
+const bn_js_1 = tslib_1.__importDefault(require("bn.js"));
+const coinselectUtils_1 = require("../coinselectUtils");
+const MAX_TRIES = 1000000;
+function calculateEffectiveValues(utxos, feeRate) {
+    return utxos.map(utxo => {
+        const value = (0, coinselectUtils_1.bignumberOrNaN)(utxo.value);
+        if (!value) {
+            return {
+                utxo,
+                effectiveValue: coinselectUtils_1.ZERO,
+            };
+        }
+        const effectiveFee = (0, coinselectUtils_1.getFeeForBytes)(feeRate, (0, coinselectUtils_1.inputBytes)(utxo));
+        const effectiveValue = value.sub(new bn_js_1.default(effectiveFee));
+        return {
+            utxo,
+            effectiveValue,
+        };
+    });
+}
+function search(effectiveUtxos, target, costRange) {
+    if (effectiveUtxos.length === 0) {
+        return null;
+    }
+    let tries = MAX_TRIES;
+    const selected = [];
+    let selectedAccum = coinselectUtils_1.ZERO;
+    let done = false;
+    let backtrack = false;
+    let remaining = effectiveUtxos.reduce((a, x) => x.effectiveValue.add(a), coinselectUtils_1.ZERO);
+    let depth = 0;
+    while (!done) {
+        if (tries <= 0) {
+            return null;
+        }
+        if (selectedAccum.gt(costRange)) {
+            backtrack = true;
+        }
+        else if (selectedAccum.gte(target)) {
+            done = true;
+        }
+        else if (depth >= effectiveUtxos.length) {
+            backtrack = true;
+        }
+        else if (selectedAccum.add(remaining).lt(target)) {
+            if (depth === 0) {
+                return null;
+            }
+            backtrack = true;
+        }
+        else {
+            remaining = remaining.sub(effectiveUtxos[depth].effectiveValue);
+            selected[depth] = true;
+            selectedAccum = selectedAccum.add(effectiveUtxos[depth].effectiveValue);
+            depth++;
+        }
+        if (backtrack) {
+            backtrack = false;
+            depth--;
+            while (!selected[depth]) {
+                remaining = remaining.add(effectiveUtxos[depth].effectiveValue);
+                depth--;
+                if (depth < 0) {
+                    return null;
+                }
+            }
+            selected[depth] = false;
+            selectedAccum = selectedAccum.sub(effectiveUtxos[depth].effectiveValue);
+            depth++;
+        }
+        tries--;
+    }
+    return selected;
+}
+const branchAndBound = (utxos, outputs, feeRate, options) => {
+    if (options.baseFee)
+        return { fee: 0 };
+    if (utxos.find(u => u.required))
+        return { fee: 0 };
+    const changeOutputFee = (0, coinselectUtils_1.getFeeForBytes)(feeRate, (0, coinselectUtils_1.outputBytes)({
+        script: {
+            length: coinselectUtils_1.OUTPUT_SCRIPT_LENGTH[options.txType],
+        },
+    }));
+    const costOfChange = changeOutputFee + (0, coinselectUtils_1.getDustAmount)(feeRate, options);
+    const outputsBytes = (0, coinselectUtils_1.transactionBytes)([], outputs);
+    const outputsFee = (0, coinselectUtils_1.getFeeForBytes)(feeRate, outputsBytes);
+    const outputsTotalValue = (0, coinselectUtils_1.sumOrNaN)(outputs);
+    if (!outputsTotalValue)
+        return { fee: 0 };
+    const target = outputsTotalValue.add(new bn_js_1.default(outputsFee));
+    const targetRange = target.add(new bn_js_1.default(costOfChange));
+    const effectiveUtxos = calculateEffectiveValues(utxos, feeRate)
+        .filter(({ effectiveValue }) => effectiveValue.gt(coinselectUtils_1.ZERO) && effectiveValue.lte(targetRange))
+        .sort((a, b) => {
+        const subtract = b.effectiveValue.sub(a.effectiveValue).toNumber();
+        if (subtract !== 0) {
+            return subtract;
+        }
+        return a.utxo.i - b.utxo.i;
+    });
+    const utxosTotalEffectiveValue = effectiveUtxos.reduce((total, { effectiveValue }) => total.add(effectiveValue), coinselectUtils_1.ZERO);
+    if (utxosTotalEffectiveValue.lt(target)) {
+        return { fee: 0 };
+    }
+    const selected = search(effectiveUtxos, target, targetRange);
+    if (selected !== null) {
+        const inputs = [];
+        for (let i = 0; i < effectiveUtxos.length; i++) {
+            if (selected[i]) {
+                inputs.push(effectiveUtxos[i].utxo);
+            }
+        }
+        return (0, coinselectUtils_1.finalize)(inputs, outputs, feeRate, options);
+    }
+    return { fee: 0 };
+};
+exports.branchAndBound = branchAndBound;
+//# sourceMappingURL=branchAndBound.js.map

package/third-party/utxo-lib/coinselect/outputs/split.d.ts

@@ -0,0 +1,3 @@
+import { CoinSelectInput, CoinSelectOutput, CoinSelectOptions, CoinSelectResult } from '../../types';
+export declare function split(utxosOrig: CoinSelectInput[], outputs: CoinSelectOutput[], feeRate: number, options: CoinSelectOptions): CoinSelectResult;
+//# sourceMappingURL=split.d.ts.map

package/third-party/utxo-lib/coinselect/outputs/split.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.split = split;
+const tslib_1 = require("tslib");
+const bn_js_1 = tslib_1.__importDefault(require("bn.js"));
+const coinselectUtils_1 = require("../coinselectUtils");
+function split(utxosOrig, outputs, feeRate, options) {
+    const coinbase = options.coinbase || 100;
+    const utxos = (0, coinselectUtils_1.filterCoinbase)(utxosOrig, coinbase);
+    const fee = (0, coinselectUtils_1.getFee)(utxos, outputs, feeRate, options);
+    if (outputs.length === 0)
+        return { fee };
+    const inAccum = (0, coinselectUtils_1.sumOrNaN)(utxos);
+    const outAccum = (0, coinselectUtils_1.sumOrNaN)(outputs, true);
+    if (!inAccum)
+        return { fee };
+    const remaining = inAccum.sub(outAccum).sub(new bn_js_1.default(fee));
+    if (remaining.lt(coinselectUtils_1.ZERO))
+        return { fee };
+    const unspecified = outputs.reduce((a, x) => a + (!(0, coinselectUtils_1.bignumberOrNaN)(x.value) ? 1 : 0), 0);
+    if (remaining.isZero() || unspecified === 0) {
+        return (0, coinselectUtils_1.finalize)(utxos, outputs, feeRate, options);
+    }
+    const splitValue = remaining.div(new bn_js_1.default(unspecified));
+    const dustAmount = (0, coinselectUtils_1.getDustAmount)(feeRate, options);
+    if (unspecified && splitValue.lt(new bn_js_1.default(dustAmount)))
+        return { fee };
+    const outputsSplit = outputs.map(output => {
+        if (output.value)
+            return output;
+        return Object.assign(Object.assign({}, output), { value: splitValue });
+    });
+    return (0, coinselectUtils_1.finalize)(utxos, outputsSplit, feeRate, options);
+}
+//# sourceMappingURL=split.js.map

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

@@ -0,0 +1,3 @@
+import { CoinSelectAlgorithm, CoinSelectOptions } from '../types';
+export declare function tryConfirmed(algorithm: CoinSelectAlgorithm, options: CoinSelectOptions): CoinSelectAlgorithm;
+//# sourceMappingURL=tryconfirmed.d.ts.map

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

@@ -0,0 +1,65 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.tryConfirmed = tryConfirmed;
+const coinselectUtils_1 = require("./coinselectUtils");
+function filterUtxos(utxos, minConfOwn, minConfOther) {
+    const usable = [];
+    const unusable = [];
+    for (let i = 0; i < utxos.length; i++) {
+        const utxo = utxos[i];
+        const isUsed = utxo.own
+            ? utxo.confirmations >= minConfOwn
+            : utxo.confirmations >= minConfOther;
+        if (isUsed || utxo.required) {
+            usable.push(utxo);
+        }
+        else {
+            unusable.push(utxo);
+        }
+    }
+    return {
+        usable,
+        unusable,
+    };
+}
+function tryConfirmed(algorithm, options) {
+    const own = options.own || 1;
+    const other = options.other || 6;
+    const coinbase = options.coinbase || 100;
+    return (utxosO, outputs, feeRate, optionsIn) => {
+        const utxos = (0, coinselectUtils_1.filterCoinbase)(utxosO, coinbase);
+        if (utxos.length === 0) {
+            return { fee: 0 };
+        }
+        const trials = [];
+        let i;
+        for (i = own; i > 0; i--) {
+            trials.push({ other, own: i });
+        }
+        for (i = other - 1; i > 0; i--) {
+            trials.push({ other: i, own: 1 });
+        }
+        trials.push({ other: 1, own: 0 });
+        trials.push({ other: 0, own: 0 });
+        let unusable = utxos;
+        let usable = [];
+        for (i = 0; i < trials.length; i++) {
+            const trial = trials[i];
+            const filterResult = filterUtxos(unusable, trial.own, trial.other);
+            if (filterResult.usable.length > 0) {
+                usable = usable.concat(filterResult.usable);
+                const unusableH = filterResult.unusable;
+                unusable = unusableH;
+                const result = algorithm(usable, outputs, feeRate, optionsIn);
+                if (result.inputs) {
+                    return result;
+                }
+                if (unusable.length === 0) {
+                    return result;
+                }
+            }
+        }
+        throw new Error('Unexpected unreturned result');
+    };
+}
+//# sourceMappingURL=tryconfirmed.js.map

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

@@ -0,0 +1,3 @@
+import { ComposeRequest, ComposeInput, ComposeOutput, ComposeChangeAddress, ComposeResult } from '../types';
+export declare function composeTx<Input extends ComposeInput, Output extends ComposeOutput, Change extends ComposeChangeAddress>(request: ComposeRequest<Input, Output, Change>): ComposeResult<Input, Output, Change>;
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.composeTx = composeTx;
+const request_1 = require("./request");
+const result_1 = require("./result");
+const coinselect_1 = require("../coinselect");
+function composeTx(request) {
+    const coinselectRequest = (0, request_1.validateAndParseRequest)(request);
+    if ('error' in coinselectRequest) {
+        return coinselectRequest;
+    }
+    try {
+        const result = (0, coinselect_1.coinselect)(coinselectRequest);
+        return (0, result_1.getResult)(request, coinselectRequest, result);
+    }
+    catch (error) {
+        return (0, result_1.getErrorResult)(error);
+    }
+}
+//# sourceMappingURL=index.js.map

package/third-party/utxo-lib/compose/request.d.ts

@@ -0,0 +1,5 @@
+import type { ComposeInput, ComposeOutput, ComposeChangeAddress, ComposeRequest, ComposeResultError, CoinSelectRequest } from '../types';
+type Request = ComposeRequest<ComposeInput, ComposeOutput, ComposeChangeAddress>;
+export declare function validateAndParseRequest(request: Request): CoinSelectRequest | ComposeResultError;
+export {};
+//# sourceMappingURL=request.d.ts.map

package/third-party/utxo-lib/compose/request.js

@@ -0,0 +1,168 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateAndParseRequest = validateAndParseRequest;
+const address_1 = require("../address");
+const embed_1 = require("../payments/embed");
+const coinselectUtils_1 = require("../coinselect/coinselectUtils");
+function validateAndParseFeeRate(rate) {
+    const feeRate = typeof rate === 'string' ? Number(rate) : rate;
+    if (typeof feeRate !== 'number' ||
+        Number.isNaN(feeRate) ||
+        !Number.isFinite(feeRate) ||
+        feeRate > Number.MAX_SAFE_INTEGER ||
+        feeRate <= 0) {
+        return;
+    }
+    return feeRate;
+}
+function transformInput(i, utxo, txType) {
+    if (typeof utxo.coinbase !== 'boolean') {
+        throw new Error('Missing coinbase');
+    }
+    if (typeof utxo.own !== 'boolean') {
+        throw new Error('Missing own');
+    }
+    if (typeof utxo.confirmations !== 'number') {
+        throw new Error('Missing confirmations');
+    }
+    const value = (0, coinselectUtils_1.bignumberOrNaN)(utxo.amount);
+    if (!value) {
+        throw new Error('Invalid amount');
+    }
+    return Object.assign(Object.assign({}, utxo), { type: txType, i, script: { length: coinselectUtils_1.INPUT_SCRIPT_LENGTH[txType] }, value });
+}
+function validateAndParseUtxos(txType, { utxos }) {
+    if (utxos.length === 0) {
+        return { type: 'error', error: 'MISSING-UTXOS' };
+    }
+    const incorrectUtxoError = (index, message) => ({
+        type: 'error',
+        error: 'INCORRECT-UTXO',
+        message: `${message} at index ${index}`,
+    });
+    const result = [];
+    for (let i = 0; i < utxos.length; i++) {
+        try {
+            const csInput = transformInput(i, utxos[i], txType);
+            csInput.weight = (0, coinselectUtils_1.inputWeight)(csInput);
+            result.push(csInput);
+        }
+        catch (error) {
+            return incorrectUtxoError(i, error.message);
+        }
+    }
+    return result;
+}
+function transformOutput(output, txType, network) {
+    const script = { length: coinselectUtils_1.OUTPUT_SCRIPT_LENGTH[txType] };
+    if (output.type === 'payment') {
+        const value = (0, coinselectUtils_1.bignumberOrNaN)(output.amount);
+        if (!value)
+            throw new Error('Invalid amount');
+        return {
+            value,
+            script: (0, address_1.toOutputScript)(output.address, network),
+        };
+    }
+    if (output.type === 'payment-noaddress') {
+        const value = (0, coinselectUtils_1.bignumberOrNaN)(output.amount);
+        if (!value)
+            throw new Error('Invalid amount');
+        return {
+            value,
+            script,
+        };
+    }
+    if (output.type === 'opreturn') {
+        return {
+            value: (0, coinselectUtils_1.bignumberOrNaN)('0', true),
+            script: (0, embed_1.p2data)({ data: [Buffer.from(output.dataHex, 'hex')] }).output,
+        };
+    }
+    if (output.type === 'send-max') {
+        return {
+            script: (0, address_1.toOutputScript)(output.address, network),
+        };
+    }
+    if (output.type === 'send-max-noaddress') {
+        return {
+            script,
+        };
+    }
+    throw new Error('Unknown output type');
+}
+function validateAndParseOutputs(txType, { outputs, network }) {
+    if (outputs.length === 0) {
+        return { type: 'error', error: 'MISSING-OUTPUTS' };
+    }
+    const incorrectOutputError = (index, message) => ({
+        type: 'error',
+        error: 'INCORRECT-OUTPUT',
+        message: `${message} at index ${index}`,
+    });
+    let sendMaxOutputIndex = -1;
+    const result = [];
+    for (let i = 0; i < outputs.length; i++) {
+        const output = outputs[i];
+        if (output.type === 'send-max-noaddress' || output.type === 'send-max') {
+            if (sendMaxOutputIndex >= 0) {
+                return incorrectOutputError(i, 'Multiple send-max');
+            }
+            sendMaxOutputIndex = i;
+        }
+        try {
+            const csOutput = transformOutput(output, txType, network);
+            csOutput.weight = (0, coinselectUtils_1.outputWeight)(csOutput);
+            result.push(csOutput);
+        }
+        catch (error) {
+            return incorrectOutputError(i, error.message);
+        }
+    }
+    return {
+        outputs: result,
+        sendMaxOutputIndex,
+    };
+}
+function validateAndParseChangeOutput(txType, { changeAddress, network }) {
+    try {
+        return transformOutput(Object.assign({ type: 'send-max' }, changeAddress), txType, network);
+    }
+    catch (error) {
+        return {
+            type: 'error',
+            error: 'INCORRECT-OUTPUT',
+            message: error.message,
+        };
+    }
+}
+function validateAndParseRequest(request) {
+    const feeRate = validateAndParseFeeRate(request.feeRate);
+    if (!feeRate) {
+        return { type: 'error', error: 'INCORRECT-FEE-RATE' };
+    }
+    const longTermFeeRate = validateAndParseFeeRate(request.longTermFeeRate);
+    if (request.longTermFeeRate != null && !longTermFeeRate) {
+        return { type: 'error', error: 'INCORRECT-FEE-RATE' };
+    }
+    const txType = request.txType || 'p2pkh';
+    const inputs = validateAndParseUtxos(txType, request);
+    if ('error' in inputs) {
+        return inputs;
+    }
+    const outputs = validateAndParseOutputs(txType, request);
+    if ('error' in outputs) {
+        return outputs;
+    }
+    const changeOutput = validateAndParseChangeOutput(txType, request);
+    if ('error' in changeOutput) {
+        return changeOutput;
+    }
+    const feePolicy = (0, coinselectUtils_1.getFeePolicy)(request.network);
+    return Object.assign(Object.assign({ txType,
+        inputs }, outputs), { changeOutput,
+        feeRate,
+        feePolicy,
+        longTermFeeRate, dustThreshold: request.dustThreshold, baseFee: request.baseFee, floorBaseFee: request.floorBaseFee, sortingStrategy: request.sortingStrategy });
+}
+//# sourceMappingURL=request.js.map

package/third-party/utxo-lib/compose/result.d.ts

@@ -0,0 +1,4 @@
+import { CoinSelectRequest, CoinSelectResult, ComposeRequest, ComposeInput, ComposeOutput, ComposeChangeAddress, ComposeResult, ComposeResultError } from '../types';
+export declare function getErrorResult(error: unknown): ComposeResultError;
+export declare function getResult<Input extends ComposeInput, Output extends ComposeOutput, Change extends ComposeChangeAddress>(request: ComposeRequest<Input, Output, Change>, { sendMaxOutputIndex }: CoinSelectRequest, result: CoinSelectResult): ComposeResult<Input, Output, Change>;
+//# sourceMappingURL=result.d.ts.map

package/third-party/utxo-lib/compose/result.js

@@ -0,0 +1,64 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getErrorResult = getErrorResult;
+exports.getResult = getResult;
+const tslib_1 = require("tslib");
+const bn_js_1 = tslib_1.__importDefault(require("bn.js"));
+const coinselectUtils_1 = require("../coinselect/coinselectUtils");
+const transaction_1 = require("./transaction");
+const types_1 = require("../types");
+function getErrorResult(error) {
+    const message = error instanceof Error ? error.message : `${error}`;
+    const known = types_1.COMPOSE_ERROR_TYPES.find(e => e === message);
+    if (known) {
+        return { type: 'error', error: known };
+    }
+    return { type: 'error', error: 'COINSELECT', message };
+}
+function splitByCompleteness(outputs) {
+    const complete = [];
+    const incomplete = [];
+    outputs.forEach(output => {
+        if (output.type === 'payment' || output.type === 'send-max' || output.type === 'opreturn') {
+            complete.push(output);
+        }
+        else {
+            incomplete.push(output);
+        }
+    });
+    return {
+        complete,
+        incomplete,
+    };
+}
+function getResult(request, { sendMaxOutputIndex }, result) {
+    if (!result.inputs || !result.outputs) {
+        return { type: 'error', error: 'NOT-ENOUGH-FUNDS' };
+    }
+    const totalSpent = result.outputs.reduce((total, output, index) => {
+        if (request.outputs[index]) {
+            return total.add(output.value);
+        }
+        return total;
+    }, new bn_js_1.default(result.fee));
+    const max = sendMaxOutputIndex >= 0 ? result.outputs[sendMaxOutputIndex].value.toString() : undefined;
+    const bytes = (0, coinselectUtils_1.transactionBytes)(result.inputs, result.outputs);
+    const feePerByte = result.fee / bytes;
+    const { complete, incomplete } = splitByCompleteness(request.outputs);
+    if (incomplete.length > 0) {
+        const inputs = result.inputs.map(input => request.utxos[input.i]);
+        return {
+            type: 'nonfinal',
+            fee: result.fee.toString(),
+            feePerByte: feePerByte.toString(),
+            bytes,
+            max,
+            totalSpent: totalSpent.toString(),
+            inputs,
+        };
+    }
+    const transaction = (0, transaction_1.createTransaction)(Object.assign(Object.assign({}, request), { outputs: complete }), result);
+    return Object.assign({ type: 'final', fee: result.fee.toString(), feePerByte: feePerByte.toString(), bytes,
+        max, totalSpent: totalSpent.toString() }, transaction);
+}
+//# sourceMappingURL=result.js.map

package/third-party/utxo-lib/compose/sorting/bip69SortingStrategy.d.ts

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

package/third-party/utxo-lib/compose/sorting/bip69SortingStrategy.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.bip69SortingStrategy = void 0;
+const convertOutput_1 = require("./convertOutput");
+function inputComparator(a, b) {
+    return Buffer.from(a.txid, 'hex').compare(Buffer.from(b.txid, 'hex')) || a.vout - b.vout;
+}
+function outputComparator(a, b) {
+    return (a.value.cmp(b.value) ||
+        (Buffer.isBuffer(a.script) && Buffer.isBuffer(b.script)
+            ? a.script.compare(b.script)
+            : a.script.length - b.script.length));
+}
+const bip69SortingStrategy = ({ result, request, convertedInputs }) => {
+    const defaultPermutation = [];
+    const convertedOutputs = result.outputs.map((output, index) => {
+        defaultPermutation.push(index);
+        if (request.outputs[index]) {
+            return (0, convertOutput_1.convertOutput)(output, request.outputs[index]);
+        }
+        return (0, convertOutput_1.convertOutput)(output, Object.assign({ type: 'change' }, request.changeAddress));
+    });
+    const permutation = defaultPermutation.sort((a, b) => outputComparator(result.outputs[a], result.outputs[b]));
+    const sortedOutputs = permutation.map(index => convertedOutputs[index]);
+    return {
+        inputs: convertedInputs.sort(inputComparator),
+        outputs: sortedOutputs,
+        outputsPermutation: permutation,
+    };
+};
+exports.bip69SortingStrategy = bip69SortingStrategy;
+//# sourceMappingURL=bip69SortingStrategy.js.map

package/third-party/utxo-lib/compose/sorting/convertOutput.d.ts

@@ -0,0 +1,13 @@
+import { CoinSelectOutputFinal, ComposeChangeAddress, ComposeFinalOutput } from '../../types';
+export declare const convertOutput: (selectedOutput: CoinSelectOutputFinal, composeOutput: ComposeFinalOutput | ({
+    type: "change";
+} & ComposeChangeAddress)) => import("../../types").ComposeOutputOpreturn | {
+    amount: string;
+    type: "change";
+    address: string;
+} | {
+    type: "payment";
+    amount: string;
+    address: string;
+};
+//# sourceMappingURL=convertOutput.d.ts.map

package/third-party/utxo-lib/compose/sorting/convertOutput.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.convertOutput = void 0;
+const convertOutput = (selectedOutput, composeOutput) => {
+    if (composeOutput.type === 'change') {
+        return Object.assign(Object.assign({}, composeOutput), { amount: selectedOutput.value.toString() });
+    }
+    if (composeOutput.type === 'opreturn') {
+        return composeOutput;
+    }
+    return Object.assign(Object.assign({}, composeOutput), { type: 'payment', amount: selectedOutput.value.toString() });
+};
+exports.convertOutput = convertOutput;
+//# sourceMappingURL=convertOutput.js.map

package/third-party/utxo-lib/compose/sorting/noneSortingStrategy.d.ts

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

package/third-party/utxo-lib/compose/sorting/noneSortingStrategy.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.noneSortingStrategy = void 0;
+const convertOutput_1 = require("./convertOutput");
+const noneSortingStrategy = ({ result, request, convertedInputs }) => {
+    const convertedOutputs = result.outputs.map((output, index) => {
+        if (request.outputs[index]) {
+            return (0, convertOutput_1.convertOutput)(output, request.outputs[index]);
+        }
+        return (0, convertOutput_1.convertOutput)(output, Object.assign({ type: 'change' }, request.changeAddress));
+    });
+    return {
+        inputs: convertedInputs,
+        outputs: convertedOutputs,
+        outputsPermutation: Array.from(convertedOutputs.keys()),
+    };
+};
+exports.noneSortingStrategy = noneSortingStrategy;
+//# sourceMappingURL=noneSortingStrategy.js.map

package/third-party/utxo-lib/compose/sorting/randomSortingStrategy.d.ts

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