@btc-vision/bitcoin 7.0.0-alpha.1 → 7.0.0-alpha.2

package/build/workers/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/workers/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8CG;AAEH,eAAe;AACf,OAAO,EACH,aAAa,EAeb,cAAc,EACd,eAAe,EACf,aAAa,EACb,aAAa,EAMb,WAAW,GAEd,MAAM,YAAY,CAAC;AAEpB,sBAAsB;AACtB,OAAO,EAAE,iBAAiB,EAAE,cAAc,EAAE,MAAM,wBAAwB,CAAC;AAE3E,sDAAsD;AACtD,OAAO,EAAE,kBAAkB,EAAE,mBAAmB,EAAE,mBAAmB,EAAE,MAAM,qBAAqB,CAAC;AAEnG,+CAA+C;AAC/C,OAAO,EAAE,UAAU,EAAE,eAAe,EAAE,MAAM,iBAAiB,CAAC;AAE9D,kEAAkE;AAClE,OAAO,EAA6B,MAAM,6BAA6B,CAAC;AAExE,oCAAoC;AACpC,OAAO,EACH,gBAAgB,EAChB,mBAAmB,EACnB,qBAAqB,GAGxB,MAAM,oBAAoB,CAAC;AAE5B;;;;GAIG;AACH,MAAM,UAAU,aAAa;IACzB,IAAI,OAAO,OAAO,KAAK,WAAW,IAAI,OAAO,CAAC,QAAQ,EAAE,IAAI,EAAE,CAAC;QAC3D,OAAO,MAAM,CAAC;IAClB,CAAC;IACD,IAAI,OAAO,MAAM,KAAK,WAAW,IAAI,OAAO,MAAM,KAAK,WAAW,EAAE,CAAC;QACjE,OAAO,SAAS,CAAC;IACrB,CAAC;IACD,OAAO,SAAS,CAAC;AACrB,CAAC;AAED;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,MAAM,CAAC,KAAK,UAAU,iBAAiB,CAAC,MAA8C;IAalF,MAAM,OAAO,GAAG,aAAa,EAAE,CAAC;IAEhC,IAAI,OAAO,KAAK,MAAM,EAAE,CAAC;QACrB,qDAAqD;QACrD,MAAM,EAAE,qBAAqB,EAAE,GAAG,MAAM,MAAM,CAAC,6BAA6B,CAAC,CAAC;QAC9E,MAAM,IAAI,GAAG,qBAAqB,CAAC,WAAW,CAAC,MAAM,CAAC,CAAC;QACvD,MAAM,IAAI,CAAC,UAAU,EAAE,CAAC;QACxB,OAAO,IAAI,CAAC;IAChB,CAAC;SAAM,IAAI,OAAO,KAAK,SAAS,EAAE,CAAC;QAC/B,MAAM,EAAE,iBAAiB,EAAE,GAAG,MAAM,MAAM,CAAC,wBAAwB,CAAC,CAAC;QACrE,MAAM,IAAI,GAAG,iBAAiB,CAAC,WAAW,CAAC,MAAM,CAAC,CAAC;QACnD,MAAM,IAAI,CAAC,UAAU,EAAE,CAAC;QACxB,OAAO,IAAI,CAAC;IAChB,CAAC;SAAM,CAAC;QACJ,MAAM,IAAI,KAAK,CAAC,6CAA6C,CAAC,CAAC;IACnE,CAAC;AACL,CAAC"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/workers/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8CG;AAIH,eAAe;AACf,OAAO,EACH,aAAa,EAeb,cAAc,EACd,eAAe,EACf,aAAa,EACb,aAAa,EAMb,WAAW,GAEd,MAAM,YAAY,CAAC;AAEpB,sBAAsB;AACtB,OAAO,EAAE,iBAAiB,EAAE,cAAc,EAAE,MAAM,wBAAwB,CAAC;AAE3E,sDAAsD;AACtD,OAAO,EAAE,kBAAkB,EAAE,mBAAmB,EAAE,mBAAmB,EAAE,MAAM,qBAAqB,CAAC;AAEnG,+CAA+C;AAC/C,OAAO,EAAE,UAAU,EAAE,eAAe,EAAE,MAAM,iBAAiB,CAAC;AAE9D,oCAAoC;AACpC,OAAO,EACH,gBAAgB,EAChB,mBAAmB,EACnB,qBAAqB,GAGxB,MAAM,oBAAoB,CAAC;AAE5B;;;;GAIG;AACH,MAAM,UAAU,aAAa;IACzB,IAAI,OAAO,OAAO,KAAK,WAAW,IAAI,OAAO,CAAC,QAAQ,EAAE,IAAI,EAAE,CAAC;QAC3D,OAAO,MAAM,CAAC;IAClB,CAAC;IACD,IAAI,OAAO,MAAM,KAAK,WAAW,IAAI,OAAO,MAAM,KAAK,WAAW,EAAE,CAAC;QACjE,OAAO,SAAS,CAAC;IACrB,CAAC;IACD,OAAO,SAAS,CAAC;AACrB,CAAC;AAED;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,MAAM,CAAC,KAAK,UAAU,iBAAiB,CAAC,MAAyB;IAa7D,MAAM,OAAO,GAAG,aAAa,EAAE,CAAC;IAEhC,IAAI,OAAO,KAAK,MAAM,EAAE,CAAC;QACrB,MAAM,EAAE,qBAAqB,EAAE,GAAG,MAAM,MAAM,CAAC,6BAA6B,CAAC,CAAC;QAC9E,MAAM,IAAI,GAAG,qBAAqB,CAAC,WAAW,CAAC,MAAM,CAAC,CAAC;QACvD,MAAM,IAAI,CAAC,UAAU,EAAE,CAAC;QACxB,OAAO,IAAI,CAAC;IAChB,CAAC;SAAM,IAAI,OAAO,KAAK,SAAS,EAAE,CAAC;QAC/B,MAAM,EAAE,iBAAiB,EAAE,GAAG,MAAM,MAAM,CAAC,wBAAwB,CAAC,CAAC;QACrE,MAAM,IAAI,GAAG,iBAAiB,CAAC,WAAW,CAAC,MAAM,CAAC,CAAC;QACnD,MAAM,IAAI,CAAC,UAAU,EAAE,CAAC;QACxB,OAAO,IAAI,CAAC;IAChB,CAAC;SAAM,CAAC;QACJ,MAAM,IAAI,KAAK,CAAC,6CAA6C,CAAC,CAAC;IACnE,CAAC;AACL,CAAC"}

