@scure/btc-signer 2.2.0 → 2.3.0

package/p2p.d.ts

@@ -44,4 +44,3 @@ export declare const elligatorSwift: Readonly<{
     getSharedSecret: (privateKeyA: TArg<Uint8Array>, publicKeyB: TArg<Uint8Array>) => TRet<Bytes>;
     getSharedSecretBip324: (privateKeyOurs: TArg<Uint8Array>, publicKeyTheirs: TArg<Uint8Array>, publicKeyOurs: TArg<Uint8Array>, initiating: boolean) => TRet<Uint8Array>;
 }>;
-//# sourceMappingURL=p2p.d.ts.map

package/p2p.js

@@ -39,6 +39,9 @@ const MINUS_3_SQRT = Fp.sqrt(Fp.create(BigInt(-3)));
 const _3n = BigInt(3);
 const _4n = BigInt(4);
 const _7n = BigInt(7);
+// Precomputed 1/2 mod p: turns the frequent "divide by 2" steps of XSwiftEC/XSwiftECInv
+// into single multiplications instead of one modular inversion per call.
+const INV_2 = Fp.inv(Fp.create(_2n));
 // This is the "lift_x(x) succeeds" predicate for field-normalized x values.
 // Raw x >= p would need the full BIP340 range check before reducing modulo p.
 const isValidX = (x) => FpIsSquare(Fp, Fp.add(Fp.mul(Fp.mul(x, x), x), _7n));
