@scure/btc-signer 2.2.0 → 2.3.0

package/transaction.js

@@ -1,13 +1,18 @@
 import { hex } from '@scure/base';
+import { anumber } from '@noble/hashes/utils.js';
 import * as P from 'micro-packed';
 import { Address, OutScript, checkScript, tapLeafHash } from "./payment.js";
 import * as psbt from "./psbt.js";
-import { CompactSizeLen, OP, RawOldTx, RawInput, RawOutput, RawTx, RawWitness, Script, scriptPushLen, VarBytes, } from "./script.js";
+import { CompactSizeLen, OP, RawOldTx, RawInput, RawOutput, RawTx, Script, scriptPushLen, VarBytes, } from "./script.js";
 import * as u from "./utils.js";
-import { NETWORK, concatBytes, equalBytes, isBytes, } from "./utils.js";
+import { NETWORK, abigint, concatBytes, equalBytes, isBytes, validateObject, } from "./utils.js";
+// 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 = /* @__PURE__ */ new Uint8Array(32);
 const EMPTY_OUTPUT = {
-    amount: 0xffffffffffffffffn,
+    amount: U64_MAX,
     script: P.EMPTY,
 };
 /**
@@ -195,6 +200,7 @@ function outputBeforeSign(i) {
  * ```
  */
 export function inputBeforeSign(i) {
+    validateObject(i, {}, {}, 'i');
     if (i.txid === undefined || i.index === undefined)
         throw new Error('Transaction/input: txid and index required');
     const res = {
@@ -235,8 +241,8 @@ function unpackSighash(hashType) {
     };
 }
 function validateOpts(opts) {
-    if (opts !== undefined && {}.toString.call(opts) !== '[object Object]')
-        throw new Error(`Wrong object type for transaction options: ${opts}`);
+    if (opts !== undefined)
+        validateObject(opts, {}, {}, 'opts');
     const _opts = {
         ...opts,
         // Defaults
@@ -274,10 +280,13 @@ function validateOpts(opts) {
             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)) {
@@ -294,6 +303,7 @@ function validateOpts(opts) {
 }
 // NOTE: we cannot do this inside PSBTInput coder, because there is no index/txid at this point!
 function validateInput(i) {
+    validateObject(i, {}, {}, 'i');
     const _i = i;
     if (_i.nonWitnessUtxo && _i.index !== undefined) {
         const last = _i.nonWitnessUtxo.outputs.length - 1;
@@ -320,6 +330,9 @@ function validateInput(i) {
                 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
@@ -346,6 +359,7 @@ function validateInput(i) {
  * ```
  */
 export function getPrevOut(input) {
+    validateObject(input, {}, {}, 'input');
     const _input = input;
     if (_input.nonWitnessUtxo) {
         if (_input.index === undefined)
@@ -359,8 +373,15 @@ export function getPrevOut(input) {
             throw new Error(`Wrong input index=${_input.index}`);
         return _input.nonWitnessUtxo.outputs[_input.index];
     }
-    else if (_input.witnessUtxo)
-        return _input.witnessUtxo;
+    else if ('witnessUtxo' in _input) {
+        // The presence check catches malformed provided values; narrow after the guard for TS.
+        const prev = _input.witnessUtxo;
+        validateObject(prev, {}, {}, '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');
 }
@@ -386,6 +407,11 @@ export function getPrevOut(input) {
  * ```
  */
 export function normalizeInput(i, cur, allowedFields, disableScriptCheck = false, allowUnknown = false) {
+    validateObject(i, {}, {}, 'i');
+    if (cur !== undefined)
+        validateObject(cur, {}, {}, 'cur');
+    if (allowedFields !== undefined)
+        u.aarray(allowedFields, 'allowedFields');
     const _i = i;
     const _cur = cur;
     const _allowedFields = allowedFields;
@@ -602,6 +628,8 @@ export class Transaction {
     // Prefer `global.version` when present so cross-version combiners can serialize at the highest
     // required PSBT version without mutating the frozen transaction options object.
     toPSBT(PSBTVersion = this.global.version || this.opts.PSBTVersion) {
+        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) {
@@ -774,32 +802,38 @@ export class Transaction {
     }
     // Info utils
     get hasWitnesses() {
-        let out = false;
         for (const i of this.inputs)
             if (i.finalScriptWitness && i.finalScriptWitness.length)
-                out = true;
-        return out;
+                return true;
+        return false;
     }
     // https://en.bitcoin.it/wiki/Weight_units
     get weight() {
         if (!this.isFinal)
             throw new Error('Transaction is not finalized');
+        // Serialized length of VarBytes(data) without allocating the encoded copy
+        const varLen = (dataLen) => 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;
+            out += 32 + 4 * varLen(o.script.length);
         // Inputs
-        if (this.hasWitnesses)
+        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;
     }
@@ -833,7 +867,8 @@ export class Transaction {
     }
     // Input stuff
     checkInputIdx(idx) {
-        if (!Number.isSafeInteger(idx) || 0 > idx || idx >= this.inputs.length)
+        anumber(idx, 'idx');
+        if (idx >= this.inputs.length)
             throw new Error(`Wrong input index=${idx}`);
     }
     getInput(idx) {
@@ -845,6 +880,7 @@ export class Transaction {
     }
     // Modification
     addInput(input, _ignoreSignStatus = false) {
+        validateObject(input, {}, {}, '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
@@ -866,7 +902,8 @@ export class Transaction {
     }
     // Output stuff
     checkOutputIdx(idx) {
-        if (!Number.isSafeInteger(idx) || 0 > idx || idx >= this.outputs.length)
+        anumber(idx, 'idx');
+        if (idx >= this.outputs.length)
             throw new Error(`Wrong output index=${idx}`);
     }
     getOutput(idx) {
@@ -883,11 +920,11 @@ export class Transaction {
         return this.outputs.length;
     }
     normalizeOutput(o, cur, allowedFields) {
+        validateObject(o, {}, {}, '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)
@@ -936,7 +973,7 @@ export class Transaction {
     }
     // Utils
     get fee() {
-        let res = 0n;
+        let res = _0n;
         for (const i of this.inputs) {
             const prevOut = getPrevOut(i);
             if (!prevOut)
@@ -957,7 +994,7 @@ export class Transaction {
         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 = this.inputs
             .map(inputBeforeSign)
@@ -994,7 +1031,8 @@ export class Transaction {
     preimageWitnessV0(idx, prevOutScript, hashType, amount) {
         // 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)
+        anumber(idx, 'idx');
+        if (idx >= this.inputs.length)
             throw new Error(`Invalid input idx=${idx}`);
         const { isAny, isNone, isSingle } = unpackSighash(hashType);
         let inputHash = EMPTY32;
@@ -1015,15 +1053,18 @@ export class Transaction {
         return u.sha256x2(P.I32LE.encode(this.version), inputHash, sequenceHash, P.bytes(32, true).encode(input.txid), P.U32LE.encode(input.index), VarBytes.encode(prevOutScript), P.U64LE.encode(amount), P.U32LE.encode(input.sequence), outputHash, P.U32LE.encode(this.lockTime), P.U32LE.encode(hashType));
     }
     preimageWitnessV1(idx, prevOutScript, hashType, amount, codeSeparator = -1, leafScript, leafVer = 0xc0, annex) {
-        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)
+        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 = [
             P.U8.encode(0),
             P.U8.encode(hashType), // U8 sigHash
@@ -1063,6 +1104,14 @@ export class Transaction {
     }
     // Signer can be privateKey OR instance of bip32 HD stuff
     signIdx(privateKey, idx, allowedSighash, _auxRand) {
+        if (!isBytes(privateKey)) {
+            // HDKey is a structural external instance, so plain-object validation would
+            // reject valid signers.
+            if (!privateKey ||
+                typeof privateKey !== 'object' ||
+                typeof privateKey.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(input, this.opts.allowLegacyWitnessUtxo);
@@ -1260,7 +1309,7 @@ export class Transaction {
     }
     finalizeIdx(idx) {
         this.checkInputIdx(idx);
-        if (this.fee < 0n)
+        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);
@@ -1440,11 +1489,13 @@ export class Transaction {
             throw new Error('Transaction has unfinalized inputs');
         if (!this.outputs.length)
             throw new Error('Transaction has no outputs');
-        if (this.fee < 0n)
+        if (this.fee < _0n)
             throw new Error('Outputs spends more than inputs amount');
         return this.toBytes(true, true);
     }
     combine(other) {
+        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);
@@ -1538,4 +1589,3 @@ export function bip32Path(path) {
     }
     return out;
 }
-//# sourceMappingURL=transaction.js.map

package/utils.d.ts

@@ -1,10 +1,40 @@
 import { sha256 as nobleSha256 } from '@noble/hashes/sha2.js';
 import { type TArg, type TRet } from '@noble/hashes/utils.js';
+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. */
 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 declare function abigint(n: unknown, title?: string): bigint;
+export declare function aarray<T>(item: unknown, title: string, inner?: (elm: T, title: string) => void): T[];
+/**
+ * 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 declare function astring(value: unknown, title?: string): string;
+export declare function validateObject(object: Record<string, any>, fields?: Record<string, string>, optFields?: Record<string, string>, _title?: string): void;
 /**
  * Checks whether a curve y-coordinate is even.
  * @param y - y-coordinate to inspect
@@ -280,4 +310,3 @@ export declare function reverseObject<T extends Record<string, string | number>>
 };
 /** Union of all value types in an object type. */
 export type ValueOf<T> = T[keyof T];
-//# sourceMappingURL=utils.d.ts.map

package/utils.js

@@ -4,10 +4,64 @@ import { ripemd160 } from '@noble/hashes/legacy.js';
 import { sha256 as nobleSha256 } from '@noble/hashes/sha2.js';
 import {} from '@noble/hashes/utils.js';
 import { utils as packedUtils, U32LE } from 'micro-packed';
+export { abytes, validateObject as vld } from '@noble/curves/utils.js';
 export {} from '@noble/hashes/utils.js';
+/**
+ * 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, title = 'value') {
+    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(item, title, inner = () => { }) {
+    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, title = '') {
+    if (typeof value !== 'string') {
+        const prefix = title && `"${title}" `;
+        throw new TypeError(prefix + 'expected string, got type=' + typeof value);
+    }
+    return value;
+}
+export function validateObject(object, fields = {}, optFields = {}, _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
@@ -18,7 +72,7 @@ const CURVE_ORDER = /* @__PURE__ */ (() => Point.Fn.ORDER)();
  * hasEven(2n);
  * ```
  */
-export const hasEven = (y) => y % 2n === 0n;
+export const hasEven = (y) => y % _2n === _0n;
 /**
  * Checks whether a value is a Uint8Array.
  * @param a - value to inspect
@@ -127,7 +181,10 @@ export const pubECDSA = (privateKey, isCompressed) => secp.getPublicKey(privateK
 // 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) => 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) => sig.r < LOW_R_BOUND;
 /**
  * Signs a 32-byte hash with ECDSA and returns DER encoding.
  * @param hash - message hash to sign
@@ -378,4 +435,3 @@ export function reverseObject(obj) {
     }
     return res;
 }
-//# sourceMappingURL=utils.js.map

package/utxo.d.ts

@@ -558,4 +558,3 @@ export declare function selectUTXO(inputs: TArg<psbt.TransactionInputUpdate[]>,
     tx: Transaction | undefined;
 }) | undefined;
 export {};
-//# sourceMappingURL=utxo.d.ts.map

package/utxo.js

@@ -2,10 +2,15 @@ import { hex } from '@scure/base';
 import * as P from 'micro-packed';
 import { Address, OutScript, checkScript, tapLeafHash } from "./payment.js";
 import * as psbt from "./psbt.js";
-import { CompactSizeLen, RawWitness, Script, VarBytes } from "./script.js";
+import { CompactSizeLen, Script } from "./script.js";
 import { SignatureHash, Transaction, getInputType, getPrevOut, inputBeforeSign, normalizeInput, toVsize, } from "./transaction.js";
-import { NETWORK, PubT, TAPROOT_UNSPENDABLE_KEY, compareBytes, equalBytes, isBytes, sha256, validatePubkey, } from "./utils.js";
+import { abigint, aarray, astring, NETWORK, PubT, TAPROOT_UNSPENDABLE_KEY, compareBytes, equalBytes, isBytes, sha256, validatePubkey, validateObject, } from "./utils.js";
 const encodeTapBlock = (item) => 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) => CompactSizeLen.encode(dataLen).length + dataLen;
 function iterLeafs(tapLeafScript, sigSize, customScripts) {
     const _tapLeafScript = tapLeafScript;
     const _customScripts = customScripts;
@@ -150,10 +155,12 @@ function estimateInput(inputType, input, opts) {
         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 };
@@ -163,13 +170,14 @@ export const _cmpBig = (a, b) => {
     // 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)
+    if (n < _0n)
         return -1;
-    else if (n > 0n)
+    else if (n > _0n)
         return 1;
     return 0;
 };
 function getScript(o, opts = {}, network = NETWORK) {
+    validateObject(o, {}, {}, 'output');
     const _o = o;
     const _opts = opts;
     let script;
@@ -177,20 +185,16 @@ function getScript(o, opts = {}, 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(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}, 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');
     }
@@ -215,12 +219,9 @@ export class _Estimator {
     constructor(inputs, outputs, opts) {
         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
@@ -233,37 +234,32 @@ 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(OutScript.encode(Address(network).decode(opts.changeAddress))).length;
+                varLen(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;
@@ -353,7 +349,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 = new Set();
         let fee;
@@ -401,7 +397,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)
+            if (skipNegative && value <= _0n)
                 continue;
             weight = newWeight;
             if (estimate.hasWitnesses)
@@ -415,6 +411,11 @@ 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,
@@ -492,7 +493,7 @@ export class _Estimator {
         if (needChange) {
             fee = changeFee;
             // this shouldn't happen!
-            if (change < 0n)
+            if (change < _0n)
                 throw new Error(`Estimator.result: negative change=${change}`);
             outputs.push({ address: this.opts.changeAddress, amount: change });
         }
@@ -550,9 +551,12 @@ export class _Estimator {
  * ```
  */
 export function selectUTXO(inputs, outputs, strategy, opts) {
+    aarray(inputs, 'inputs');
+    aarray(outputs, 'outputs');
+    validateObject(opts, {}, {}, 'opts');
+    astring(strategy, 'strategy');
     // Public wrapper defaults to BIP69 ordering and tx construction unless callers override them.
     const _opts = { createTx: true, bip69: true, ...opts };
     const est = new _Estimator(inputs, outputs, _opts);
     return est.result(strategy);
 }
-//# sourceMappingURL=utxo.js.map

package/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["src/index.ts"],"names":[],"mappings":"AAAA,0EAA0E;AAC1E,OAAO,KAAK,EAAE,IAAI,EAAE,IAAI,EAAE,MAAM,YAAY,CAAC;AAC7C,OAAO,EACL,YAAY,EAKZ,kBAAkB,EACnB,MAAM,YAAY,CAAC;AAGpB,OAAO,EACL,QAAQ,EACR,IAAI,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,IAAI,EAAE,OAAO,EAAE,OAAO,EAAE,OAAO,EAAE,MAAM,EAAE,KAAK,EACxE,MAAM,cAAc,CAAC;AACtB,OAAO,EACL,WAAW,EACX,sBAAsB,EACtB,EAAE,EACF,KAAK,EACL,UAAU,EACV,MAAM,EACN,SAAS,GACV,MAAM,aAAa,CAAC;AACrB,YAAY,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AAC9C,OAAO,EAAE,YAAY,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAC;AAC7D,OAAO,EAAE,OAAO,EAAE,uBAAuB,EAAE,YAAY,EAAE,MAAM,YAAY,CAAC;AAC5E,YAAY,EAAE,IAAI,EAAE,IAAI,EAAE,MAAM,YAAY,CAAC;AAC7C,OAAO,EAAE,UAAU,EAAE,MAAM,WAAW,CAAC;AAEvC;;;;;;;GAOG;AAEH,eAAO,MAAM,KAAK,EAAE,IAAI,CACtB,QAAQ,CAAC;IACP,OAAO,EAAE,CAAC,CAAC,EAAE,OAAO,KAAK,CAAC,IAAI,UAAU,CAAC;IACzC,WAAW,EAAE,CAAC,GAAG,MAAM,EAAE,IAAI,CAAC,UAAU,EAAE,CAAC,KAAK,IAAI,CAAC,UAAU,CAAC,CAAC;IACjE,YAAY,EAAE,OAAO,YAAY,CAAC;IAClC,UAAU,EAAE,CAAC,IAAI,EAAE,IAAI,CAAC,UAAU,CAAC,KAAK,IAAI,CAAC,UAAU,CAAC,CAAC;IACzD,qBAAqB,EAAE,MAAM,IAAI,CAAC,UAAU,CAAC,CAAC;IAC9C,kBAAkB,EAAE,OAAO,kBAAkB,CAAC;CAC/C,CAAC,CASG,CAAC;AAER,OAAO,EACL,YAAY,EACZ,OAAO,EACP,YAAY,EACZ,UAAU,EACV,SAAS,EACT,cAAc,EACd,iBAAiB,EACjB,GAAG,GACJ,MAAM,cAAc,CAAC;AAEtB,YAAY,EAAE,YAAY,EAAE,SAAS,EAAE,MAAM,cAAc,CAAC;AAE5D,OAAO,EAAE,UAAU,EAAE,mBAAmB,EAAE,MAAM,WAAW,CAAC;AAE5D,OAAO,EAAE,SAAS,EAAE,OAAO,EAAE,gBAAgB,EAAE,WAAW,EAAE,OAAO,EAAE,MAAM,kBAAkB,CAAC;AAC9F,OAAO,EAAE,OAAO,EAAE,UAAU,EAAE,MAAM,WAAW,CAAC"}

package/index.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["src/index.ts"],"names":[],"mappings":"AAEA,OAAO,EACL,YAAY,EACZ,WAAW,EACX,OAAO,EACP,UAAU,EACV,qBAAqB,EACrB,kBAAkB,GACnB,MAAM,YAAY,CAAC;AACpB,kDAAkD;AAClD,kBAAkB;AAClB,OAAO,EACL,QAAQ,EACR,IAAI,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,IAAI,EAAE,OAAO,EAAE,OAAO,EAAE,OAAO,EAAE,MAAM,EAAE,KAAK,EACxE,MAAM,cAAc,CAAC;AACtB,OAAO,EACL,WAAW,EACX,sBAAsB,EACtB,EAAE,EACF,KAAK,EACL,UAAU,EACV,MAAM,EACN,SAAS,GACV,MAAM,aAAa,CAAC;AAErB,OAAO,EAAE,YAAY,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAC;AAC7D,OAAO,EAAE,OAAO,EAAE,uBAAuB,EAAE,YAAY,EAAE,MAAM,YAAY,CAAC;AAE5E,OAAO,EAAE,UAAU,EAAE,MAAM,WAAW,CAAC;AAEvC;;;;;;;GAOG;AACH,sFAAsF;AACtF,MAAM,CAAC,MAAM,KAAK,GASd,eAAe,CAAC,CAAC,GAAG,EAAE,CACxB,MAAM,CAAC,MAAM,CAAC;IACZ,OAAO;IACP,WAAW;IACX,YAAY;IACZ,UAAU;IACV,qBAAqB;IACrB,kBAAkB;CACnB,CAAC,CAAC,EAAE,CAAC;AAER,OAAO,EACL,YAAY,EACZ,OAAO,EACP,YAAY,EACZ,UAAU,EACV,SAAS,EACT,cAAc,EACd,iBAAiB,EACjB,GAAG,GACJ,MAAM,cAAc,CAAC;AAGtB,SAAS;AACT,OAAO,EAAE,UAAU,EAAE,mBAAmB,EAAE,MAAM,WAAW,CAAC;AAC5D,SAAS;AACT,OAAO,EAAE,SAAS,EAAE,OAAO,EAAE,gBAAgB,EAAE,WAAW,EAAE,OAAO,EAAE,MAAM,kBAAkB,CAAC;AAC9F,OAAO,EAAE,OAAO,EAAE,UAAU,EAAE,MAAM,WAAW,CAAC"}

package/musig2.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"musig2.d.ts","sourceRoot":"","sources":["src/musig2.ts"],"names":[],"mappings":"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"}