@scure/btc-signer 1.1.1 → 1.2.1

package/{index.js → lib/esm/index.js}

@@ -779,13 +779,26 @@ const PSBTInputCoder = P.validate(PSBTKeyMap(PSBTInput), (i) => {
         }
     }
     // Validate txid for nonWitnessUtxo is correct
-    if (i.nonWitnessUtxo && i.index && i.txid) {
+    if (i.nonWitnessUtxo && i.index !== undefined && i.txid) {
         const outputs = i.nonWitnessUtxo.outputs;
         if (outputs.length - 1 < i.index)
             throw new Error('nonWitnessUtxo: incorect output index');
-        const tx = Transaction.fromRaw(RawTx.encode(i.nonWitnessUtxo));
+        // At this point, we are using previous tx output to create new input.
+        // Script safety checks are unnecessary:
+        // - User has no control over previous tx. If somebody send money in same tx
+        //   as unspendable output, we still want user able to spend money
+        // - We still want some checks to notify user about possible errors early
+        //   in case user wants to use wrong input by mistake
+        // - Worst case: tx will be rejected by nodes. Still better than disallowing user
+        //   to spend real input, no matter how broken it looks
+        const tx = Transaction.fromRaw(RawTx.encode(i.nonWitnessUtxo), {
+            allowUnknownOutputs: true,
+            disableScriptCheck: true,
+            allowUnknownInputs: true,
+        });
         const txid = hex.encode(i.txid);
-        if (tx.id !== txid)
+        // PSBTv2 vectors have non-final tx in inputs
+        if (tx.isFinal && tx.id !== txid)
             throw new Error(`nonWitnessUtxo: wrong txid, exp=${txid} got=${tx.id}`);
     }
     return i;
@@ -1662,6 +1675,115 @@ function validateOpts(opts) {
     }
     return Object.freeze(_opts);
 }