@@ -93,7 +96,7 @@ export const elligatorSwift = /* @__PURE__ */ Object.freeze({
                 return; // [2 condition]
             if (ellCase & 1 && Fp.is0(r))
                 return;
-            v = Fp.div(Fp.add(Fp.neg(u), Fp.div(r, s)), _2n); // v = (-u + r / s) / 2
+            v = Fp.mul(Fp.add(Fp.neg(u), Fp.div(r, s)), INV_2); // v = (-u + r / s) / 2
         }
         const w = trySqrt(s);
         if (w === undefined)
@@ -102,7 +105,7 @@ export const elligatorSwift = /* @__PURE__ */ Object.freeze({
         const t0 = last & 1 ? Fp.add(_1n, MINUS_3_SQRT) : Fp.sub(_1n, MINUS_3_SQRT);
         const w0 = last === 0 || last === 5 ? Fp.neg(w) : w; // -w | w
         // w0 * (u * t0 / 2 + v)
-        return Fp.mul(w0, Fp.add(Fp.div(Fp.mul(u, t0), _2n), v));
+        return Fp.mul(w0, Fp.add(Fp.mul(Fp.mul(u, t0), INV_2), v));
     },
     // Encode public key (point or x coordinate bigint) into 64-byte pseudorandom encoding
     // BIP324 samples encodings for x(P), so callers must pass a curve X coordinate in 0..p-1;
@@ -112,11 +115,19 @@ export const elligatorSwift = /* @__PURE__ */ Object.freeze({
         // so encode() must reject out-of-range x instead of silently reducing a different bigint modulo p.
         if (!Fp.isValid(x))
             throw new RangeError('elligatorSwift.encode: expected x coordinate in range 0..p-1');
+        // Off-curve x cannot round-trip: decode() only returns lift_x-able candidates, so
+        // the loop below would silently emit an encoding of a *different* public key.
+        if (!isValidX(x))
+            throw new RangeError('elligatorSwift.encode: expected x coordinate of a curve point');
         // 200k test cycles per keygen: avg=4 max=48
         // seems too much, but same as for reference implementation
         while (true) {
-            // random scalar 1..Fp.ORDER
-            const u = Fp.create(Fp.fromBytes(secp256k1.utils.randomSecretKey()));
+            // Random field element 1..p-1: BIP324 samples u over the whole field (the previous
+            // secret-key sampler silently restricted u to 1..n-1); decode() remaps u = 0, so
+            // zero cannot round-trip and is skipped.
+            const u = Fp.create(Fp.fromBytes(randomBytes(32), true));
+            if (Fp.is0(u))
+                continue;
             const ellCase = randomBytes(1)[0] & 7; // [0..8)
             const t = elligatorSwift._inv(x, u, ellCase);
             if (!t)
@@ -148,10 +159,12 @@ export const elligatorSwift = /* @__PURE__ */ Object.freeze({
         let res = Fp.add(u, Fp.mul(Fp.mul(y, y), _4n)); // u + 4 * Y ** 2,
         if (isValidX(res))
             return Fp.toBytes(res);
-        res = Fp.div(Fp.sub(Fp.div(Fp.neg(x), y), u), _2n); // (-X / Y - u) / 2
+        // X / Y is shared by the remaining candidates; computing it once saves an inversion.
+        const xDivY = Fp.div(x, y);
+        res = Fp.mul(Fp.sub(Fp.neg(xDivY), u), INV_2); // (-X / Y - u) / 2
         if (isValidX(res))
             return Fp.toBytes(res);
-        res = Fp.div(Fp.sub(Fp.div(x, y), u), _2n); // (X / Y - u) / 2
+        res = Fp.mul(Fp.sub(xDivY, u), INV_2); // (X / Y - u) / 2
         if (isValidX(res))
             return Fp.toBytes(res);
         throw new Error('elligatorSwift: cannot decode public key');
@@ -178,6 +191,10 @@ export const elligatorSwift = /* @__PURE__ */ Object.freeze({
     getSharedSecretBip324: (privateKeyOurs, publicKeyTheirs, publicKeyOurs, initiating) => {
         // BIP324 Shared secret computation hashes "the exactly 64-byte public keys'
         // encodings sent over the wire", so both ElligatorSwift inputs must be 64 bytes here.
+        // Initiator/responder ordering decides the hash-input order, so require a real boolean
+        // instead of letting arbitrary truthy values pick a side.
+        if (typeof initiating !== 'boolean')
+            throw new TypeError('"initiating" expected boolean, got type=' + typeof initiating);
         const ours = abytes(publicKeyOurs, 64, 'publicKeyOurs');
         const theirs = abytes(publicKeyTheirs, 64, 'publicKeyTheirs');
         const ecdhPoint = elligatorSwift.getSharedSecret(privateKeyOurs, theirs);
@@ -185,4 +202,3 @@ export const elligatorSwift = /* @__PURE__ */ Object.freeze({
         return tagSchnorr('bip324_ellswift_xonly_ecdh', ...pubs, ecdhPoint);
     },
 });
-//# sourceMappingURL=p2p.js.map

package/package.json

@@ -1,46 +1,42 @@
 {
   "name": "@scure/btc-signer",
-  "version": "2.2.0",
+  "version": "2.3.0",
   "description": "Audited & minimal library for Bitcoin. Handle transactions, Schnorr, Taproot, UTXO & PSBT",
   "files": [
     "*.js",
     "*.d.ts",
-    "*.js.map",
-    "*.d.ts.map",
     "src",
     "!_type_test.*"
   ],
   "dependencies": {
-    "@noble/curves": "~2.2.0",
-    "@noble/hashes": "~2.2.0",
-    "@scure/base": "~2.2.0",
-    "micro-packed": "~0.9.0"
+    "@noble/curves": "~2.3.0",
+    "@noble/hashes": "~2.3.0",
+    "@scure/base": "~2.3.0",
+    "micro-packed": "~0.11.0"
   },
   "devDependencies": {
-    "@paulmillr/jsbt": "0.5.0",
-    "@scure/bip32": "2.0.0",
+    "@paulmillr/jsbt": "0.6.5",
+    "@scure/bip32": "2.2.0",
+    "micro-ftch": "^1.1.0",
     "prettier": "3.6.2",
     "typescript": "6.0.2"
   },
   "scripts": {
+    "benchmark:size": "npx bismar@0.1.3 -s",
     "build": "tsc",
-    "build:clean": "rm -f *.{js,d.ts,js.map,d.ts.map}",
-    "build:release": "npx --no @paulmillr/jsbt esbuild test/build",
-    "check": "npx --no @paulmillr/jsbt check package.json",
-    "check:readme": "npx --no @paulmillr/jsbt readme package.json",
-    "check:treeshake": "npx --no @paulmillr/jsbt treeshake package.json test/build/out-treeshake",
-    "check:jsdoc": "npx --no @paulmillr/jsbt tsdoc package.json",
+    "build:clean": "rm -f *.{js,d.ts}",
+    "check": "jsbt-check",
+    "benchmark": "node benchmark/index.ts",
+    "benchmark:network": "node benchmark/network.ts",
     "format": "prettier --write src test/*.test.*",
-    "test": "node --no-warnings test/index.ts",
-    "test:bun": "bun test/index.ts",
-    "test:deno": "deno --allow-env --allow-read test/index.ts",
-    "test:node20": "cd test; npx tsc; node compiled/test/index.js",
+    "test": "node test/index.ts",
     "test:slow": "node test/slow.test.ts",
     "test:extended": "node --experimental-loader ./test/bitcoinjs-test/esm-loader.js ./test/bitcoinjs-test/index.test.js"
   },
   "exports": {
     ".": "./index.js",
     "./musig2.js": "./musig2.js",
+    "./net.js": "./net.js",
     "./p2p.js": "./p2p.js",
     "./payment.js": "./payment.js",
     "./psbt.js": "./psbt.js",

package/payment.d.ts

@@ -91,7 +91,7 @@ export type CustomScript = Coder<OptScript, CustomScriptOut | undefined> & {
 export declare const OutScript: TRet<P.CoderType<NonNullable<OutP2AType | OutPKType | OutPKHType | OutSHType | OutWSHType | OutWPKHType | OutMSType | OutTRType | OutTRNSType | OutTRMSType | OutUnknownType | undefined>>>;
 /** Type of the output-script coder. */
 export type OutScriptType = typeof OutScript;
-type OutScriptValue = ReturnType<OutScriptType['decode']> | undefined;
+type AddressValue = NonNullable<ReturnType<OutScriptType['decode']>>;
 /**
  * Validates that nested redeem and witness scripts match their wrappers.
  * @param script - top-level output script
@@ -561,9 +561,5 @@ export declare function WIF(network?: BTC_NETWORK): TRet<Coder<Bytes, string>>;
  * coder.encode(p2wpkh(pubECDSA(randomPrivateKeyBytes())));
  * ```
  */
-export declare function Address(network?: BTC_NETWORK): {
-    encode(from: Exclude<OutScriptValue, undefined>): string;
-    decode(address: string): OutScriptValue;
-};
+export declare function Address(network?: BTC_NETWORK): TRet<P.Coder<AddressValue, string>>;
 export {};
-//# sourceMappingURL=payment.d.ts.map

package/payment.js

@@ -6,10 +6,16 @@ import { TaprootControlBlock } from "./psbt.js";
 import { MAX_SCRIPT_BYTE_LENGTH, OpToNum, Script, VarBytes } from "./script.js";
 import * as u from "./utils.js";
 import { NETWORK } from "./utils.js";
+// Pay to Anchor (P2A)
+// BIP433 Pay-to-Anchor witness program bytes; the scriptPubKey is `OP_1 <0x4e73>`.
+const P2A_PROGRAM = /* @__PURE__ */ Uint8Array.from([0x4e, 0x73]);
 const OutP2A = {
     encode(from) {
         // BIP433 defines P2A as the exact OP_1 <0x4e73> scriptPubKey.
-        if (from.length !== 2 || from[0] !== 1 || !u.isBytes(from[1]) || hex.encode(from[1]) !== '4e73')
+        if (from.length !== 2 ||
+            from[0] !== 1 ||
+            !u.isBytes(from[1]) ||
+            !u.equalBytes(from[1], P2A_PROGRAM))
             return;
         return { type: 'p2a', script: Script.encode(from) };
     },
@@ -18,7 +24,7 @@ const OutP2A = {
             return;
         // The decoded object keeps `script` for caller convenience, but the `p2a`
         // tag always canonicalizes back to the fixed BIP433 script.
-        return [1, hex.decode('4e73')];
+        return [1, Uint8Array.from(P2A_PROGRAM)];
     },
 };
 function isValidPubkey(pub, type) {
@@ -54,8 +60,10 @@ const OutPKH = {
     encode(from) {
         if (from.length !== 5 || from[0] !== 'DUP' || from[1] !== 'HASH160' || !u.isBytes(from[2]))
             return;
-        // OutScript validates that the pushed HASH160 is exactly 20 bytes.
-        // This child matcher only recognizes the canonical P2PKH opcode skeleton.
+        // Require the exact 20-byte HASH160 here so near-miss scripts fall through
+        // to OutUnknown instead of throwing in the OutScript validator on decode.
+        if (from[2].length !== 20)
+            return;
         if (from[3] !== 'EQUALVERIFY' || from[4] !== 'CHECKSIG')
             return;
         return { type: 'pkh', hash: from[2] };
@@ -70,8 +78,10 @@ const OutSH = {
     encode(from) {
         if (from.length !== 3 || from[0] !== 'HASH160' || !u.isBytes(from[1]) || from[2] !== 'EQUAL')
             return;
-        // OutScript validates that the pushed HASH160 is exactly 20 bytes.
-        // This child matcher only recognizes the canonical P2SH opcode skeleton.
+        // Require the exact 20-byte HASH160 here so near-miss scripts fall through
+        // to OutUnknown instead of throwing in the OutScript validator on decode.
+        if (from[1].length !== 20)
+            return;
         return { type: 'sh', hash: from[1] };
     },
     // OutScript validates `sh.hash` before this branch emits the canonical
@@ -119,11 +129,15 @@ const OutMS = {
         const pubkeys = from.slice(1, -2);
         if (n !== pubkeys.length)
             return;
+        // Require valid ECDSA pubkeys and `0 < m <= n` here so near-miss
+        // CHECKMULTISIG scripts (garbage keys, degenerate 0-of-0) fall through to
+        // OutUnknown instead of throwing in the OutScript validator on decode.
+        // Script.decode only yields 0..16 for opcode numbers, so n <= 16 holds.
         for (const pub of pubkeys)
-            if (!u.isBytes(pub))
+            if (!u.isBytes(pub) || !isValidPubkey(pub, u.PubT.ecdsa))
                 return;
-        // OutScript validates pubkey encodings and `0 < m <= n <= 16`.
-        // This child matcher only recognizes the canonical CHECKMULTISIG skeleton.
+        if (!Number.isSafeInteger(m) || m < 1 || m > n)
+            return;
         // We don't need n here because it is the same as pubkeys.length.
         return { type: 'ms', m, pubkeys: pubkeys };
     },
@@ -143,6 +157,11 @@ const OutTR = {
         // other OP_1 program lengths remain reserved future witness programs and should fall through.
         if (from.length !== 2 || from[0] !== 1 || !u.isBytes(from[1]) || from[1].length !== 32)
             return;
+        // A 32-byte v1 program with an off-curve x coordinate is a fundable but
+        // taproot-unspendable output; classify it as unknown instead of throwing
+        // in the OutScript validator on decode.
+        if (!isValidPubkey(from[1], u.PubT.schnorr))
+            return;
         return { type: 'tr', pubkey: from[1] };
     },
     // OutScript validates `tr.pubkey` before this branch emits the canonical
@@ -206,10 +225,15 @@ const OutTRMS = {
                     return;
                 continue;
             }
-            if (!u.isBytes(elm))
+            // Require actual Schnorr pubkeys here (same as tr_ns) so near-miss
+            // CHECKSIGADD scripts fall through to OutUnknown instead of throwing
+            // in the OutScript validator on decode.
+            if (!u.isBytes(elm) || !isValidPubkey(elm, u.PubT.schnorr))
                 return;
             pubkeys.push(elm);
         }
+        if (!Number.isSafeInteger(m) || m < 1 || m > pubkeys.length || pubkeys.length > 999)
+            return;
         return { type: 'tr_ms', pubkeys, m };
     },
     decode: (to) => {
@@ -457,6 +481,7 @@ export const p2pkh = (publicKey, network = NETWORK) => {
  * ```
  */
 export const p2sh = (child, network = NETWORK) => {
+    u.validateObject(child, {}, {}, 'child');
     // It is already tested inside noble-hashes and checkScript
     // BIP16 redeemScripts are pushed by scriptSig, so anything over the 520-byte pushed-element
     // limit would be fundable by HASH160 but unspendable once wrapped in P2SH.
@@ -506,6 +531,7 @@ export const p2sh = (child, network = NETWORK) => {
  * ```
  */
 export const p2wsh = (child, network = NETWORK) => {
+    u.validateObject(child, {}, {}, 'child');
     const cs = child.script;
     if (!u.isBytes(cs))
         throw new Error(`Wrong script: ${typeof cs}, expected Uint8Array`);
@@ -584,9 +610,17 @@ function checkTaprootScript(script, internalPubKey, allowUnknownOutputs = false,
         // disable custom. All custom scripts for taproot should have prefix 'tr_'
         if (customScripts) {
             const cs = P.apply(Script, P.coders.match(customScripts));
-            const c = cs.decode(script);
+            let c;
+            // match() throws when no custom coder matches; treat that as "not a custom
+            // script" so the allowUnknownOutputs escape below stays reachable.
+            try {
+                c = cs.decode(script);
+            }
+            catch (e) {
+                c = undefined;
+            }
             if (c !== undefined) {
-                if (typeof c.type !== 'string' || !c.type.startsWith('tr_'))
+                if (!u.astring(c.type, 'c.type').startsWith('tr_'))
                     throw new Error(`P2TR: invalid custom type=${c.type}`);
                 return;
             }
@@ -632,6 +666,15 @@ function checkTaprootScript(script, internalPubKey, allowUnknownOutputs = false,
  * ```
  */
 export function taprootListToTree(taprootList) {
+    u.aarray(taprootList, 'taprootList', (leaf, title) => {
+        // p2tr reduces non-binary trees through this helper, so nested branch arrays are valid here.
+        if (Array.isArray(leaf))
+            return;
+        u.validateObject(leaf, {}, {}, title);
+        // This helper only arranges weighted tree nodes; p2tr validates leaf scripts while hashing.
+        if (leaf.weight !== undefined)
+            anumber(leaf.weight, title + '.weight');
+    });
     // Empty flat lists cannot represent a taproot script tree; omit the tree entirely for
     // key-path-only outputs instead of passing [] here, otherwise this helper would return
     // undefined and downstream taproot tree walkers would fail much later on a non-tree value.
@@ -684,20 +727,23 @@ function taprootWalkTree(tree) {
     return [...taprootWalkTree(tree.left), ...taprootWalkTree(tree.right)];
 }
 function taprootHashTree(tree, internalPubKey, allowUnknownOutputs = false, customScripts) {
-    if (!tree)
+    if (tree === undefined)
         throw new Error('taprootHashTree: empty tree');
+    if (!Array.isArray(tree) && !P.utils.isPlainObject(tree))
+        throw new TypeError('"tree" expected object or array, got type=' + typeof tree);
     if (Array.isArray(tree) && tree.length === 1)
         tree = tree[0];
     // Terminal node (leaf)
     if (!Array.isArray(tree)) {
+        u.validateObject(tree, {}, {}, 'tree');
         const version = tree.leafVersion;
         const { script: leafScript } = tree;
         // Earliest tree walk where we can validate tapScripts
         if (tree.tapLeafScript || (tree.tapMerkleRoot && !u.equalBytes(tree.tapMerkleRoot, P.EMPTY)))
             throw new Error('P2TR: tapRoot leafScript cannot have tree');
-        const script = typeof leafScript === 'string' ? hex.decode(leafScript) : leafScript;
-        if (!u.isBytes(script))
-            throw new Error(`checkScript: wrong script type=${script}`);
+        const script = typeof leafScript === 'string'
+            ? hex.decode(leafScript)
+            : abytes(leafScript, undefined, 'tree.script');
         checkTaprootScript(script, internalPubKey, allowUnknownOutputs, customScripts);
         return {
             type: 'leaf',
@@ -766,18 +812,20 @@ export function p2tr(internalPubKey, tree, network = NETWORK, allowUnknownOutput
         let hashedTree = taprootAddPath(taprootHashTree(tree, pubKey, allowUnknownOutputs, customScripts));
         const tapMerkleRoot = hashedTree.hash;
         const [tweakedPubkey, parity] = u.taprootTweakPubkey(pubKey, tapMerkleRoot);
+        const tapLeafScript = [];
         const leaves = taprootWalkTree(hashedTree).map((l) => {
             const version = tapLeafVersion(l.version);
-            return {
-                ...l,
-                // Leaf versions are stored as the base even byte; only the control block adds the
-                // output-key parity bit required by BIP 341 script-path spending.
-                controlBlock: TaprootControlBlock.encode({
-                    version: version + parity,
-                    internalKey: pubKey,
-                    merklePath: l.path,
-                }),
+            // Leaf versions are stored as the base even byte; only the control block adds the
+            // output-key parity bit required by BIP 341 script-path spending.
+            const controlBlock = {
+                version: version + parity,
+                internalKey: pubKey,
+                merklePath: l.path,
             };
+            // Skip an encode/decode copy for performance; callers must treat returned metadata as
+            // immutable.
+            tapLeafScript.push([controlBlock, u.concatBytes(l.script, new Uint8Array([version]))]);
+            return { ...l, controlBlock: TaprootControlBlock.encode(controlBlock) };
         });
         return {
             type: 'tr',
@@ -788,10 +836,7 @@ export function p2tr(internalPubKey, tree, network = NETWORK, allowUnknownOutput
             // PSBT stuff
             tapInternalKey: pubKey,
             leaves,
-            tapLeafScript: leaves.map((l) => [
-                TaprootControlBlock.decode(l.controlBlock),
-                u.concatBytes(l.script, new Uint8Array([tapLeafVersion(l.version)])),
-            ]),
+            tapLeafScript,
             tapMerkleRoot,
         };
     }
@@ -938,6 +983,7 @@ export function p2tr_ms(m, pubkeys, allowSamePubkeys = false) {
  * ```
  */
 export function getAddress(type, privKey, network = NETWORK) {
+    u.astring(type, 'type');
     if (type === 'tr') {
         return p2tr(u.pubSchnorr(privKey), undefined, network).address;
     }
@@ -1076,15 +1122,21 @@ export function WIF(network = NETWORK) {
  * ```
  */
 export function Address(network = NETWORK) {
+    u.validateObject(network, {}, {}, 'network');
     return {
         encode(from) {
+            u.validateObject(from, {}, {}, 'from');
             const { type } = from;
+            u.astring(type, 'from.type');
             if (type === 'wpkh')
                 return programToWitness(0, from.hash, network);
             else if (type === 'wsh')
                 return programToWitness(0, from.hash, network);
             else if (type === 'tr')
                 return programToWitness(1, from.pubkey, network);
+            // BIP433 P2A is the fixed v1 witness program 0x4e73 ('bc1pfeessrawgf').
+            else if (type === 'p2a')
+                return programToWitness(1, P2A_PROGRAM, network);
             else if (type === 'pkh')
                 return formatKey(from.hash, [network.pubKeyHash]);
             else if (type === 'sh')
@@ -1092,6 +1144,7 @@ export function Address(network = NETWORK) {
             throw new Error(`Unknown address type=${type}`);
         },
         decode(address) {
+            u.astring(address, 'address');
             if (address.length < 14 || address.length > 74)
                 throw new Error('Invalid address length');
             // Bech32
@@ -1119,8 +1172,10 @@ export function Address(network = NETWORK) {
                     return { type: 'wpkh', hash: data };
                 else if (version === 1 && data.length === 32)
                     return { type: 'tr', pubkey: data };
+                else if (version === 1 && u.equalBytes(data, P2A_PROGRAM))
+                    return { type: 'p2a', script: Script.encode([1, data]) };
                 // Future witness versions can still be valid addresses, but this helper
-                // only returns typed descriptors for recognized v0 and taproot templates.
+                // only returns typed descriptors for recognized v0, taproot and P2A templates.
                 else
                     throw new Error('Unknown witness program');
             }
@@ -1141,4 +1196,3 @@ export function Address(network = NETWORK) {
         },
     };
 }
-//# sourceMappingURL=payment.js.map

package/psbt.d.ts

@@ -3216,4 +3216,3 @@ export declare const RawPSBTV2: Readonly<P.CoderType<P.StructInput<{
     })[];
 }>>>;
 export {};
-//# sourceMappingURL=psbt.d.ts.map

package/psbt.js

@@ -1,8 +1,12 @@
 import { hex } from '@scure/base';
+import { anumber } from '@noble/hashes/utils.js';
 import * as P from 'micro-packed';
 import { CompactSize, CompactSizeLen, RawOldTx, RawOutput, RawTx, RawWitness, VarBytes, } from "./script.js";
-import { compareBytes, equalBytes, PubT, validatePubkey, } from "./utils.js";
+import { aarray, compareBytes, equalBytes, PubT, validateObject, validatePubkey, } from "./utils.js";
 // PSBT BIP174, BIP370, BIP371
+// Be friendly to bad ECMAScript parsers by not using bigint literals.
+// prettier-ignore
+const _0n = /* @__PURE__ */ BigInt(0), _1n = /* @__PURE__ */ BigInt(1);
 // BIP174 keydata only says "public key", so legacy PSBT ECDSA fields still accept both
 // compressed (33-byte) and uncompressed (65-byte) SEC1 encodings, but not x-only keys.
 const PubKeyECDSA = /* @__PURE__ */ (() => P.validate(P.bytes(null), (pub) => validatePubkey(pub, PubT.ecdsa)))();
@@ -121,10 +125,10 @@ const tapTree = /* @__PURE__ */ (() => P.validate(P.array(null, P.struct({
             next.push(0);
         path = next;
     }
-    let leaves = 0n;
+    let leaves = _0n;
     for (let i = 0; i < tree.length; i++)
-        leaves += 1n << BigInt(maxDepth - tree[i].depth);
-    if (leaves !== 1n << BigInt(maxDepth))
+        leaves += _1n << BigInt(maxDepth - tree[i].depth);
+    if (leaves !== _1n << BigInt(maxDepth))
         throw new Error('tapTree: tuples must describe a complete binary tree');
     return tree;
 }))();
@@ -486,7 +490,7 @@ export const PSBTOutputCoder = /* @__PURE__ */ (() => Object.freeze(P.validate(P
     // in the field coder itself because BIP371 constrains the tuple value, not just the row shape.
     // BIP174/BIP370 define PSBT_OUT_AMOUNT as a signed int64 transport field, but it still
     // represents the transaction output amount in satoshis, so negative output values are invalid.
-    if (o.amount !== undefined && o.amount < 0n)
+    if (o.amount !== undefined && o.amount < _0n)
         throw new Error(`validateOutput: wrong amount=${o.amount}`);
     if (o.bip32Derivation)
         for (const [k] of o.bip32Derivation)
@@ -574,6 +578,9 @@ function validatePSBTFields(version, info, lst) {
  * ```
  */
 export function cleanPSBTFields(version, info, lst) {
+    anumber(version, 'version');
+    validateObject(info, {}, {}, 'info');
+    validateObject(lst, {}, {}, 'lst');
     const _lst = lst;
     const out = {};
     for (const _k in _lst) {
@@ -647,6 +654,12 @@ function validatePSBT(tx) {
  * ```
  */
 export function mergeKeyMap(psbtEnum, val, cur, allowedFields, allowUnknown) {
+    validateObject(psbtEnum, {}, {}, 'psbtEnum');
+    validateObject(val, {}, {}, 'val');
+    if (cur !== undefined)
+        validateObject(cur, {}, {}, 'cur');
+    if (allowedFields !== undefined)
+        aarray(allowedFields, 'allowedFields');
     const _val = val;
     const _cur = cur;
     const _allowedFields = allowedFields;
@@ -750,4 +763,3 @@ export const RawPSBTV0 = /* @__PURE__ */ (() => Object.freeze(P.validate(_RawPSB
 // This wrapper only layers `validatePSBT`'s PSBTv2 required-field/count reconciliation on top
 // of `_RawPSBTV2`; nested input/output/global field invariants still depend on the coders below.
 export const RawPSBTV2 = /* @__PURE__ */ (() => Object.freeze(P.validate(_RawPSBTV2, validatePSBT)))();
-//# sourceMappingURL=psbt.js.map

package/script.d.ts

@@ -1,5 +1,5 @@
 import * as P from 'micro-packed';
-import { type ValueOf, type Bytes, type TArg, type TRet } from './utils.ts';
+import { type Bytes, type TArg, type TRet, type ValueOf } from './utils.ts';
 /**
  * Maximum byte size allowed for a single pushed script element.
  * BIP 342 keeps this 520-byte stack-element limit even though tapscript removes
@@ -351,4 +351,3 @@ export declare const RawOldTx: Readonly<P.CoderType<P.StructInput<{
     lockTime: number;
 }>>>;
 export {};
-//# sourceMappingURL=script.d.ts.map