@scure/btc-signer 2.2.0 → 2.3.0

package/src/transaction.ts

@@ -1,4 +1,5 @@
 import { hex } from '@scure/base';
+import { anumber } from '@noble/hashes/utils.js';
 import * as P from 'micro-packed';
 import { Address, type CustomScript, OutScript, checkScript, tapLeafHash } from './payment.ts';
 import * as psbt from './psbt.ts';
@@ -9,7 +10,6 @@ import {
   RawInput,
   RawOutput,
   RawTx,
-  RawWitness,
   Script,
   scriptPushLen,
   VarBytes,
@@ -18,16 +18,22 @@ import * as u from './utils.ts';
 import {
   type Bytes,
   NETWORK,
+  abigint,
   concatBytes,
   equalBytes,
   isBytes,
   type TArg,
   type TRet,
+  validateObject,
 } from './utils.ts';
 
+// Be friendly to bad ECMAScript parsers by not using bigint literals.
+// prettier-ignore
+const _0n = /* @__PURE__ */ BigInt(0), _1n = /* @__PURE__ */ BigInt(1);
+const U64_MAX = /* @__PURE__ */ BigInt('0xffffffffffffffff');
 const EMPTY32: Uint8Array = /* @__PURE__ */ new Uint8Array(32);
 const EMPTY_OUTPUT: P.UnwrapCoder<typeof RawOutput> = {
-  amount: 0xffffffffffffffffn,
+  amount: U64_MAX,
   script: P.EMPTY,
 };
 /**
@@ -301,6 +307,7 @@ function outputBeforeSign(i: TArg<psbt.TransactionOutput>): TRet<psbt.Transactio
  * ```
  */
 export function inputBeforeSign(i: TArg<psbt.TransactionInput>): TRet<TransactionInputRequired> {
+  validateObject(i as Record<string, any>, {}, {}, 'i');
   if (i.txid === undefined || i.index === undefined)
     throw new Error('Transaction/input: txid and index required');
   const res = {
@@ -344,8 +351,7 @@ function unpackSighash(hashType: number) {
 }
 
 function validateOpts(opts: TArg<TxOpts>): TRet<Readonly<TxOpts>> {
-  if (opts !== undefined && {}.toString.call(opts) !== '[object Object]')
-    throw new Error(`Wrong object type for transaction options: ${opts}`);
+  if (opts !== undefined) validateObject(opts as Record<string, any>, {}, {}, 'opts');
 
   const _opts = {
     ...opts,
@@ -382,12 +388,15 @@ function validateOpts(opts: TArg<TxOpts>): TRet<Readonly<TxOpts>> {
       throw new Error(`Transation options wrong type: ${k}=${v} (${typeof v})`);
   }
   // 0 and -1 happens in tests
+  // With allowUnknownVersion any numeric version is fine; the ternary was inverted
+  // before 2026-07 (audit), which made the option throw for every numeric version.
   if (
     _opts.allowUnknownVersion
-      ? typeof _opts.version === 'number'
+      ? typeof _opts.version !== 'number'
       : ![-1, 0, 1, 2, 3].includes(_opts.version)
   )
     throw new Error(`Unknown version: ${_opts.version}`);
+  P.I32LE.encode(_opts.version); // Validate the signed transaction-version wire domain.
   if (_opts.customScripts !== undefined) {
     const cs = _opts.customScripts;
     if (!Array.isArray(cs)) {
@@ -407,6 +416,7 @@ function validateOpts(opts: TArg<TxOpts>): TRet<Readonly<TxOpts>> {
 
 // NOTE: we cannot do this inside PSBTInput coder, because there is no index/txid at this point!
 function validateInput(i: TArg<psbt.TransactionInput>): TRet<PSBTInputs> {
+  validateObject(i as Record<string, any>, {}, {}, 'i');
   const _i = i as PSBTInputs;
   if (_i.nonWitnessUtxo && _i.index !== undefined) {
     const last = _i.nonWitnessUtxo.outputs.length - 1;
@@ -433,6 +443,9 @@ function validateInput(i: TArg<psbt.TransactionInput>): TRet<PSBTInputs> {
         allowUnknownOutputs: true,
         disableScriptCheck: true,
         allowUnknownInputs: true,
+        // Consensus does not restrict nVersion; a previous tx with a non-standard
+        // version is still spendable and its txid must still be verifiable.
+        allowUnknownVersion: true,
       });
       const txid = hex.encode(_i.txid);
       // BIP174 requires the provided nonWitnessUtxo to hash to the prevout txid even when the
@@ -465,6 +478,7 @@ export type PSBTOutputs = psbt.PSBTKeyMapKeys<typeof psbt.PSBTOutput>;
  * ```
  */
 export function getPrevOut(input: TArg<psbt.TransactionInput>): P.UnwrapCoder<typeof RawOutput> {
+  validateObject(input as Record<string, any>, {}, {}, 'input');
   const _input = input as PSBTInputs;
   if (_input.nonWitnessUtxo) {
     if (_input.index === undefined) throw new Error('Unknown input index');
@@ -478,8 +492,17 @@ export function getPrevOut(input: TArg<psbt.TransactionInput>): P.UnwrapCoder<ty
     )
       throw new Error(`Wrong input index=${_input.index}`);
     return _input.nonWitnessUtxo.outputs[_input.index];
-  } else if (_input.witnessUtxo) return _input.witnessUtxo;
-  else throw new Error('Cannot find previous output info');
+  } else if ('witnessUtxo' in _input) {
+    // The presence check catches malformed provided values; narrow after the guard for TS.
+    const prev = _input.witnessUtxo as P.UnwrapCoder<typeof RawOutput>;
+    validateObject(prev as Record<string, any>, {}, {}, 'input.witnessUtxo');
+    abigint(prev.amount, 'input.witnessUtxo.amount');
+    if (!isBytes(prev.script))
+      throw new TypeError(
+        '"input.witnessUtxo.script" expected Uint8Array, got type=' + typeof prev.script
+      );
+    return prev;
+  } else throw new Error('Cannot find previous output info');
 }
 
 /**
@@ -510,6 +533,9 @@ export function normalizeInput(
   disableScriptCheck = false,
   allowUnknown = false
 ): TRet<PSBTInputs> {
+  validateObject(i as Record<string, any>, {}, {}, 'i');
+  if (cur !== undefined) validateObject(cur as Record<string, any>, {}, {}, 'cur');
+  if (allowedFields !== undefined) u.aarray(allowedFields, 'allowedFields');
   const _i = i as psbt.TransactionInputUpdate;
   const _cur = cur as PSBTInputs | undefined;
   const _allowedFields = allowedFields as readonly (keyof PSBTInputs)[] | undefined;
@@ -718,6 +744,7 @@ export class Transaction {
   toPSBT(
     PSBTVersion: number | undefined = this.global.version || this.opts.PSBTVersion
   ): Uint8Array {
+    if (PSBTVersion !== undefined) anumber(PSBTVersion, 'PSBTVersion');
     if (PSBTVersion !== 0 && PSBTVersion !== 2)
       throw new Error(`Wrong PSBT version=${PSBTVersion}`);
     // if (PSBTVersion === 0 && this.inputs.length === 0) {
@@ -878,27 +905,33 @@ export class Transaction {
 
   // Info utils
   get hasWitnesses(): boolean {
-    let out = false;
     for (const i of this.inputs)
-      if (i.finalScriptWitness && i.finalScriptWitness.length) out = true;
-    return out;
+      if (i.finalScriptWitness && i.finalScriptWitness.length) return true;
+    return false;
   }
   // https://en.bitcoin.it/wiki/Weight_units
   get weight(): number {
     if (!this.isFinal) throw new Error('Transaction is not finalized');
+    // Serialized length of VarBytes(data) without allocating the encoded copy
+    const varLen = (dataLen: number) => CompactSizeLen.encode(dataLen).length + dataLen;
+    const hasWitnesses = this.hasWitnesses;
     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;
+    for (const o of outputs) out += 32 + 4 * varLen(o.script.length);
     // Inputs
-    if (this.hasWitnesses) out += 2;
+    if (hasWitnesses) out += 2;
     out += 4 * CompactSizeLen.encode(this.inputs.length).length;
     for (const i of this.inputs) {
-      out += 160 + 4 * VarBytes.encode(i.finalScriptSig || P.EMPTY).length;
+      out += 160 + 4 * varLen((i.finalScriptSig || P.EMPTY).length);
       // Once segwit serialization is active, every input contributes one witness vector, including
       // legacy inputs whose empty vector still encodes as a single zero-item-count byte.
-      if (this.hasWitnesses) out += RawWitness.encode(i.finalScriptWitness || []).length;
+      if (hasWitnesses) {
+        const witness = i.finalScriptWitness || [];
+        out += CompactSizeLen.encode(witness.length).length;
+        for (const w of witness) out += varLen(w.length);
+      }
     }
     return out;
   }
@@ -933,8 +966,8 @@ export class Transaction {
   }
   // Input stuff
   private checkInputIdx(idx: number) {
-    if (!Number.isSafeInteger(idx) || 0 > idx || idx >= this.inputs.length)
-      throw new Error(`Wrong input index=${idx}`);
+    anumber(idx, 'idx');
+    if (idx >= this.inputs.length) throw new Error(`Wrong input index=${idx}`);
   }
   getInput(idx: number): psbt.TransactionInput {
     this.checkInputIdx(idx);
@@ -945,6 +978,7 @@ export class Transaction {
   }
   // Modification
   addInput(input: TArg<psbt.TransactionInputUpdate>, _ignoreSignStatus = false): number {
+    validateObject(input as Record<string, any>, {}, {}, 'input');
     if (!_ignoreSignStatus && !this.signStatus().addInput)
       throw new Error('Tx has signed inputs, cannot add new one');
     // normalizeInput preserves nested caller-owned byte arrays, so detach them here before the
@@ -982,8 +1016,8 @@ export class Transaction {
   }
   // Output stuff
   private checkOutputIdx(idx: number) {
-    if (!Number.isSafeInteger(idx) || 0 > idx || idx >= this.outputs.length)
-      throw new Error(`Wrong output index=${idx}`);
+    anumber(idx, 'idx');
+    if (idx >= this.outputs.length) throw new Error(`Wrong output index=${idx}`);
   }
   getOutput(idx: number): psbt.TransactionOutput {
     this.checkOutputIdx(idx);
@@ -1005,12 +1039,10 @@ export class Transaction {
     cur?: PSBTOutputs,
     allowedFields?: readonly (keyof typeof psbt.PSBTOutput)[]
   ): PSBTOutputs {
+    validateObject(o as Record<string, any>, {}, {}, 'o');
     let { amount, script } = o;
     if (amount === undefined) amount = cur?.amount;
-    if (typeof amount !== 'bigint')
-      throw new Error(
-        `Wrong amount type, should be of type bigint in sats, but got ${amount} of type ${typeof amount}`
-      );
+    amount = abigint(amount, 'o.amount');
     if (typeof script === 'string') script = hex.decode(script);
     if (script === undefined) script = cur?.script;
     let res: PSBTOutputs = { ...cur, ...(o as PSBTOutputs & { script?: string }), amount, script };
@@ -1065,7 +1097,7 @@ export class Transaction {
   }
   // Utils
   get fee(): bigint {
-    let res = 0n;
+    let res = _0n;
     for (const i of this.inputs) {
       const prevOut = getPrevOut(i);
       if (!prevOut) throw new Error('Empty input amount');
@@ -1084,7 +1116,7 @@ export class Transaction {
     const { isAny, isNone, isSingle } = unpackSighash(hashType);
     if (idx < 0 || !Number.isSafeInteger(idx)) throw new Error(`Invalid input idx=${idx}`);
     if ((isSingle && idx >= this.outputs.length) || idx >= this.inputs.length)
-      return P.U256BE.encode(1n);
+      return P.U256BE.encode(_1n);
     prevOutScript = stripCodeSeparator(prevOutScript);
     let inputs: TransactionInputRequired[] = this.inputs
       .map(inputBeforeSign)
@@ -1124,8 +1156,8 @@ export class Transaction {
   ): Uint8Array {
     // BIP143 serializes txTo.vin[nIn].prevout and txTo.vin[nIn].nSequence, so reject an invalid
     // nIn explicitly instead of leaking a later undefined-input TypeError from inputs[idx].
-    if (idx < 0 || !Number.isSafeInteger(idx) || idx >= this.inputs.length)
-      throw new Error(`Invalid input idx=${idx}`);
+    anumber(idx, 'idx');
+    if (idx >= this.inputs.length) throw new Error(`Invalid input idx=${idx}`);
     const { isAny, isNone, isSingle } = unpackSighash(hashType);
     let inputHash = EMPTY32;
     let sequenceHash = EMPTY32;
@@ -1164,15 +1196,16 @@ export class Transaction {
     leafVer = 0xc0,
     annex?: Bytes
   ): Uint8Array {
-    if (!Array.isArray(amount) || this.inputs.length !== amount.length)
-      throw new Error(`Invalid amounts array=${amount}`);
-    if (!Array.isArray(prevOutScript) || this.inputs.length !== prevOutScript.length)
-      throw new Error(`Invalid prevOutScript array=${prevOutScript}`);
     // BIP341 SigMsg commits either to input_index or to the selected input's outpoint/amount/script/
     // sequence under ANYONECANPAY, so reject an invalid index explicitly instead of hashing a
     // nonexistent input or leaking a later integer-encoding RangeError for negative idx.
-    if (idx < 0 || !Number.isSafeInteger(idx) || idx >= this.inputs.length)
-      throw new Error(`Invalid input idx=${idx}`);
+    anumber(idx, 'idx');
+    if (idx >= this.inputs.length) throw new Error(`Invalid input idx=${idx}`);
+    u.aarray(amount, 'amount');
+    u.aarray(prevOutScript, 'prevOutScript');
+    if (this.inputs.length !== amount.length) throw new Error(`Invalid amounts array=${amount}`);
+    if (this.inputs.length !== prevOutScript.length)
+      throw new Error(`Invalid prevOutScript array=${prevOutScript}`);
     const out: Bytes[] = [
       P.U8.encode(0),
       P.U8.encode(hashType), // U8 sigHash
@@ -1216,6 +1249,18 @@ export class Transaction {
   }
   // Signer can be privateKey OR instance of bip32 HD stuff
   signIdx(privateKey: Signer, idx: number, allowedSighash?: SigHash[], _auxRand?: Bytes): boolean {
+    if (!isBytes(privateKey)) {
+      // HDKey is a structural external instance, so plain-object validation would
+      // reject valid signers.
+      if (
+        !privateKey ||
+        typeof privateKey !== 'object' ||
+        typeof (privateKey as HDKey).deriveChild !== 'function'
+      )
+        throw new TypeError(
+          '"privateKey" expected Uint8Array or HDKey, got type=' + typeof privateKey
+        );
+    }
     this.checkInputIdx(idx);
     const input = this.inputs[idx];
     const inputType = getInputType(
@@ -1438,7 +1483,7 @@ export class Transaction {
 
   finalizeIdx(idx: number): void {
     this.checkInputIdx(idx);
-    if (this.fee < 0n) throw new Error('Outputs spends more than inputs amount');
+    if (this.fee < _0n) throw new Error('Outputs spends more than inputs amount');
     const input = this.inputs[idx];
     const inputType = getInputType(input, this.opts.allowLegacyWitnessUtxo);
     // Taproot finalize
@@ -1592,10 +1637,12 @@ export class Transaction {
   extract(): Uint8Array {
     if (!this.isFinal) throw new Error('Transaction has unfinalized inputs');
     if (!this.outputs.length) throw new Error('Transaction has no outputs');
-    if (this.fee < 0n) throw new Error('Outputs spends more than inputs amount');
+    if (this.fee < _0n) throw new Error('Outputs spends more than inputs amount');
     return this.toBytes(true, true);
   }
   combine(other: Transaction): this {
+    if (!(other instanceof Transaction))
+      throw new TypeError('"other" expected Transaction, got type=' + typeof other);
     // BIP174 combiners merge same-transaction PSBTs across versions and emit the highest required
     // version, so PSBTVersion mismatches are normalized below instead of treated as conflicts.
     const PSBTVersion = Math.max(this.opts.PSBTVersion || 0, other.opts.PSBTVersion || 0);

package/src/utils.ts

@@ -4,6 +4,7 @@ import { ripemd160 } from '@noble/hashes/legacy.js';
 import { sha256 as nobleSha256 } from '@noble/hashes/sha2.js';
 import { type TArg, type TRet } from '@noble/hashes/utils.js';
 import { utils as packedUtils, U32LE } from 'micro-packed';
+export { abytes, validateObject as vld } from '@noble/curves/utils.js';
 export { type TArg, type TRet } from '@noble/hashes/utils.js';
 
 /** Hex-like input accepted by helpers in this module. */
@@ -11,9 +12,71 @@ export type Hex = string | Uint8Array;
 /** Byte array alias used across the library. */
 export type Bytes = Uint8Array;
 
+/**
+ * Validates that a value is a non-negative bigint.
+ * @param n - Value to validate.
+ * @param title - Label included in thrown errors.
+ * @returns The same bigint.
+ * @throws On wrong argument types. {@link TypeError}
+ * @example
+ * Validate a satoshi amount before transaction encoding.
+ * ```ts
+ * abigint(1n, 'amount');
+ * ```
+ */
+export function abigint(n: unknown, title: string = 'value'): bigint {
+  if (typeof n !== 'bigint')
+    throw new TypeError(`"${title}" expected bigint, got type=${typeof n}`);
+  if (n < _0n) throw new RangeError(`"${title}" expected non-negative bigint, got ${n}`);
+  return n;
+}
+
+import { validateObject as vld } from '@noble/curves/utils.js';
+
+export function aarray<T>(
+  item: unknown,
+  title: string,
+  inner: (elm: T, title: string) => void = () => {}
+): T[] {
+  if (!Array.isArray(item))
+    throw new TypeError(`"${title}" expected array, got type=${typeof item}`);
+  for (let i = 0; i < item.length; i++) inner(item[i], `${title}[${i}]`);
+  return item;
+}
+/**
+ * Asserts something is a string.
+ * @param value - Value to validate.
+ * @param title - Label included in thrown errors.
+ * @returns The validated string.
+ * @throws On wrong argument types. {@link TypeError}
+ * @example
+ * Validate a label string.
+ *
+ * ```ts
+ * astring('example', 'label');
+ * ```
+ */
+export function astring(value: unknown, title: string = ''): string {
+  if (typeof value !== 'string') {
+    const prefix = title && `"${title}" `;
+    throw new TypeError(prefix + 'expected string, got type=' + typeof value);
+  }
+  return value;
+}
+export function validateObject(
+  object: Record<string, any>,
+  fields: Record<string, string> = {},
+  optFields: Record<string, string> = {},
+  _title = 'object'
+) {
+  return vld(object, fields, optFields);
+}
 const Point = /* @__PURE__ */ (() => secp.Point)();
 const Fn = /* @__PURE__ */ (() => Point.Fn)();
 const CURVE_ORDER = /* @__PURE__ */ (() => Point.Fn.ORDER)();
+// Be friendly to bad ECMAScript parsers by not using bigint literals.
+// prettier-ignore
+const _0n = /* @__PURE__ */ BigInt(0), _2n = /* @__PURE__ */ BigInt(2);
 /**
  * Checks whether a curve y-coordinate is even.
  * @param y - y-coordinate to inspect
@@ -24,7 +87,7 @@ const CURVE_ORDER = /* @__PURE__ */ (() => Point.Fn.ORDER)();
  * hasEven(2n);
  * ```
  */
-export const hasEven = (y: bigint) => y % 2n === 0n;
+export const hasEven = (y: bigint) => y % _2n === _0n;
 
 /**
  * Checks whether a value is a Uint8Array.
@@ -144,7 +207,10 @@ export const pubECDSA = (privateKey: TArg<Uint8Array>, isCompressed?: boolean):
 // noble/secp256k1 does not support the feature: it is not used outside of BTC.
 // We implement it manually, because in BTC it's common.
 // Not best way, but closest to bitcoin implementation (easier to check)
-const hasLowR = (sig: { r: bigint; s: bigint }) => sig.r < CURVE_ORDER / 2n;
+// Hoisted: the bound is constant; no need to redo the bigint division on every
+// grinding-loop iteration. n/2 < 2^255, so r < n/2 guarantees the 32-byte DER r.
+const LOW_R_BOUND = /* @__PURE__ */ (() => CURVE_ORDER / _2n)();
+const hasLowR = (sig: { r: bigint; s: bigint }) => sig.r < LOW_R_BOUND;
 /**
  * Signs a 32-byte hash with ECDSA and returns DER encoding.
  * @param hash - message hash to sign

package/src/utxo.ts

@@ -2,7 +2,7 @@ import { hex } from '@scure/base';
 import * as P from 'micro-packed';
 import { Address, type CustomScript, OutScript, checkScript, tapLeafHash } from './payment.ts';
 import * as psbt from './psbt.ts';
-import { CompactSizeLen, RawWitness, Script, VarBytes } from './script.ts';
+import { CompactSizeLen, Script } from './script.ts';
 import {
   SignatureHash,
   Transaction,
@@ -14,6 +14,9 @@ import {
   toVsize,
 } from './transaction.ts';
 import {
+  abigint,
+  aarray,
+  astring,
   type Bytes,
   NETWORK,
   PubT,
@@ -24,6 +27,7 @@ import {
   isBytes,
   sha256,
   validatePubkey,
+  validateObject,
 } from './utils.ts';
 
 // UTXO Select
@@ -41,6 +45,11 @@ export type Accumulated =
 type TapLeafScript = psbt.TransactionInput['tapLeafScript'];
 type TB = Parameters<typeof psbt.TaprootControlBlock.encode>[0];
 const encodeTapBlock = (item: TB) => psbt.TaprootControlBlock.encode(item);
+// Be friendly to bad ECMAScript parsers by not using bigint literals.
+// prettier-ignore
+const _0n = /* @__PURE__ */ BigInt(0), _3n = /* @__PURE__ */ BigInt(3);
+// Serialized length of VarBytes(data) without allocating the encoded copy
+const varLen = (dataLen: number) => CompactSizeLen.encode(dataLen).length + dataLen;
 
 function iterLeafs(
   tapLeafScript: TArg<TapLeafScript>,
@@ -175,10 +184,11 @@ function estimateInput(
     } else if (inputType.type.startsWith('wsh-')) {
     } else if (inputType.txType !== 'segwit') script = inputScript;
   }
-  let weight = 160 + 4 * VarBytes.encode(script).length;
+  let weight = 160 + 4 * varLen(script.length);
   let hasWitnesses = false;
   if (witness) {
-    weight += RawWitness.encode(witness).length;
+    weight += CompactSizeLen.encode(witness.length).length;
+    for (const w of witness) weight += varLen(w.length);
     hasWitnesses = true;
   }
   return { weight, hasWitnesses };
@@ -189,8 +199,8 @@ export const _cmpBig = (a: bigint, b: bigint): 0 | 1 | -1 => {
   // Array.sort comparators must return a number, so normalize bigint comparisons to -1/0/1
   // instead of coercing large differences through Number(...) and losing ordering precision.
   const n = a - b;
-  if (n < 0n) return -1;
-  else if (n > 0n) return 1;
+  if (n < _0n) return -1;
+  else if (n > _0n) return 1;
   return 0;
 };
 
@@ -212,6 +222,7 @@ export type EstimatorOpts = TxOpts & {
 };
 
 function getScript(o: TArg<Output>, opts: TArg<TxOpts> = {}, network = NETWORK) {
+  validateObject(o as Record<string, any>, {}, {}, 'output');
   const _o = o as Output;
   const _opts = opts as TxOpts;
   let script;
@@ -219,8 +230,7 @@ function getScript(o: TArg<Output>, opts: TArg<TxOpts> = {}, network = NETWORK)
     script = _o.script;
   }
   if ('address' in _o) {
-    if (typeof _o.address !== 'string')
-      throw new Error(`Estimator: wrong output address=${_o.address}`);
+    astring(_o.address, 'output.address');
     // Address.decode() only yields known descriptors for valid output addresses, but the wrapped
     // coder type still includes `undefined`, so narrow before re-encoding the script template.
     script = OutScript.encode(
@@ -228,15 +238,9 @@ function getScript(o: TArg<Output>, opts: TArg<TxOpts> = {}, network = NETWORK)
     );
   }
   if (!script) throw new Error('Estimator: wrong output script');
-  if (typeof _o.amount !== 'bigint')
-    throw new Error(
-      `Estimator: wrong output amount=${
-        _o.amount
-      }, should be of type bigint but got ${typeof _o.amount}.`
-    );
   // Keep selector-only `createTx: false` flows aligned with the transaction/PSBT output boundary:
   // satoshi-denominated outputs are not allowed to go negative.
-  if (_o.amount < 0n) throw new Error(`Estimator: wrong output amount=${_o.amount}`);
+  abigint(_o.amount, 'output.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'
@@ -282,16 +286,9 @@ export class _Estimator {
   constructor(inputs: psbt.TransactionInputUpdate[], outputs: Output[], opts: EstimatorOpts) {
     this.outputs = outputs;
     this.opts = opts;
-    if (typeof opts.feePerByte !== 'bigint')
-      throw new Error(
-        `Estimator: wrong feePerByte=${
-          opts.feePerByte
-        }, should be of type bigint but got ${typeof opts.feePerByte}.`
-      );
     // Zero-fee estimation is useful on regtest/in tests, but negative fee rates would make
     // `getSatoshi(...)` produce nonsensical negative fees throughout selection.
-    if (opts.feePerByte < 0n)
-      throw new Error(`Estimator: feePerByte must be >= 0 satoshi per vbyte`);
+    abigint(opts.feePerByte, 'opts.feePerByte');
     // Dust stuff
     // TODO: think about this more:
     // - current dust filters tx which cannot be relayed by core
@@ -304,46 +301,37 @@ export class _Estimator {
     const inputsDust = 32 + 4 + 1 + 107 + 4; // NOTE: can be smaller for segwit tx?
     const outputDust = 34; // NOTE: 'nSize = GetSerializeSize(txout)'
     const dustBytes = opts.dust === undefined ? BigInt(inputsDust + outputDust) : opts.dust;
-    if (typeof dustBytes !== 'bigint') {
-      throw new Error(
-        `Estimator: wrong dust=${opts.dust}, should be of type bigint but got ${typeof opts.dust}.`
-      );
-    }
+    abigint(dustBytes, 'opts.dust');
     // 3 sat/vb is the default minimum fee rate used to calculate dust thresholds by bitcoin core.
     // 3000 sat/kvb -> 3 sat/vb.
     // https://github.com/bitcoin/bitcoin/blob/27a770b34b8f1dbb84760f442edb3e23a0c2420b/src/policy/policy.h#L55
-    const dustFee = opts.dustRelayFeeRate === undefined ? 3n : opts.dustRelayFeeRate;
-    if (typeof dustFee !== 'bigint') {
-      throw new Error(
-        `Estimator: wrong dustRelayFeeRate=${opts.dustRelayFeeRate}, should be of type bigint but got ${typeof opts.dustRelayFeeRate}.`
-      );
-    }
+    const dustFee = opts.dustRelayFeeRate === undefined ? _3n : opts.dustRelayFeeRate;
+    abigint(dustFee, 'opts.dustRelayFeeRate');
     // Dust uses feePerbyte by default, but we allow separate dust fee if needed
     this.dust = dustBytes * dustFee;
     if (opts.requiredInputs !== undefined && !Array.isArray(opts.requiredInputs))
       throw new Error(`Estimator: wrong required inputs=${opts.requiredInputs}`);
     const network = opts.network || NETWORK;
-    let amount = 0n;
+    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;
+      baseWeight += 32 + 4 * varLen(script.length);
       amount += o.amount;
     }
-    if (typeof opts.changeAddress !== 'string')
-      throw new Error(`Estimator: wrong change address=${opts.changeAddress}`);
+    astring(opts.changeAddress, 'opts.changeAddress');
     let changeWeight =
       baseWeight +
       32 +
       // Same Address.decode() narrowing as above: the estimator only reaches this path for a
       // concrete change output address, not an unknown descriptor.
       4 *
-        VarBytes.encode(
+        varLen(
           OutScript.encode(
             Address(network).decode(opts.changeAddress) as Parameters<typeof OutScript.encode>[0]
-          )
-        ).length;
+          ).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;
@@ -441,7 +429,7 @@ export class _Estimator {
     let weight = this.opts.alwaysChange ? this.changeWeight : this.baseWeight;
     let hasWitnesses = false;
     let num = 0;
-    let inputsAmount = 0n;
+    let inputsAmount = _0n;
     const targetAmount = this.amount;
     const res: Set<number> = new Set();
     let fee;
@@ -483,7 +471,7 @@ export class _Estimator {
       // 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;
+      if (skipNegative && value <= _0n) continue;
       weight = newWeight;
       if (estimate.hasWitnesses) hasWitnesses = true;
       num = newNum;
@@ -495,6 +483,10 @@ export class _Estimator {
     }
     if (all) {
       const total = getTotal(weight, num);
+      // 'all' accumulates unconditionally, so sufficiency must be checked here; otherwise
+      // result() would report a negative fee (or throw its internal negative-change error).
+      // Insufficient funds are a selection failure, same as for accumulation strategies.
+      if (targetAmount + total.fee > inputsAmount) return undefined;
       return {
         indices: Array.from(res),
         fee: total.fee,
@@ -572,7 +564,7 @@ export class _Estimator {
     if (needChange) {
       fee = changeFee;
       // this shouldn't happen!
-      if (change < 0n) throw new Error(`Estimator.result: negative change=${change}`);
+      if (change < _0n) throw new Error(`Estimator.result: negative change=${change}`);
       outputs.push({ address: this.opts.changeAddress, amount: change });
     }
     if (this.opts.bip69) {
@@ -634,6 +626,10 @@ export function selectUTXO(
   strategy: SelectionStrategy,
   opts: TArg<EstimatorOpts>
 ) {
+  aarray(inputs, 'inputs');
+  aarray(outputs, 'outputs');
+  validateObject(opts as Record<string, any>, {}, {}, 'opts');
+  astring(strategy, 'strategy');
   // Public wrapper defaults to BIP69 ordering and tx construction unless callers override them.
   const _opts = { createTx: true, bip69: true, ...(opts as EstimatorOpts) };
   const est = new _Estimator(inputs as psbt.TransactionInputUpdate[], outputs as Output[], _opts);

package/transaction.d.ts

@@ -374,4 +374,3 @@ export declare function PSBTCombine(psbts: TArg<Bytes[]>): TRet<Bytes>;
  */
 export declare function bip32Path(path: string): number[];
 export {};
-//# sourceMappingURL=transaction.d.ts.map