package/build/workers/index.node.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Node.js worker pool entry point.
+ *
+ * This module provides direct access to Node.js-specific worker functionality.
+ * It re-exports everything from the base index plus Node.js specific exports.
+ *
+ * @example
+ * ```typescript
+ * import { NodeWorkerSigningPool } from '@btc-vision/bitcoin/workers';
+ *
+ * const pool = NodeWorkerSigningPool.getInstance({ workerCount: 4 });
+ * await pool.initialize();
+ * pool.preserveWorkers();
+ *
+ * const result = await pool.signBatch(tasks, keyPair);
+ *
+ * await pool.shutdown();
+ * ```
+ *
+ * @packageDocumentation
+ */
+export * from './index.js';
+export { NodeWorkerSigningPool, type NodeWorkerPoolConfig } from './WorkerSigningPool.node.js';
+//# sourceMappingURL=index.node.d.ts.map

package/build/workers/index.node.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.node.d.ts","sourceRoot":"","sources":["../../src/workers/index.node.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;AAGH,cAAc,YAAY,CAAC;AAG3B,OAAO,EAAE,qBAAqB,EAAE,KAAK,oBAAoB,EAAE,MAAM,6BAA6B,CAAC"}

package/build/workers/index.node.js

@@ -0,0 +1,26 @@
+/**
+ * Node.js worker pool entry point.
+ *
+ * This module provides direct access to Node.js-specific worker functionality.
+ * It re-exports everything from the base index plus Node.js specific exports.
+ *
+ * @example
+ * ```typescript
+ * import { NodeWorkerSigningPool } from '@btc-vision/bitcoin/workers';
+ *
+ * const pool = NodeWorkerSigningPool.getInstance({ workerCount: 4 });
+ * await pool.initialize();
+ * pool.preserveWorkers();
+ *
+ * const result = await pool.signBatch(tasks, keyPair);
+ *
+ * await pool.shutdown();
+ * ```
+ *
+ * @packageDocumentation
+ */
+// Re-export everything from browser-safe index
+export * from './index.js';
+// Node.js specific exports
+export { NodeWorkerSigningPool } from './WorkerSigningPool.node.js';
+//# sourceMappingURL=index.node.js.map

