@scure/btc-signer 2.2.0 → 2.4.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,43 @@
 {
   "name": "@scure/btc-signer",
-  "version": "2.2.0",
+  "version": "2.4.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.4.0",
+    "@noble/hashes": "2.4.0",
+    "@scure/base": "2.4.0",
+    "micro-packed": "0.11.0"
   },
   "devDependencies": {
-    "@paulmillr/jsbt": "0.5.0",
-    "@scure/bip32": "2.0.0",
-    "prettier": "3.6.2",
-    "typescript": "6.0.2"
+    "@paulmillr/jsbt": "0.7.1",
+    "bismar": "0.1.8",
+    "@scure/bip32": "2.4.0",
+    "micro-ftch": "1.2.0",
+    "prettier": "3.9.6",
+    "typescript": "6.0.3"
   },
   "scripts": {
+    "benchmark:size": "bismar -bsm",
     "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,8 @@ 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;
+export declare const _WitnessOutScript: OutScriptType;
+type AddressValue = NonNullable<ReturnType<OutScriptType['decode']>>;
 /**
  * Validates that nested redeem and witness scripts match their wrappers.
  * @param script - top-level output script
@@ -186,6 +187,7 @@ export type P2SHReturn<T extends P2Ret> = T extends {
  * Wraps a child script inside P2SH.
  * @param child - child payment descriptor to wrap
  * @param network - address network parameters
+ * @param allowNonCanonicalScript - whether to create an address for a non-minimal child script
  * @returns P2SH descriptor preserving witness metadata when present.
  * @throws If the wrapped script combination is invalid or unsupported. {@link Error}
  * @example
@@ -196,7 +198,7 @@ export type P2SHReturn<T extends P2Ret> = T extends {
  * p2sh(p2wsh(p2pk(hex.decode('0279be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798'))));
  * ```
  */
-export declare const p2sh: <T extends P2Ret>(child: TArg<T>, network?: BTC_NETWORK) => TRet<Extends<P2SHReturn<T>, P2Ret>>;
+export declare const p2sh: <T extends P2Ret>(child: TArg<T>, network?: BTC_NETWORK, allowNonCanonicalScript?: boolean) => TRet<Extends<P2SHReturn<T>, P2Ret>>;
 /** Pay-to-witness-script-hash descriptor. */
 export type P2WSH = {
     /** Payment-script tag for pay-to-witness-script-hash outputs. */
@@ -214,6 +216,7 @@ export type P2WSH = {
  * Wraps a child script inside native SegWit P2WSH.
  * @param child - child payment descriptor to wrap
  * @param network - address network parameters
+ * @param allowNonCanonicalScript - whether to create an address for a non-minimal child script
  * @returns P2WSH descriptor.
  * @throws If the wrapped script combination is invalid or unsupported. {@link Error}
  * @example
@@ -224,7 +227,7 @@ export type P2WSH = {
  * p2wsh(p2pk(hex.decode('0279be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798')));
  * ```
  */
-export declare const p2wsh: (child: TArg<P2Ret>, network?: BTC_NETWORK) => TRet<Extends<P2WSH, P2Ret>>;
+export declare const p2wsh: (child: TArg<P2Ret>, network?: BTC_NETWORK, allowNonCanonicalScript?: boolean) => TRet<Extends<P2WSH, P2Ret>>;
 /** Pay-to-witness-public-key-hash descriptor. */
 export type P2WPKH = {
     /** Payment-script tag for pay-to-witness-public-key-hash outputs. */
@@ -380,6 +383,7 @@ export type P2TRRet<T> = T extends TaprootScriptTree ? P2TR_TREE : P2TR;
  * @param customScripts - optional custom script codecs for taproot leaves
  * @returns Taproot descriptor with optional script-path metadata.
  * @throws If the internal key or taproot script tree is invalid. {@link Error}
+ * @throws If a numeric script value is outside its supported range. {@link RangeError}
  * @example
  * Combine script leaves into a final taproot output descriptor and address.
  * ```ts
@@ -393,23 +397,27 @@ export type P2TRRet<T> = T extends TaprootScriptTree ? P2TR_TREE : P2TR;
  */
 export declare function p2tr(internalPubKey: TArg<Bytes | string>, tree?: undefined, network?: BTC_NETWORK, allowUnknownOutputs?: boolean, customScripts?: TArg<CustomScript[]>): TRet<Extends<P2TR, P2Ret>>;
 export declare function p2tr(internalPubKey: TArg<Bytes | string | undefined>, tree: TArg<TaprootScriptTree>, network?: BTC_NETWORK, allowUnknownOutputs?: boolean, customScripts?: TArg<CustomScript[]>): TRet<Extends<P2TR_TREE, P2Ret>>;
+/** Maximum number of combinations materialized by one default helper call. */
+export declare const MAX_COMBINATIONS = 4096;
 /**
  * Returns all size-`m` combinations from a list.
  * @param m - size of each combination
  * @param list - input items to combine
+ * @param maxCombinations - maximum result rows to materialize
  * @returns Array of combinations.
  * @throws If the combination size or input list is invalid. {@link Error}
+ * @throws If the requested result exceeds the materialization limit. {@link RangeError}
  * @example
  * Enumerate all size-two subsets of a short list.
  * ```ts
  * combinations(2, [1, 2, 3]);
  * ```
  */
-export declare function combinations<T>(m: number, list: T[]): T[][];
+export declare function combinations<T>(m: number, list: T[], maxCombinations?: number): T[][];
 /**
  * M-of-N multi-leaf wallet via p2tr_ns. If m == n, single script is emitted.
- * Takes O(n^2) if m != n. 99-of-100 is ok, 5-of-100 is not.
- * It materializes C(n, m) leaves, so middle-of-the-range thresholds blow up combinatorially.
+ * It materializes C(n, m) leaves up to {@link MAX_COMBINATIONS}; middle-of-the-range thresholds
+ * above that bound are rejected before allocation.
  * `2-of-[A,B,C] => [A,B] | [A,C] | [B,C]`
  */
 export type P2TR_NS = {
@@ -425,6 +433,7 @@ export type P2TR_NS = {
  * @param allowSamePubkeys - whether duplicate keys are allowed
  * @returns Array of taproot leaf descriptors.
  * @throws If the taproot multisig parameters are invalid. {@link Error}
+ * @throws If the requested leaf set exceeds the materialization limit. {@link RangeError}
  * @example
  * Build the leaf set for an M-of-N taproot `CHECKSIGVERIFY` policy.
  * ```ts
@@ -443,6 +452,7 @@ export type P2TR_PK = P2TR_NS;
  * @param pubkey - Schnorr public key
  * @returns Taproot single-key leaf descriptor.
  * @throws If the taproot single-key leaf cannot be encoded. {@link Error}
+ * @throws If the delegated leaf policy exceeds its supported range. {@link RangeError}
  * @example
  * Build a single-key tapscript leaf.
  * ```ts
@@ -482,6 +492,7 @@ export declare function p2tr_ms(m: number, pubkeys: TArg<Bytes[]>, allowSamePubk
  * @param network - address network parameters
  * @returns Encoded Bitcoin address.
  * @throws If the requested address type is unknown. {@link Error}
+ * @throws If a key-derived script value is outside its supported range. {@link RangeError}
  * @example
  * Pick the output type first, then derive the matching address from the private key.
  * ```ts
@@ -561,9 +572,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