+// Normalizes input
+function getPrevOut(input) {
+    if (input.nonWitnessUtxo) {
+        if (input.index === undefined)
+            throw new Error('Unknown input index');
+        return input.nonWitnessUtxo.outputs[input.index];
+    }
+    else if (input.witnessUtxo)
+        return input.witnessUtxo;
+    else
+        throw new Error('Cannot find previous output info');
+}
+function normalizeInput(i, cur, allowedFields, disableScriptCheck = false) {
+    let { nonWitnessUtxo, txid } = i;
+    // String support for common fields. We usually prefer Uint8Array to avoid errors
+    // like hex looking string accidentally passed, however, in case of nonWitnessUtxo
+    // it is better to expect string, since constructing this complex object will be
+    // difficult for user
+    if (typeof nonWitnessUtxo === 'string')
+        nonWitnessUtxo = hex.decode(nonWitnessUtxo);
+    if (isBytes(nonWitnessUtxo))
+        nonWitnessUtxo = RawTx.decode(nonWitnessUtxo);
+    if (!('nonWitnessUtxo' in i) && nonWitnessUtxo === undefined)
+        nonWitnessUtxo = cur?.nonWitnessUtxo;
+    if (typeof txid === 'string')
+        txid = hex.decode(txid);
+    // TODO: if we have nonWitnessUtxo, we can extract txId from here
+    if (txid === undefined)
+        txid = cur?.txid;
+    let res = { ...cur, ...i, nonWitnessUtxo, txid };
+    if (!('nonWitnessUtxo' in i) && res.nonWitnessUtxo === undefined)
+        delete res.nonWitnessUtxo;
+    if (res.sequence === undefined)
+        res.sequence = DEFAULT_SEQUENCE;
+    if (res.tapMerkleRoot === null)
+        delete res.tapMerkleRoot;
+    res = mergeKeyMap(PSBTInput, res, cur, allowedFields);
+    PSBTInputCoder.encode(res); // Validates that everything is correct at this point
+    let prevOut;
+    if (res.nonWitnessUtxo && res.index !== undefined)
+        prevOut = res.nonWitnessUtxo.outputs[res.index];
+    else if (res.witnessUtxo)
+        prevOut = res.witnessUtxo;
+    if (prevOut && !disableScriptCheck)
+        checkScript(prevOut && prevOut.script, res.redeemScript, res.witnessScript);
+    return res;
+}
+function getInputType(input, allowLegacyWitnessUtxo = false) {
+    let txType = 'legacy';
+    let defaultSighash = SignatureHash.ALL;
+    const prevOut = getPrevOut(input);
+    const first = OutScript.decode(prevOut.script);
+    let type = first.type;
+    let cur = first;
+    const stack = [first];
+    if (first.type === 'tr') {
+        defaultSighash = SignatureHash.DEFAULT;
+        return {
+            txType: 'taproot',
+            type: 'tr',
+            last: first,
+            lastScript: prevOut.script,
+            defaultSighash,
+            sighash: input.sighashType || defaultSighash,
+        };
+    }
+    else {
+        if (first.type === 'wpkh' || first.type === 'wsh')
+            txType = 'segwit';
+        if (first.type === 'sh') {
+            if (!input.redeemScript)
+                throw new Error('inputType: sh without redeemScript');
+            let child = OutScript.decode(input.redeemScript);
+            if (child.type === 'wpkh' || child.type === 'wsh')
+                txType = 'segwit';
+            stack.push(child);
+            cur = child;
+            type += `-${child.type}`;
+        }
+        // wsh can be inside sh
+        if (cur.type === 'wsh') {
+            if (!input.witnessScript)
+                throw new Error('inputType: wsh without witnessScript');
+            let child = OutScript.decode(input.witnessScript);
+            if (child.type === 'wsh')
+                txType = 'segwit';
+            stack.push(child);
+            cur = child;
+            type += `-${child.type}`;
+        }
+        const last = stack[stack.length - 1];
+        if (last.type === 'sh' || last.type === 'wsh')
+            throw new Error('inputType: sh/wsh cannot be terminal type');
+        const lastScript = OutScript.encode(last);
+        const res = {
+            type,
+            txType,
+            last,
+            lastScript,
+            defaultSighash,
+            sighash: input.sighashType || defaultSighash,
+        };
+        if (txType === 'legacy' && !allowLegacyWitnessUtxo && !input.nonWitnessUtxo) {
+            throw new Error(`Transaction/sign: legacy input without nonWitnessUtxo, can result in attack that forces paying higher fees. Pass allowLegacyWitnessUtxo=true, if you sure`);
+        }
+        return res;
+    }
+}
+const toVsize = (weight) => Math.ceil(weight / 4);
 export class Transaction {
     constructor(opts = {}) {
         this.global = {};
@@ -1816,7 +1938,7 @@ export class Transaction {
     // We will lose some vectors -> smaller test coverage of preimages (very important!)
     inputSighash(idx) {
         this.checkInputIdx(idx);
-        const sighash = this.inputType(this.inputs[idx]).sighash;
+        const sighash = getInputType(this.inputs[idx], this.opts.allowLegacyWitnessUtxo).sighash;
         // ALL or DEFAULT -- everything signed
         // NONE           -- all inputs + no outputs
         // SINGLE         -- all inputs + output with same index
@@ -1875,26 +1997,25 @@ export class Transaction {
     get weight() {
         if (!this.isFinal)
             throw new Error('Transaction is not finalized');
-        // TODO: Can we find out how much witnesses/script will be used before signing?
         let out = 32;
+        // Outputs
         const outputs = this.outputs.map(outputBeforeSign);
+        out += 4 * CompactSizeLen.encode(this.outputs.length).length;
+        for (const o of outputs)
+            out += 32 + 4 * VarBytes.encode(o.script).length;
+        // Inputs
         if (this.hasWitnesses)
             out += 2;
         out += 4 * CompactSizeLen.encode(this.inputs.length).length;
-        out += 4 * CompactSizeLen.encode(this.outputs.length).length;
-        for (const i of this.inputs)
+        for (const i of this.inputs) {
             out += 160 + 4 * VarBytes.encode(i.finalScriptSig || P.EMPTY).length;
-        for (const o of outputs)
-            out += 32 + 4 * VarBytes.encode(o.script).length;
-        if (this.hasWitnesses) {
-            for (const i of this.inputs)
-                if (i.finalScriptWitness)
-                    out += RawWitness.encode(i.finalScriptWitness).length;
+            if (this.hasWitnesses && i.finalScriptWitness)
+                out += RawWitness.encode(i.finalScriptWitness).length;
         }
         return out;
     }
     get vsize() {
-        return Math.ceil(this.weight / 4);
+        return toVsize(this.weight);
     }
     toBytes(withScriptSig = false, withWitness = false) {
         return RawTx.encode({
@@ -1938,42 +2059,10 @@ export class Transaction {
         return this.inputs.length;
     }
     // Modification
-    normalizeInput(i, cur, allowedFields) {
-        let { nonWitnessUtxo, txid } = i;
-        // String support for common fields. We usually prefer Uint8Array to avoid errors (like hex looking string accidentally passed),
-        // however in case of nonWitnessUtxo it is better to expect string, since constructing this complex object will be difficult for user
-        if (typeof nonWitnessUtxo === 'string')
-            nonWitnessUtxo = hex.decode(nonWitnessUtxo);
-        if (isBytes(nonWitnessUtxo))
-            nonWitnessUtxo = RawTx.decode(nonWitnessUtxo);
-        if (!('nonWitnessUtxo' in i) && nonWitnessUtxo === undefined)
-            nonWitnessUtxo = cur?.nonWitnessUtxo;
-        if (typeof txid === 'string')
-            txid = hex.decode(txid);
-        if (txid === undefined)
-            txid = cur?.txid;
-        let res = { ...cur, ...i, nonWitnessUtxo, txid };
-        if (!('nonWitnessUtxo' in i) && res.nonWitnessUtxo === undefined)
-            delete res.nonWitnessUtxo;
-        if (res.sequence === undefined)
-            res.sequence = DEFAULT_SEQUENCE;
-        if (res.tapMerkleRoot === null)
-            delete res.tapMerkleRoot;
-        res = mergeKeyMap(PSBTInput, res, cur, allowedFields);
-        PSBTInputCoder.encode(res); // Validates that everything is correct at this point
-        let prevOut;
-        if (res.nonWitnessUtxo && res.index !== undefined)
-            prevOut = res.nonWitnessUtxo.outputs[res.index];
-        else if (res.witnessUtxo)
-            prevOut = res.witnessUtxo;
-        if (prevOut && !this.opts.disableScriptCheck)
-            checkScript(prevOut && prevOut.script, res.redeemScript, res.witnessScript);
-        return res;
-    }
     addInput(input, _ignoreSignStatus = false) {
         if (!_ignoreSignStatus && !this.signStatus().addInput)
             throw new Error('Tx has signed inputs, cannot add new one');
-        this.inputs.push(this.normalizeInput(input));
+        this.inputs.push(normalizeInput(input, undefined, undefined, this.opts.disableScriptCheck));
         return this.inputs.length - 1;
     }
     updateInput(idx, input, _ignoreSignStatus = false) {
@@ -1984,7 +2073,7 @@ export class Transaction {
             if (!status.addInput || status.inputs.includes(idx))
                 allowedFields = PSBTInputUnsignedKeys;
         }
-        this.inputs[idx] = this.normalizeInput(input, this.inputs[idx], allowedFields);
+        this.inputs[idx] = normalizeInput(input, this.inputs[idx], allowedFields, this.opts.disableScriptCheck);
     }
     // Output stuff
     checkOutputIdx(idx) {
@@ -2016,7 +2105,7 @@ export class Transaction {
         if (res.script &&
             !this.opts.allowUnknownOutputs &&
             OutScript.decode(res.script).type === 'unknown') {
-            throw new Error('Transaction/output: unknown output script type, there is a chance that input is unspendable. Pass allowUnknownScript=true, if you sure');
+            throw new Error('Transaction/output: unknown output script type, there is a chance that input is unspendable. Pass allowUnknownOutputs=true, if you sure');
         }
         if (!this.opts.disableScriptCheck)
             checkScript(res.script, res.redeemScript, res.witnessScript);
@@ -2045,7 +2134,7 @@ export class Transaction {
     get fee() {
         let res = 0n;
         for (const i of this.inputs) {
-            const prevOut = this.prevOut(i);
+            const prevOut = getPrevOut(i);
             if (!prevOut)
                 throw new Error('Empty input amount');
             res += prevOut.amount;
@@ -2156,85 +2245,11 @@ export class Transaction {
             out.push(tapLeafHash(leafScript, leafVer), P.U8.encode(0), P.I32LE.encode(codeSeparator));
         return schnorr.utils.taggedHash('TapSighash', ...out);
     }
-    // Utils for sign/finalize
-    // Used pretty often, should be fast
-    prevOut(input) {
-        if (input.nonWitnessUtxo) {
-            if (input.index === undefined)
-                throw new Error('Unknown input index');
-            return input.nonWitnessUtxo.outputs[input.index];
-        }
-        else if (input.witnessUtxo)
-            return input.witnessUtxo;
-        else
-            throw new Error('Cannot find previous output info');
-    }
-    inputType(input) {
-        let txType = 'legacy';
-        let defaultSighash = SignatureHash.ALL;
-        const prevOut = this.prevOut(input);
-        const first = OutScript.decode(prevOut.script);
-        let type = first.type;
-        let cur = first;
-        const stack = [first];
-        if (first.type === 'tr') {
-            defaultSighash = SignatureHash.DEFAULT;
-            return {
-                txType: 'taproot',
-                type: 'tr',
-                last: first,
-                lastScript: prevOut.script,
-                defaultSighash,
-                sighash: input.sighashType || defaultSighash,
-            };
-        }
-        else {
-            if (first.type === 'wpkh' || first.type === 'wsh')
-                txType = 'segwit';
-            if (first.type === 'sh') {
-                if (!input.redeemScript)
-                    throw new Error('inputType: sh without redeemScript');
-                let child = OutScript.decode(input.redeemScript);
-                if (child.type === 'wpkh' || child.type === 'wsh')
-                    txType = 'segwit';
-                stack.push(child);
-                cur = child;
-                type += `-${child.type}`;
-            }
-            // wsh can be inside sh
-            if (cur.type === 'wsh') {
-                if (!input.witnessScript)
-                    throw new Error('inputType: wsh without witnessScript');
-                let child = OutScript.decode(input.witnessScript);
-                if (child.type === 'wsh')
-                    txType = 'segwit';
-                stack.push(child);
-                cur = child;
-                type += `-${child.type}`;
-            }
-            const last = stack[stack.length - 1];
-            if (last.type === 'sh' || last.type === 'wsh')
-                throw new Error('inputType: sh/wsh cannot be terminal type');
-            const lastScript = OutScript.encode(last);
-            const res = {
-                type,
-                txType,
-                last,
-                lastScript,
-                defaultSighash,
-                sighash: input.sighashType || defaultSighash,
-            };
-            if (txType === 'legacy' && !this.opts.allowLegacyWitnessUtxo && !input.nonWitnessUtxo) {
-                throw new Error(`Transaction/sign: legacy input without nonWitnessUtxo, can result in attack that forces paying higher fees. Pass allowLegacyWitnessUtxo=true, if you sure`);
-            }
-            return res;
-        }
-    }
     // Signer can be privateKey OR instance of bip32 HD stuff
     signIdx(privateKey, idx, allowedSighash, _auxRand) {
         this.checkInputIdx(idx);
         const input = this.inputs[idx];
-        const inputType = this.inputType(input);
+        const inputType = getInputType(input, this.opts.allowLegacyWitnessUtxo);
         // Handle BIP32 HDKey
         if (!isBytes(privateKey)) {
             if (!input.bip32Derivation || !input.bip32Derivation.length)
@@ -2279,11 +2294,11 @@ export class Transaction {
         }
         // Actual signing
         // Taproot
-        const prevOut = this.prevOut(input);
+        const prevOut = getPrevOut(input);
         if (inputType.txType === 'taproot') {
             if (input.tapBip32Derivation)
                 throw new Error('tapBip32Derivation unsupported');
-            const prevOuts = this.inputs.map(this.prevOut);
+            const prevOuts = this.inputs.map(getPrevOut);
             const prevOutScript = prevOuts.map((i) => i.script);
             const amount = prevOuts.map((i) => i.amount);
             let signed = false;
@@ -2383,7 +2398,7 @@ export class Transaction {
         if (this.fee < 0n)
             throw new Error('Outputs spends more than inputs amount');
         const input = this.inputs[idx];
-        const inputType = this.inputType(input);
+        const inputType = getInputType(input, this.opts.allowLegacyWitnessUtxo);
         // Taproot finalize
         if (inputType.txType === 'taproot') {
             if (input.tapKeySig)
@@ -2621,4 +2636,376 @@ export function PSBTCombine(psbts) {
         tx.combine(Transaction.fromPSBT(psbts[i]));
     return tx.toPSBT();
 }
-//# sourceMappingURL=index.js.map
+function estimateInput(inputType, input, opts) {
+    let script = P.EMPTY, witness;
+    // schnorr sig is always 64 bytes. except for cases when sighash is not default!
+    if (inputType.txType === 'taproot') {
+        const SCHNORR_SIG_SIZE = inputType.sighash !== SignatureHash.DEFAULT ? 65 : 64;
+        if (input.tapInternalKey && !P.equalBytes(input.tapInternalKey, TAPROOT_UNSPENDABLE_KEY)) {
+            witness = [new Uint8Array(SCHNORR_SIG_SIZE)];
+        }
+        else if (input.tapLeafScript) {
+            // If user want to select specific leaf (which can signed, it is possible to remove all other leafs manually);
+            // Sort leafs by control block length.
+            const leafs = input.tapLeafScript.sort((a, b) => TaprootControlBlock.encode(a[0]).length - TaprootControlBlock.encode(b[0]).length);
+            for (const [cb, _script] of leafs) {
+                // Last byte is version
+                const script = _script.slice(0, -1);
+                const outScript = OutScript.decode(script);
+                let signatures = [];
+                if (outScript.type === 'tr_ms') {
+                    const m = outScript.m;
+                    for (let i = 0; i < m; i++)
+                        signatures.push(new Uint8Array(SCHNORR_SIG_SIZE));
+                    const n = outScript.pubkeys.length - m;
+                    for (let i = 0; i < n; i++)
+                        signatures.push(P.EMPTY);
+                }
+                else if (outScript.type === 'tr_ns') {
+                    for (const _pub of outScript.pubkeys)
+                        signatures.push(new Uint8Array(SCHNORR_SIG_SIZE));
+                }
+                else
+                    throw new Error('Finalize: Unknown tapLeafScript');
+                // Witness is stack, so last element will be used first
+                witness = signatures.reverse().concat([script, TaprootControlBlock.encode(cb)]);
+                break;
+            }
+        }
+        else
+            throw new Error('estimateInput/taproot: unknown input');
+    }
+    else {
+        // It is possible to grind signatures until it has minimal size (but changing fee value +N satoshi),
+        // which will make estimations exact. But will be very hard for multi sig (need to make sure all signatures has small size).
+        const SIG_SIZE = 72; // Maximum size of signatures
+        const PUB_KEY_SIZE = 33;
+        let inputScript = P.EMPTY;
+        let inputWitness = [];
+        if (inputType.last.type === 'ms') {
+            const m = inputType.last.m;
+            const sig = [0];
+            for (let i = 0; i < m; i++)
+                sig.push(new Uint8Array(SIG_SIZE));
+            inputScript = Script.encode(sig);
+        }
+        else if (inputType.last.type === 'pk') {
+            // 71 sig + 1 sighash
+            inputScript = Script.encode([new Uint8Array(SIG_SIZE)]);
+        }
+        else if (inputType.last.type === 'pkh') {
+            inputScript = Script.encode([new Uint8Array(SIG_SIZE), new Uint8Array(PUB_KEY_SIZE)]);
+        }
+        else if (inputType.last.type === 'wpkh') {
+            inputScript = P.EMPTY;
+            inputWitness = [new Uint8Array(SIG_SIZE), new Uint8Array(PUB_KEY_SIZE)];
+        }
+        else if (inputType.last.type === 'unknown' && !opts.allowUnknownInputs)
+            throw new Error('Unknown inputs not allowed');
+        if (inputType.type.includes('wsh-')) {
+            // P2WSH
+            if (inputScript.length && inputType.lastScript.length) {
+                inputWitness = Script.decode(inputScript).map((i) => {
+                    if (i === 0)
+                        return P.EMPTY;
+                    if (isBytes(i))
+                        return i;
+                    throw new Error(`Wrong witness op=${i}`);
+                });
+            }
+            inputWitness = inputWitness.concat(inputType.lastScript);
+        }
+        if (inputType.txType === 'segwit')
+            witness = inputWitness;
+        if (inputType.type.startsWith('sh-wsh-')) {
+            script = Script.encode([Script.encode([0, new Uint8Array(sha256.outputLen)])]);
+        }
+        else if (inputType.type.startsWith('sh-')) {
+            script = Script.encode([...Script.decode(inputScript), inputType.lastScript]);
+        }
+        else if (inputType.type.startsWith('wsh-')) {
+        }
+        else if (inputType.txType !== 'segwit')
+            script = inputScript;
+    }
+    let weight = 160 + 4 * VarBytes.encode(script).length;
+    let hasWitnesses = false;
+    if (witness) {
+        weight += RawWitness.encode(witness).length;
+        hasWitnesses = true;
+    }
+    return { weight, hasWitnesses };
+}
+// Exported for tests, internal method
+export const _cmpBig = (a, b) => {
+    const n = a - b;
+    if (n < 0n)
+        return -1;
+    else if (n > 0n)
+        return 1;
+    return 0;
+};
+function getScript(o, opts = {}, network = NETWORK) {
+    let script;
+    if ('script' in o && o.script instanceof Uint8Array) {
+        script = o.script;
+    }
+    if ('address' in o) {
+        if (typeof o.address !== 'string')
+            throw new Error(`Estimator: wrong output address=${o.address}`);
+        script = OutScript.encode(Address(network).decode(o.address));
+    }
+    if (!script)
+        throw new Error('Estimator: wrong output script');
+    if (typeof o.amount !== 'bigint')
+        throw new Error(`Estimator: wrong output amount=${o.amount}`);
+    if (script && !opts.allowUnknownOutputs && OutScript.decode(script).type === 'unknown') {
+        throw new Error('Estimator: unknown output script type, there is a chance that input is unspendable. Pass allowUnknownOutputs=true, if you sure');
+    }
+    if (!opts.disableScriptCheck)
+        checkScript(script);
+    return script;
+}
+// class, because we need to re-use normalized inputs, instead of parsing each time
+// internal stuff, exported for tests only
+export class _Estimator {
+    constructor(inputs, outputs, opts) {
+        this.inputs = inputs;
+        this.outputs = outputs;
+        this.opts = opts;
+        // https://github.com/bitcoin/bitcoin/blob/f90603ac6d24f5263649675d51233f1fce8b2ecd/src/policy/policy.cpp#L44
+        // 32 + 4 + 1 + 107 + 4
+        // Dust used in accumExact + change address algo
+        // - change address: can be smaller for segwit
+        // - accumExact: ???
+        this.dust = 148n; // compat with coinselect
+        if (typeof opts.feePerByte !== 'bigint')
+            throw new Error(`Estimator: wrong feePerByte=${opts.feePerByte}`);
+        if (opts.dust) {
+            if (typeof opts.dust !== 'bigint')
+                throw new Error(`Estimator: wrong dust=${opts.dust}`);
+            this.dust = opts.dust;
+        }
+        const network = opts.network || NETWORK;
+        let amount = 0n;
+        // Base weight: tx with outputs, no inputs
+        let baseWeight = 32;
+        for (const o of outputs) {
+            const script = getScript(o, opts, opts.network);
+            baseWeight += 32 + 4 * VarBytes.encode(script).length;
+            amount += o.amount;
+        }
+        if (typeof opts.changeAddress !== 'string')
+            throw new Error(`Estimator: wrong change address=${opts.changeAddress}`);
+        let changeWeight = baseWeight +
+            32 +
+            4 * VarBytes.encode(OutScript.encode(Address(network).decode(opts.changeAddress))).length;
+        baseWeight += 4 * CompactSizeLen.encode(outputs.length).length;
+        // If there a lot of outputs change can change fee
+        changeWeight += 4 * CompactSizeLen.encode(outputs.length + 1).length;
+        this.baseWeight = baseWeight;
+        this.changeWeight = changeWeight;
+        this.amount = amount;
+        this.normalizedInputs = this.inputs.map((i) => {
+            const normalized = normalizeInput(i, undefined, undefined, opts.disableScriptCheck);
+            inputBeforeSign(normalized); // check fields
+            const inputType = getInputType(normalized, opts.allowLegacyWitnessUtxo);
+            const prev = getPrevOut(normalized);
+            const estimate = estimateInput(inputType, normalized, this.opts);
+            const value = prev.amount - opts.feePerByte * BigInt(toVsize(estimate.weight)); // value = amount-fee
+            return { inputType, normalized, amount: prev.amount, value, estimate };
+        });
+    }
+    checkInputIdx(idx) {
+        if (!Number.isSafeInteger(idx) || 0 > idx || idx >= this.inputs.length)
+            throw new Error(`Wrong input index=${idx}`);
+        return idx;
+    }
+    sortIndices(indices) {
+        return indices.slice().sort((a, b) => {
+            const ai = this.normalizedInputs[this.checkInputIdx(a)];
+            const bi = this.normalizedInputs[this.checkInputIdx(b)];
+            const out = _cmpBytes(ai.normalized.txid, bi.normalized.txid);
+            if (out !== 0)
+                return out;
+            return ai.normalized.index - bi.normalized.index;
+        });
+    }
+    sortOutputs(outputs) {
+        const scripts = outputs.map((o) => getScript(o, this.opts, this.opts.network));
+        const indices = outputs.map((_, j) => j);
+        return indices.sort((a, b) => {
+            const aa = outputs[a].amount;
+            const ba = outputs[b].amount;
+            const out = _cmpBig(aa, ba);
+            if (out !== 0)
+                return out;
+            return _cmpBytes(scripts[a], scripts[b]);
+        });
+    }
+    getSatoshi(weigth) {
+        return this.opts.feePerByte * BigInt(toVsize(weigth));
+    }
+    // Sort by value instead of amount
+    get biggest() {
+        return this.inputs
+            .map((_i, j) => j)
+            .sort((a, b) => _cmpBig(this.normalizedInputs[b].value, this.normalizedInputs[a].value));
+    }
+    get smallest() {
+        return this.biggest.reverse();
+    }
+    // These assume that UTXO array has historical order.
+    // Otherwise, we have no way to know which tx is oldest
+    // Explorers usually give UTXO in this order.
+    get oldest() {
+        return this.inputs.map((_i, j) => j);
+    }
+    get newest() {
+        return this.oldest.reverse();
+    }
+    // exact - like blackjack from coinselect.
+    // exact(biggest) will select one big utxo which is closer to targetValue+dust, if possible.
+    // If not, it will accumulate largest utxo until value is close to targetValue+dust.
+    accumulate(indices, exact = false, skipNegative = true, all = false) {
+        const { feePerByte } = this.opts;
+        // TODO: how to handle change addresses?
+        // - cost of input
+        // - cost of change output (if input requires change)
+        // - cost of output spending
+        // Dust threshold should be significantly bigger, no point in
+        // creating an output, which cannot be spent.
+        // coinselect doesn't consider cost of output address for dust.
+        // Changing that can actually reduce privacy
+        let weight = this.opts.alwaysChange ? this.changeWeight : this.baseWeight;
+        let hasWitnesses = false;
+        let num = 0;
+        let inputsAmount = 0n;
+        const targetAmount = this.amount;
+        const res = [];
+        let fee;
+        for (const idx of indices) {
+            this.checkInputIdx(idx);
+            const { estimate, amount, value } = this.normalizedInputs[idx];
+            let newWeight = weight + estimate.weight;
+            if (!hasWitnesses && estimate.hasWitnesses)
+                newWeight += 2; // enable witness if needed
+            const totalWeight = newWeight + 4 * CompactSizeLen.encode(num).length; // number of outputs can change weight
+            fee = this.getSatoshi(totalWeight);
+            // Best case scenario exact(biggest) -> we find biggest output, less than target+threshold
+            if (exact) {
+                const dust = this.dust * feePerByte;
+                // skip if added value is bigger than dust
+                if (amount + inputsAmount > targetAmount + fee + dust)
+                    continue;
+            }
+            // Negative: cost of using input is more than value provided (negative)
+            // By default 'blackjack' mode in coinselect doesn't use that, which means
+            // it will use negative output if sorted by 'smallest'
+            if (skipNegative && value <= 0n)
+                continue;
+            weight = newWeight;
+            if (estimate.hasWitnesses)
+                hasWitnesses = true;
+            num++;
+            inputsAmount += amount;
+            res.push(idx);
+            // inputsAmount is enough to cover cost of tx
+            if (!all && targetAmount + fee < inputsAmount)
+                return { indices: res, fee, weight: totalWeight, total: inputsAmount };
+        }
+        if (all) {
+            const newWeight = weight + 4 * CompactSizeLen.encode(num).length;
+            return { indices: res, fee, weight: newWeight, total: inputsAmount };
+        }
+        return undefined;
+    }
+    // Works like coinselect default method
+    default() {
+        const { biggest } = this;
+        const exact = this.accumulate(biggest, true, false);
+        if (exact)
+            return exact;
+        return this.accumulate(biggest);
+    }
+    select(strategy) {
+        if (strategy === 'all') {
+            return this.accumulate(this.inputs.map((_, j) => j), false, true, true);
+        }
+        if (strategy === 'default')
+            return this.default();
+        const data = {
+            Oldest: () => this.oldest,
+            Newest: () => this.newest,
+            Smallest: () => this.smallest,
+            Biggest: () => this.biggest,
+        };
+        if (strategy.startsWith('exact')) {
+            const [exactData, left] = strategy.slice(5).split('/');
+            if (!data[exactData])
+                throw new Error(`Estimator.select: wrong strategy=${strategy}`);
+            strategy = left;
+            const exact = this.accumulate(data[exactData](), true, true);
+            if (exact)
+                return exact;
+        }
+        if (strategy.startsWith('accum')) {
+            const accumData = strategy.slice(5);
+            if (!data[accumData])
+                throw new Error(`Estimator.select: wrong strategy=${strategy}`);
+            return this.accumulate(data[accumData]());
+        }
+        throw new Error(`Estimator.select: wrong strategy=${strategy}`);
+    }
+    result(strategy) {
+        const s = this.select(strategy);
+        if (!s)
+            return;
+        const { indices, weight, total } = s;
+        let needChange = this.opts.alwaysChange;
+        const changeWeight = this.opts.alwaysChange
+            ? weight
+            : weight + (this.changeWeight - this.baseWeight);
+        const changeFee = this.getSatoshi(changeWeight);
+        let fee = s.fee;
+        const change = total - this.amount - changeFee;
+        if (change > this.dust)
+            needChange = true;
+        let inputs = indices;
+        let outputs = Array.from(this.outputs);
+        if (needChange) {
+            fee = changeFee;
+            // this shouldn't happen!
+            if (change < 0n)
+                throw new Error(`Estimator.result: negative change=${change}`);
+            outputs.push({ address: this.opts.changeAddress, amount: change });
+        }
+        if (this.opts.bip69) {
+            inputs = this.sortIndices(inputs);
+            outputs = this.sortOutputs(outputs).map((i) => outputs[i]);
+        }
+        const res = {
+            inputs: inputs.map((i) => this.inputs[i]),
+            outputs,
+            fee,
+            weight: this.opts.alwaysChange ? s.weight : changeWeight,
+            change: !!needChange,
+        };
+        let tx;
+        if (this.opts.createTx) {
+            const { inputs, outputs } = res;
+            tx = new Transaction(this.opts);
+            for (const i of inputs)
+                tx.addInput(i);
+            for (const o of outputs)
+                tx.addOutput({ ...o, script: getScript(o, this.opts, this.opts.network) });
+        }
+        return { ...res, tx };
+    }
+}
+export function selectUTXO(inputs, outputs, strategy, opts) {
+    // Defaults: do we want bip69 by default?
+    const _opts = { createTx: true, bip69: true, ...opts };
+    const est = new _Estimator(inputs, outputs, _opts);
+    return est.result(strategy);
+}