package/build/workers/index.node.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.node.js","sourceRoot":"","sources":["../../src/workers/index.node.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;AAEH,+CAA+C;AAC/C,cAAc,YAAY,CAAC;AAE3B,2BAA2B;AAC3B,OAAO,EAAE,qBAAqB,EAA6B,MAAM,6BAA6B,CAAC"}

package/package.json

@@ -1,13 +1,8 @@
 {
     "name": "@btc-vision/bitcoin",
     "type": "module",
-    "version": "7.0.0-alpha.1",
+    "version": "7.0.0-alpha.2",
     "sideEffects": false,
-    "overrides": {
-        "ecpair": {
-            "valibot": "^1.2.0"
-        }
-    },
     "description": "Client-side Bitcoin JavaScript library",
     "engines": {
         "node": ">=24.0.0"
@@ -33,6 +28,21 @@
             "import": "./browser/index.js",
             "default": "./browser/index.js"
         },
+        "./workers": {
+            "browser": {
+                "types": "./browser/workers/index.d.ts",
+                "import": "./browser/workers/index.js",
+                "default": "./browser/workers/index.js"
+            },
+            "node": {
+                "types": "./build/workers/index.node.d.ts",
+                "import": "./build/workers/index.node.js",
+                "default": "./build/workers/index.node.js"
+            },
+            "types": "./build/workers/index.d.ts",
+            "import": "./build/workers/index.js",
+            "default": "./build/workers/index.js"
+        },
         "./address": {
             "types": "./build/address.d.ts",
             "import": "./build/address.js"
@@ -89,6 +99,8 @@
     "browser": {
         "./build/index.js": "./browser/index.js",
         "./build/index.d.ts": "./browser/index.d.ts",
+        "./build/workers/index.node.js": "./browser/workers/index.js",
+        "./build/workers/index.node.d.ts": "./browser/workers/index.d.ts",
         "Buffer": "buffer",
         "crypto": "./src/crypto/crypto-browser.js",
         "stream": "stream-browserify",
@@ -132,6 +144,8 @@
         "test": "npm run build && npm run lint && vitest run",
         "test:watch": "vitest",
         "unit": "vitest run",
+        "test:browser": "vitest run --config vitest.config.browser.ts",
+        "test:browser:watch": "vitest --config vitest.config.browser.ts",
         "bench": "vitest bench benchmark/",
         "bench:run": "npx tsx benchmark/signing.bench.ts",
         "check:circular": "madge --circular --extensions ts,tsx src/",
@@ -143,6 +157,8 @@
         "@types/bs58check": "^3.0.1",
         "@types/node": "^25.0.10",
         "@types/randombytes": "^2.0.3",
+        "@vitest/browser": "^4.0.18",
+        "@vitest/browser-playwright": "^4.0.18",
         "@vitest/coverage-v8": "^4.0.18",
         "better-npm-audit": "^3.11.0",
         "bip39": "^3.1.0",
@@ -150,12 +166,12 @@
         "bip68": "^1.0.4",
         "bs58": "^6.0.0",
         "dhttp": "^3.0.3",
-        "ecpair": "^3.0.0",
         "eslint": "^9.39.2",
         "https-browserify": "^1.0.0",
         "madge": "^8.0.0",
         "minimaldata": "^1.0.2",
         "os-browserify": "^0.3.0",
+        "playwright": "^1.58.0",
         "prettier": "^3.8.1",
         "randombytes": "^2.1.0",
         "regtest-client": "0.2.1",
@@ -171,10 +187,13 @@
         "vite": "^7.3.1",
         "vite-plugin-dts": "^4.5.4",
         "vite-plugin-node-polyfills": "^0.25.0",
+        "vite-plugin-top-level-await": "^1.6.0",
+        "vite-plugin-wasm": "^3.5.0",
         "vitest": "^4.0.18"
     },
     "dependencies": {
-        "@btc-vision/bip32": "^6.1.0",
+        "@btc-vision/bip32": "^7.0.1",
+        "@btc-vision/ecpair": "^4.0.1",
         "@btc-vision/logger": "^1.0.8",
         "@noble/hashes": "^2.0.1",
         "@noble/secp256k1": "^3.0.0",
@@ -187,4 +206,4 @@
         "process": "^0.11.10",
         "varuint-bitcoin": "^2.0.0"
     }
-}
+}

