@scure/btc-signer 1.1.1 → 1.2.1

package/index.ts

@@ -416,7 +416,7 @@ type PSBTKeyMapInfo = Readonly<
     any,
     readonly number[], // versionsRequiringInclusion
     readonly number[], // versionsAllowsInclusion
-    boolean // silentIgnore
+    boolean, // silentIgnore
   ]
 >;
 
@@ -714,12 +714,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) throw new Error(`nonWitnessUtxo: wrong txid, exp=${txid} got=${tx.id}`);
+    // 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;
 });
@@ -1705,6 +1719,109 @@ function validateOpts(opts: TxOpts) {
   return Object.freeze(_opts);
 }
 
+// Normalizes input
+function getPrevOut(input: TransactionInput): P.UnwrapCoder<typeof RawOutput> {
+  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: TransactionInputUpdate,
+  cur?: TransactionInput,
+  allowedFields?: (keyof TransactionInput)[],
+  disableScriptCheck = false
+): TransactionInput {
+  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: PSBTKeyMapKeys<typeof PSBTInput> = { ...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: TransactionInput, 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: number) => Math.ceil(weight / 4);
+
 export class Transaction {
   private global: PSBTKeyMapKeys<typeof PSBTGlobal> = {};
   private inputs: TransactionInput[] = []; // use getInput()
@@ -1845,7 +1962,7 @@ export class Transaction {
   // We will lose some vectors -> smaller test coverage of preimages (very important!)
   private inputSighash(idx: number) {
     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
@@ -1898,23 +2015,23 @@ export class Transaction {
   // https://en.bitcoin.it/wiki/Weight_units
   get weight(): number {
     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(): number {
-    return Math.ceil(this.weight / 4);
+    return toVsize(this.weight);
   }
   toBytes(withScriptSig = false, withWitness = false) {
     return RawTx.encode({
@@ -1957,40 +2074,10 @@ export class Transaction {
     return this.inputs.length;
   }
   // Modification
-  private normalizeInput(
-    i: TransactionInputUpdate,
-    cur?: TransactionInput,
-    allowedFields?: (keyof TransactionInput)[]
-  ): TransactionInput {
-    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: PSBTKeyMapKeys<typeof PSBTInput> = { ...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: TransactionInputUpdate, _ignoreSignStatus = false): number {
     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: number, input: TransactionInputUpdate, _ignoreSignStatus = false) {
@@ -2000,7 +2087,12 @@ export class Transaction {
       const status = this.signStatus();
       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
   private checkOutputIdx(idx: number) {
@@ -2034,7 +2126,7 @@ export class Transaction {
       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'
+        '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);
@@ -2062,7 +2154,7 @@ export class Transaction {
   get fee(): bigint {
     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;
     }
@@ -2110,7 +2202,7 @@ export class Transaction {
     });
     return sha256x2(tmpTx, P.I32LE.encode(hashType));
   }
-  private preimageWitnessV0(idx: number, prevOutScript: Bytes, hashType: number, amount: bigint) {
+  preimageWitnessV0(idx: number, prevOutScript: Bytes, hashType: number, amount: bigint) {
     const { isAny, isNone, isSingle } = unpackSighash(hashType);
     let inputHash = EMPTY32;
     let sequenceHash = EMPTY32;
@@ -2139,7 +2231,7 @@ export class Transaction {
       P.U32LE.encode(hashType)
     );
   }
-  private preimageWitnessV1(
+  preimageWitnessV1(
     idx: number,
     prevOutScript: Bytes[],
     hashType: number,
@@ -2194,78 +2286,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
-  private prevOut(input: TransactionInput): P.UnwrapCoder<typeof RawOutput> {
-    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');
-  }
-  private inputType(input: TransactionInput) {
-    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: Signer, idx: number, allowedSighash?: SigHash[], _auxRand?: Bytes): boolean {
     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)
@@ -2308,10 +2333,10 @@ 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;
@@ -2428,7 +2453,7 @@ export class Transaction {
     this.checkInputIdx(idx);
     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) input.finalScriptWitness = [input.tapKeySig];
@@ -2640,3 +2665,403 @@ export function PSBTCombine(psbts: Bytes[]): Bytes {
   for (let i = 1; i < psbts.length; i++) tx.combine(Transaction.fromPSBT(psbts[i]));
   return tx.toPSBT();
 }
+
+// UTXO Select
+type Output = { address: string; amount: bigint } | { script: Uint8Array; amount: bigint };
+
+function estimateInput(
+  inputType: ReturnType<typeof getInputType>,
+  input: TransactionInput,
+  opts: TxOpts
+) {
+  let script: Bytes = P.EMPTY,
+    witness: Bytes[] | undefined;
+
+  // 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: Bytes[] = [];
+        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: Uint8Array[] = [];
+    if (inputType.last.type === 'ms') {
+      const m = inputType.last.m;
+      const sig: (number | Uint8Array)[] = [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: bigint, b: bigint) => {
+  const n = a - b;
+  if (n < 0n) return -1;
+  else if (n > 0n) return 1;
+  return 0;
+};
+
+export type EstimatorOpts = TxOpts & {
+  // NOTE: fees less than 1 satoshi per vbyte is not supported. Please create issue if you have valid use case for that.
+  feePerByte: bigint; // satoshi per vbyte
+  changeAddress: string; // address where change will be sent
+  // Optional
+  alwaysChange?: boolean; // always create change, even if less than dust threshold
+  bip69?: boolean; // https://github.com/bitcoin/bips/blob/master/bip-0069.mediawiki
+  network?: typeof NETWORK;
+  dust?: number; // how much vbytes considered dust?
+  createTx?: boolean; // Create tx inside selection
+};
+
+function getScript(o: Output, opts: TxOpts = {}, 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;
+}
+
+// exact is meaningless without additional accum (will often fail if not possible to find right utxo)
+// -> we support only exact+accum or accum
+type SortStrategy = 'Newest' | 'Oldest' | 'Smallest' | 'Biggest';
+type ExactStrategy = `exact${SortStrategy}`;
+type AccumStrategy = `accum${SortStrategy}`;
+
+export type SelectionStrategy =
+  | 'all'
+  | 'default'
+  | AccumStrategy
+  | `${ExactStrategy}/${AccumStrategy}`;
+
+// class, because we need to re-use normalized inputs, instead of parsing each time
+// internal stuff, exported for tests only
+export class _Estimator {
+  private baseWeight: number;
+  private changeWeight: number;
+  private amount: bigint;
+  private normalizedInputs: {
+    inputType: ReturnType<typeof getInputType>;
+    normalized: ReturnType<typeof normalizeInput>;
+    amount: bigint;
+    value: bigint;
+    estimate: { weight: number; hasWitnesses: boolean };
+  }[];
+  // 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: ???
+  private dust = 148n; // compat with coinselect
+
+  constructor(
+    private inputs: TransactionInputUpdate[],
+    private outputs: Output[],
+    private opts: EstimatorOpts
+  ) {
+    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 };
+    });
+  }
+  private checkInputIdx(idx: number) {
+    if (!Number.isSafeInteger(idx) || 0 > idx || idx >= this.inputs.length)
+      throw new Error(`Wrong input index=${idx}`);
+    return idx;
+  }
+  private sortIndices(indices: number[]) {
+    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!;
+    });
+  }
+  private sortOutputs(outputs: Output[]) {
+    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]);
+    });
+  }
+  private getSatoshi(weigth: number) {
+    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: number[], 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);
+  }
+
+  private select(strategy: SelectionStrategy) {
+    if (strategy === 'all') {
+      return this.accumulate(
+        this.inputs.map((_, j) => j),
+        false,
+        true,
+        true
+      );
+    }
+    if (strategy === 'default') return this.default();
+    const data: Record<SortStrategy, () => number[]> = {
+      Oldest: () => this.oldest,
+      Newest: () => this.newest,
+      Smallest: () => this.smallest,
+      Biggest: () => this.biggest,
+    };
+    if (strategy.startsWith('exact')) {
+      const [exactData, left] = strategy.slice(5).split('/') as [SortStrategy, SelectionStrategy];
+      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) as SortStrategy;
+      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: SelectionStrategy) {
+    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: TransactionInputUpdate[],
+  outputs: Output[],
+  strategy: SelectionStrategy,
+  opts: EstimatorOpts
+) {
+  // 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);
+}