package/src/address.ts

@@ -25,7 +25,6 @@ import {
     type Bytes20,
     isBytes20,
     isUInt8,
-    type Script,
     toBytes20,
     toBytes32,
     type XOnlyPublicKey,
@@ -188,27 +187,51 @@ export function toBech32(
 }
 
 /**
- * decode address from output script with network, return address if matched
+ * decode address from output script with network, return address if matched.
+ *
+ * Uses fast byte-pattern matching for common script types (P2PKH, P2SH,
+ * P2WPKH, P2WSH, P2TR) to avoid constructing payment objects and catching
+ * exceptions. Falls back to payment constructors for exotic types.
  */
 export function fromOutputScript(output: Uint8Array, network?: Network): string {
-    // TODO: Network
     network = network || networks.bitcoin;
+    const len = output.length;
+
+    // P2PKH: OP_DUP(0x76) OP_HASH160(0xa9) 0x14 <20-byte hash> OP_EQUALVERIFY(0x88) OP_CHECKSIG(0xac)
+    if (
+        len === 25 &&
+        output[0] === 0x76 &&
+        output[1] === 0xa9 &&
+        output[2] === 0x14 &&
+        output[23] === 0x88 &&
+        output[24] === 0xac
+    ) {
+        return toBase58Check(output.subarray(3, 23) as Bytes20, network.pubKeyHash);
+    }
 
-    try {
-        return p2pkh({ output: output as Script, network }).address as string;
-    } catch (e) {}
-    try {
-        return p2sh({ output: output as Script, network }).address as string;
-    } catch (e) {}
-    try {
-        return p2wpkh({ output: output as Script, network }).address as string;
-    } catch (e) {}
-    try {
-        return p2wsh({ output: output as Script, network }).address as string;
-    } catch (e) {}
-    try {
-        return p2tr({ output: output as Script, network }).address as string;
-    } catch (e) {}
+    // P2SH: OP_HASH160(0xa9) 0x14 <20-byte hash> OP_EQUAL(0x87)
+    if (len === 23 && output[0] === 0xa9 && output[1] === 0x14 && output[22] === 0x87) {
+        return toBase58Check(output.subarray(2, 22) as Bytes20, network.scriptHash);
+    }
+
+    // P2WPKH: OP_0(0x00) 0x14 <20-byte hash>
+    if (len === 22 && output[0] === 0x00 && output[1] === 0x14) {
+        return toBech32(output.subarray(2, 22), 0, network.bech32);
+    }
+
+    // P2WSH: OP_0(0x00) 0x20 <32-byte hash>
+    if (len === 34 && output[0] === 0x00 && output[1] === 0x20) {
+        return toBech32(output.subarray(2, 34), 0, network.bech32);
+    }
+
+    // P2TR: OP_1(0x51) 0x20 <32-byte x-only pubkey>
+    if (len === 34 && output[0] === 0x51 && output[1] === 0x20) {
+        const words = bech32m.toWords(output.subarray(2, 34));
+        words.unshift(1);
+        return bech32m.encode(network.bech32, words);
+    }
+
+    // Fallback for exotic types
     try {
         return toFutureOPNetAddress(output, network);
     } catch (e) {}

package/src/branded.ts

@@ -1,18 +1,20 @@
 /**
  * Branded type definitions for type-safe primitives.
  *
+ * Re-exported from @btc-vision/ecpair to ensure cross-package type compatibility.
+ *
  * @packageDocumentation
  */
-
-declare const __brand: unique symbol;
-type Brand<T, B extends string> = T & { readonly [__brand]: B };
-
-export type Bytes32 = Brand<Uint8Array, 'Bytes32'>;
-export type Bytes20 = Brand<Uint8Array, 'Bytes20'>;
-export type PublicKey = Brand<Uint8Array, 'PublicKey'>;
-export type XOnlyPublicKey = Brand<Uint8Array, 'XOnlyPublicKey'>;
-export type Satoshi = Brand<bigint, 'Satoshi'>;
-export type PrivateKey = Brand<Uint8Array, 'PrivateKey'>;
-export type Signature = Brand<Uint8Array, 'Signature'>;
-export type SchnorrSignature = Brand<Uint8Array, 'SchnorrSignature'>;
-export type Script = Brand<Uint8Array, 'Script'>;
+export type {
+    Brand,
+    Bytes32,
+    Bytes20,
+    PublicKey,
+    XOnlyPublicKey,
+    Satoshi,
+    PrivateKey,
+    Signature,
+    SchnorrSignature,
+    MessageHash,
+    Script,
+} from '@btc-vision/ecpair';

package/src/ecc/context.ts

@@ -59,6 +59,10 @@ export class EccContext {
      * ```
      */
     static init(lib: EccLib): EccContext {
+        // Skip re-verification if same lib is already initialized
+        if (EccContext.#instance && EccContext.#instance.#lib === lib) {
+            return EccContext.#instance;
+        }
         verifyEcc(lib);
         EccContext.#instance = new EccContext(lib);
         return EccContext.#instance;
@@ -177,32 +181,64 @@ export function getEccLib(): EccLib {
 // ============================================================================
 
 interface TweakAddVector {
-    pubkey: string;
-    tweak: string;
+    pubkey: Uint8Array;
+    tweak: Uint8Array;
     parity: 0 | 1 | -1;
-    result: string | null;
+    result: Uint8Array | null;
+}
+
+// Lazily decoded test vectors (decoded once on first verification)
+let _tweakVectors: TweakAddVector[] | undefined;
+let _validPoints: Uint8Array[] | undefined;
+let _invalidPoints: Uint8Array[] | undefined;
+
+function getTweakVectors(): TweakAddVector[] {
+    if (!_tweakVectors) {
+        _tweakVectors = [
+            {
+                pubkey: fromHex('79be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798'),
+                tweak: fromHex('fffffffffffffffffffffffffffffffebaaedce6af48a03bbfd25e8cd0364140'),
+                parity: -1,
+                result: null,
+            },
+            {
+                pubkey: fromHex('1617d38ed8d8657da4d4761e8057bc396ea9e4b9d29776d4be096016dbd2509b'),
+                tweak: fromHex('a8397a935f0dfceba6ba9618f6451ef4d80637abf4e6af2669fbc9de6a8fd2ac'),
+                parity: 1,
+                result: fromHex('e478f99dab91052ab39a33ea35fd5e6e4933f4d28023cd597c9a1f6760346adf'),
+            },
+            {
+                pubkey: fromHex('2c0b7cf95324a07d05398b240174dc0c2be444d96b159aa6c7f7b1e668680991'),
+                tweak: fromHex('823c3cd2142744b075a87eade7e1b8678ba308d566226a0056ca2b7a76f86b47'),
+                parity: 0,
+                result: fromHex('9534f8dc8c6deda2dc007655981c78b49c5d96c778fbf363462a11ec9dfd948c'),
+            },
+        ];
+    }
+    return _tweakVectors;
 }
 
-const TWEAK_ADD_VECTORS: TweakAddVector[] = [
-    {
-        pubkey: '79be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798',
-        tweak: 'fffffffffffffffffffffffffffffffebaaedce6af48a03bbfd25e8cd0364140',
-        parity: -1,
-        result: null,
-    },
-    {
-        pubkey: '1617d38ed8d8657da4d4761e8057bc396ea9e4b9d29776d4be096016dbd2509b',
-        tweak: 'a8397a935f0dfceba6ba9618f6451ef4d80637abf4e6af2669fbc9de6a8fd2ac',
-        parity: 1,
-        result: 'e478f99dab91052ab39a33ea35fd5e6e4933f4d28023cd597c9a1f6760346adf',
-    },
-    {
-        pubkey: '2c0b7cf95324a07d05398b240174dc0c2be444d96b159aa6c7f7b1e668680991',
-        tweak: '823c3cd2142744b075a87eade7e1b8678ba308d566226a0056ca2b7a76f86b47',
-        parity: 0,
-        result: '9534f8dc8c6deda2dc007655981c78b49c5d96c778fbf363462a11ec9dfd948c',
-    },
-];
+function getValidPoints(): Uint8Array[] {
+    if (!_validPoints) {
+        _validPoints = [
+            fromHex('79be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798'),
+            fromHex('fffffffffffffffffffffffffffffffffffffffffffffffffffffffeeffffc2e'),
+            fromHex('f9308a019258c31049344f85f89d5229b531c845836f99b08601f113bce036f9'),
+            fromHex('0000000000000000000000000000000000000000000000000000000000000001'),
+        ];
+    }
+    return _validPoints;
+}
+
+function getInvalidPoints(): Uint8Array[] {
+    if (!_invalidPoints) {
+        _invalidPoints = [
+            fromHex('0000000000000000000000000000000000000000000000000000000000000000'),
+            fromHex('fffffffffffffffffffffffffffffffffffffffffffffffffffffffefffffc2f'),
+        ];
+    }
+    return _invalidPoints;
+}
 
 /**
  * Verifies that the ECC library implementation is correct.
@@ -216,29 +252,17 @@ function verifyEcc(ecc: EccLib): void {
         throw new Error('ECC library missing isXOnlyPoint function');
     }
 
-    // Test isXOnlyPoint with valid points
-    const validPoints = [
-        '79be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798',
-        'fffffffffffffffffffffffffffffffffffffffffffffffffffffffeeffffc2e',
-        'f9308a019258c31049344f85f89d5229b531c845836f99b08601f113bce036f9',
-        '0000000000000000000000000000000000000000000000000000000000000001',
-    ];
-
-    for (const hex of validPoints) {
-        if (!ecc.isXOnlyPoint(fromHex(hex))) {
-            throw new Error(`ECC library isXOnlyPoint failed for valid point: ${hex}`);
+    // Test isXOnlyPoint with valid points (pre-decoded)
+    for (const point of getValidPoints()) {
+        if (!ecc.isXOnlyPoint(point)) {
+            throw new Error('ECC library isXOnlyPoint failed for a valid point');
         }
     }
 
-    // Test isXOnlyPoint with invalid points
-    const invalidPoints = [
-        '0000000000000000000000000000000000000000000000000000000000000000',
-        'fffffffffffffffffffffffffffffffffffffffffffffffffffffffefffffc2f',
-    ];
-
-    for (const hex of invalidPoints) {
-        if (ecc.isXOnlyPoint(fromHex(hex))) {
-            throw new Error(`ECC library isXOnlyPoint should reject invalid point: ${hex}`);
+    // Test isXOnlyPoint with invalid points (pre-decoded)
+    for (const point of getInvalidPoints()) {
+        if (ecc.isXOnlyPoint(point)) {
+            throw new Error('ECC library isXOnlyPoint should reject invalid point');
         }
     }
 
@@ -247,33 +271,27 @@ function verifyEcc(ecc: EccLib): void {
         throw new Error('ECC library missing xOnlyPointAddTweak function');
     }
 
-    for (const vector of TWEAK_ADD_VECTORS) {
+    for (const vector of getTweakVectors()) {
         const result = ecc.xOnlyPointAddTweak(
-            fromHex(vector.pubkey) as XOnlyPublicKey,
-            fromHex(vector.tweak) as Bytes32,
+            vector.pubkey as XOnlyPublicKey,
+            vector.tweak as Bytes32,
         );
 
         if (vector.result === null) {
             if (result !== null) {
                 throw new Error(
-                    `ECC library xOnlyPointAddTweak should return null for: ${vector.pubkey}`,
+                    'ECC library xOnlyPointAddTweak should return null for test vector',
                 );
             }
         } else {
             if (result === null) {
-                throw new Error(
-                    `ECC library xOnlyPointAddTweak returned null unexpectedly for: ${vector.pubkey}`,
-                );
+                throw new Error('ECC library xOnlyPointAddTweak returned null unexpectedly');
             }
             if (result.parity !== vector.parity) {
-                throw new Error(
-                    `ECC library xOnlyPointAddTweak parity mismatch for: ${vector.pubkey}`,
-                );
+                throw new Error('ECC library xOnlyPointAddTweak parity mismatch');
             }
-            if (!equals(result.xOnlyPubkey, fromHex(vector.result))) {
-                throw new Error(
-                    `ECC library xOnlyPointAddTweak result mismatch for: ${vector.pubkey}`,
-                );
+            if (!equals(result.xOnlyPubkey, vector.result)) {
+                throw new Error('ECC library xOnlyPointAddTweak result mismatch');
             }
         }
     }

package/src/index.ts

@@ -39,7 +39,42 @@ export * as script from './script.js';
 export { Block } from './block.js';
 /** @hidden */
 export * from './crypto.js';
-export * from './psbt.js';
+export {
+    Psbt,
+    PsbtCache,
+    PsbtSigner,
+    PsbtFinalizer,
+    PsbtTransaction,
+    transactionFromBuffer,
+    getFinalScripts,
+    prepareFinalScripts,
+} from './psbt.js';
+export type {
+    TransactionInput,
+    PsbtTxInput,
+    TransactionOutput,
+    PsbtTxOutput,
+    ValidateSigFunction,
+    PsbtBaseExtended,
+    PsbtOptsOptional,
+    PsbtOpts,
+    PsbtInputExtended,
+    PsbtOutputExtended,
+    PsbtOutputExtendedScript,
+    HDSigner,
+    HDSignerAsync,
+    SignerAlternative,
+    Signer,
+    SignerAsync,
+    TaprootHashCheckSigner,
+    PsbtCacheInterface,
+    TxCacheNumberKey,
+    ScriptType,
+    AllScriptType,
+    GetScriptReturn,
+    FinalScriptsFunc,
+    FinalTaprootScriptsFunc,
+} from './psbt.js';
 /** @hidden */
 export { opcodes } from './opcodes.js';
 export { Transaction } from './transaction.js';

package/src/opcodes.ts

@@ -273,8 +273,25 @@ export const opcodes: Opcodes = {
     OP_INVALIDOPCODE: 255,
 };
 
-export const REVERSE_OPS: { [key: number]: string } = {};
-for (const op of Object.keys(opcodes)) {
-    const code = opcodes[op as keyof Opcodes];
-    REVERSE_OPS[code] = op;
+let _reverseOps: { [key: number]: string } | undefined;
+
+/**
+ * Returns the reverse mapping from opcode number to opcode name.
+ * Lazily computed on first call.
+ */
+export function getReverseOps(): { [key: number]: string } {
+    if (!_reverseOps) {
+        _reverseOps = {};
+        for (const op of Object.keys(opcodes)) {
+            const code = opcodes[op as keyof Opcodes];
+            _reverseOps[code] = op;
+        }
+    }
+    return _reverseOps;
 }
+
+/**
+ * @deprecated Use {@link getReverseOps}() for lazy initialization.
+ * This eagerly-initialized alias exists for backward compatibility.
+ */
+export const REVERSE_OPS: { [key: number]: string } = getReverseOps();