@btc-vision/bitcoin 7.0.0-alpha.0 → 7.0.0-alpha.10

package/package.json

@@ -1,19 +1,19 @@
 {
     "name": "@btc-vision/bitcoin",
     "type": "module",
-    "version": "7.0.0-alpha.0",
+    "version": "7.0.0-alpha.10",
     "sideEffects": false,
-    "overrides": {
-        "ecpair": {
-            "valibot": "^1.2.0"
-        }
-    },
     "description": "Client-side Bitcoin JavaScript library",
     "engines": {
         "node": ">=24.0.0"
     },
     "exports": {
         ".": {
+            "react-native": {
+                "types": "./build/index.d.ts",
+                "import": "./build/index.js",
+                "default": "./build/index.js"
+            },
             "browser": {
                 "types": "./browser/index.d.ts",
                 "import": "./browser/index.js",
@@ -33,6 +33,26 @@
             "import": "./browser/index.js",
             "default": "./browser/index.js"
         },
+        "./workers": {
+            "react-native": {
+                "types": "./build/workers/index.react-native.d.ts",
+                "import": "./build/workers/index.react-native.js",
+                "default": "./build/workers/index.react-native.js"
+            },
+            "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 +109,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",
@@ -122,7 +144,7 @@
         "audit": "better-npm-audit audit -l high",
         "clean": "rimraf build",
         "coverage": "vitest run --coverage",
-        "doc": "typedoc",
+        "doc": "typedoc --options typedoc.json",
         "format:ci": "npm run prettier -- --check && npm run prettier -- --check",
         "gitdiff:ci": "npm run build && git diff --exit-code",
         "integration": "vitest run --config vitest.config.integration.ts",
@@ -132,6 +154,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 +167,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 +176,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",
@@ -165,15 +191,27 @@
         "tiny-secp256k1": "^2.2.4",
         "ts-node": "^10.9.2",
         "typedoc": "^0.28.16",
+        "typedoc-material-theme": "^1.4.1",
         "typescript": "^5.9.3",
         "typescript-eslint": "^8.53.1",
         "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"
     },
+    "peerDependencies": {
+        "react-native-worklets": ">=0.7.0"
+    },
+    "peerDependenciesMeta": {
+        "react-native-worklets": {
+            "optional": true
+        }
+    },
     "dependencies": {
-        "@btc-vision/bip32": "^6.1.0",
+        "@btc-vision/bip32": "^7.0.2",
+        "@btc-vision/ecpair": "^4.0.2",
         "@btc-vision/logger": "^1.0.8",
         "@noble/hashes": "^2.0.1",
         "@noble/secp256k1": "^3.0.0",
@@ -183,6 +221,7 @@
         "browserify-zlib": "^0.2.0",
         "bs58check": "^4.0.0",
         "buffer": "^6.0.3",
+        "esbuild": "^0.27.2",
         "process": "^0.11.10",
         "varuint-bitcoin": "^2.0.0"
     }

package/src/address.ts

@@ -9,10 +9,10 @@
  */
 import { bech32, bech32m } from 'bech32';
 import * as bs58check from 'bs58check';
-import { fromBech32, type Bech32Result } from './bech32utils.js';
+import { type Bech32Result, fromBech32 } from './bech32utils.js';
 import { alloc } from './io/index.js';
-import * as networks from './networks.js';
 import type { Network } from './networks.js';
+import * as networks from './networks.js';
 import { p2op } from './payments/p2op.js';
 import { p2pkh } from './payments/p2pkh.js';
 import { p2sh } from './payments/p2sh.js';
@@ -21,7 +21,14 @@ import { p2wpkh } from './payments/p2wpkh.js';
 import { p2wsh } from './payments/p2wsh.js';
 import * as bscript from './script.js';
 import { opcodes } from './script.js';
-import { isBytes20, isUInt8, toBytes20, toBytes32, type Bytes20, type XOnlyPublicKey, type Script } from './types.js';
+import {
+    type Bytes20,
+    isBytes20,
+    isUInt8,
+    toBytes20,
+    toBytes32,
+    type XOnlyPublicKey,
+} from './types.js';
 
 export { fromBech32, type Bech32Result };
 
@@ -180,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) {}
@@ -282,7 +313,8 @@ export function toOutputScript(
                     return p2wsh({ hash: toBytes32(decodeBech32.data) }).output as Uint8Array;
             } else if (decodeBech32.version === 1) {
                 if (decodeBech32.data.length === 32)
-                    return p2tr({ pubkey: decodeBech32.data as XOnlyPublicKey }).output as Uint8Array;
+                    return p2tr({ pubkey: decodeBech32.data as XOnlyPublicKey })
+                        .output as Uint8Array;
             } else if (decodeBech32.version === FUTURE_OPNET_VERSION) {
                 if (!network.bech32Opnet) throw new Error(address + ' has an invalid prefix');
                 return p2op({

package/src/bech32utils.ts

@@ -25,18 +25,18 @@ export function fromBech32(address: string): Bech32Result {
     } catch (e) {}
 
     if (result) {
-        version = result.words[0];
+        version = result.words[0] as number;
         if (version !== 0) throw new TypeError(address + ' uses wrong encoding');
     } else {
         result = bech32m.decode(address);
-        version = result.words[0];
+        version = result.words[0] as number;
         if (version === 0) throw new TypeError(address + ' uses wrong encoding');
     }
 
     const data = bech32.fromWords(result.words.slice(1));
 
     return {
-        version: version!,
+        version: version,
         prefix: result.prefix,
         data: new Uint8Array(data),
     };

package/src/block.ts

@@ -1,5 +1,15 @@
 import * as bcrypto from './crypto.js';
-import { BinaryReader, BinaryWriter, varuint, equals, fromHex, alloc, compare, toHex, reverse } from './io/index.js';
+import {
+    alloc,
+    BinaryReader,
+    BinaryWriter,
+    compare,
+    equals,
+    fromHex,
+    reverse,
+    toHex,
+    varuint,
+} from './io/index.js';
 import { fastMerkleRoot } from './merkle.js';
 import { Transaction } from './transaction.js';
 import type { Bytes32 } from './types.js';
@@ -70,10 +80,7 @@ export class Block {
         if (buffer.length === 80) return block;
 
         const readTransaction = (): Transaction => {
-            const tx = Transaction.fromBuffer(
-                reader.data.subarray(reader.offset),
-                true,
-            );
+            const tx = Transaction.fromBuffer(reader.data.subarray(reader.offset), true);
             reader.offset += tx.byteLength();
             return tx;
         };
@@ -138,11 +145,11 @@ export class Block {
         const rootHash = fastMerkleRoot(hashes, bcrypto.hash256);
 
         if (forWitness) {
-            const witness = transactions[0]!.ins[0]!.witness![0]!;
+            const witness = transactions[0]!.ins[0]!.witness[0]!;
             const combined = new Uint8Array(rootHash.length + witness.length);
             combined.set(rootHash);
             combined.set(witness, rootHash.length);
-            return bcrypto.hash256(combined) as Bytes32;
+            return bcrypto.hash256(combined);
         }
         return rootHash as Bytes32;
     }
@@ -158,9 +165,9 @@ export class Block {
         // There is no rule for the index of the output, so use filter to find it.
         // The root is prepended with 0xaa21a9ed so check for 0x6a24aa21a9ed
         // If multiple commits are found, the output with highest index is assumed.
-        const witnessCommits = this.transactions[0]!.outs
-            .filter((out) => equals(out.script.subarray(0, 6), WITNESS_COMMIT_PREFIX))
-            .map((out) => out.script.subarray(6, 38));
+        const witnessCommits = this.transactions[0]!.outs.filter((out) =>
+            equals(out.script.subarray(0, 6), WITNESS_COMMIT_PREFIX),
+        ).map((out) => out.script.subarray(6, 38));
         if (witnessCommits.length === 0) return null;
         // Use the commit with the highest output (should only be one though)
         const result = witnessCommits[witnessCommits.length - 1];

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/crypto.ts

@@ -7,7 +7,7 @@
 import { ripemd160 as _ripemd160, sha1 as _sha1 } from '@noble/hashes/legacy.js';
 import { sha256 as _sha256 } from '@noble/hashes/sha2.js';
 import { concat } from './io/index.js';
-import type { Bytes32, Bytes20 } from './types.js';
+import type { Bytes20, Bytes32 } from './types.js';
 
 /**
  * Computes RIPEMD-160 hash of the input.

package/src/ecc/context.ts

@@ -4,9 +4,8 @@
  *
  * @packageDocumentation
  */
-import type { EccLib } from './types.js';
-import { fromHex, equals } from '../io/index.js';
-import type { Bytes32, XOnlyPublicKey } from '../types.js';
+import type { CryptoBackend } from '@btc-vision/ecpair';
+import { verifyCryptoBackend } from '@btc-vision/ecpair';
 
 /**
  * Context class for managing the ECC library instance.
@@ -15,10 +14,11 @@ import type { Bytes32, XOnlyPublicKey } from '../types.js';
  * @example
  * ```typescript
  * import { EccContext } from '@btc-vision/bitcoin';
- * import * as secp256k1 from 'tiny-secp256k1';
+ * import { createNobleBackend } from '@btc-vision/ecpair';
  *
  * // Initialize once at app startup
- * EccContext.init(secp256k1);
+ * const backend = createNobleBackend();
+ * EccContext.init(backend);
  *
  * // Get instance anywhere in your code
  * const ecc = EccContext.get();
@@ -29,30 +29,41 @@ import type { Bytes32, XOnlyPublicKey } from '../types.js';
  */
 export class EccContext {
     static #instance: EccContext | undefined;
-    readonly #lib: EccLib;
+    readonly #lib: CryptoBackend;
 
-    private constructor(lib: EccLib) {
+    private constructor(lib: CryptoBackend) {
         this.#lib = lib;
     }
 
+    /**
+     * The underlying ECC library instance.
+     */
+    get lib(): CryptoBackend {
+        return this.#lib;
+    }
+
     /**
      * Initializes the ECC context with the provided library.
      * The library is verified before being set as active.
      *
-     * @param lib - The ECC library instance to initialize
+     * @param lib - The CryptoBackend instance to initialize
      * @returns The initialized EccContext instance
-     * @throws Error if the ECC library fails verification
+     * @throws Error if the CryptoBackend fails verification
      *
      * @example
      * ```typescript
      * import { EccContext } from '@btc-vision/bitcoin';
-     * import * as secp256k1 from 'tiny-secp256k1';
+     * import { createNobleBackend } from '@btc-vision/ecpair';
      *
-     * const context = EccContext.init(secp256k1);
+     * const context = EccContext.init(createNobleBackend());
      * ```
      */
-    static init(lib: EccLib): EccContext {
-        verifyEcc(lib);
+    static init(lib: CryptoBackend): EccContext {
+        // Skip re-verification if same lib is already initialized
+        if (EccContext.#instance && EccContext.#instance.#lib === lib) {
+            return EccContext.#instance;
+        }
+        verifyCryptoBackend(lib);
         EccContext.#instance = new EccContext(lib);
         return EccContext.#instance;
     }
@@ -68,7 +79,7 @@ export class EccContext {
      * import { EccContext } from '@btc-vision/bitcoin';
      *
      * const context = EccContext.get();
-     * const isValid = context.lib.isXOnlyPoint(someKey);
+     * const tweaked = context.lib.xOnlyPointAddTweak(key, tweak);
      * ```
      */
     static get(): EccContext {
@@ -106,20 +117,13 @@ export class EccContext {
      * import { EccContext } from '@btc-vision/bitcoin';
      *
      * if (!EccContext.isInitialized()) {
-     *     EccContext.init(secp256k1);
+     *     EccContext.init(createNobleBackend());
      * }
      * ```
      */
     static isInitialized(): boolean {
         return EccContext.#instance !== undefined;
     }
-
-    /**
-     * The underlying ECC library instance.
-     */
-    get lib(): EccLib {
-        return this.#lib;
-    }
 }
 
 /**
@@ -127,22 +131,22 @@ export class EccContext {
  * This is a convenience function that wraps EccContext.init().
  * Pass `undefined` to clear the library.
  *
- * @param eccLib - The ECC library instance to initialize, or undefined to clear
- * @throws Error if the ECC library fails verification
+ * @param eccLib - The CryptoBackend instance to initialize, or undefined to clear
+ * @throws Error if the CryptoBackend fails verification
  *
  * @example
  * ```typescript
  * import { initEccLib } from '@btc-vision/bitcoin';
- * import * as secp256k1 from 'tiny-secp256k1';
+ * import { createNobleBackend } from '@btc-vision/ecpair';
  *
  * // Initialize the ECC library
- * initEccLib(secp256k1);
+ * initEccLib(createNobleBackend());
  *
  * // Clear the library
  * initEccLib(undefined);
  * ```
  */
-export function initEccLib(eccLib: EccLib | undefined): void {
+export function initEccLib(eccLib: CryptoBackend | undefined): void {
     if (eccLib === undefined) {
         EccContext.clear();
         return;
@@ -154,124 +158,20 @@ export function initEccLib(eccLib: EccLib | undefined): void {
  * Retrieves the initialized ECC library instance.
  * This is a convenience function that wraps EccContext.get().lib.
  *
- * @returns The ECC library instance
+ * @returns The CryptoBackend instance
  * @throws Error if the ECC library has not been initialized
  *
  * @example
  * ```typescript
  * import { getEccLib, initEccLib } from '@btc-vision/bitcoin';
- * import * as secp256k1 from 'tiny-secp256k1';
+ * import { createNobleBackend } from '@btc-vision/ecpair';
  *
- * initEccLib(secp256k1);
+ * initEccLib(createNobleBackend());
  *
  * const ecc = getEccLib();
- * const isValid = ecc.isXOnlyPoint(somePublicKey);
+ * const tweaked = ecc.xOnlyPointAddTweak(pubkey, tweak);
  * ```
  */
-export function getEccLib(): EccLib {
+export function getEccLib(): CryptoBackend {
     return EccContext.get().lib;
 }
-
-// ============================================================================
-// Verification
-// ============================================================================
-
-interface TweakAddVector {
-    pubkey: string;
-    tweak: string;
-    parity: 0 | 1 | -1;
-    result: string | null;
-}
-
-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',
-    },
-];
-
-/**
- * Verifies that the ECC library implementation is correct.
- * Tests `isXOnlyPoint` and `xOnlyPointAddTweak` with known test vectors.
- *
- * @param ecc - The ECC library to verify
- * @throws Error if any verification test fails
- */
-function verifyEcc(ecc: EccLib): void {
-    if (typeof ecc.isXOnlyPoint !== 'function') {
-        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 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 xOnlyPointAddTweak
-    if (typeof ecc.xOnlyPointAddTweak !== 'function') {
-        throw new Error('ECC library missing xOnlyPointAddTweak function');
-    }
-
-    for (const vector of TWEAK_ADD_VECTORS) {
-        const result = ecc.xOnlyPointAddTweak(fromHex(vector.pubkey) as XOnlyPublicKey, fromHex(vector.tweak) as Bytes32);
-
-        if (vector.result === null) {
-            if (result !== null) {
-                throw new Error(
-                    `ECC library xOnlyPointAddTweak should return null for: ${vector.pubkey}`,
-                );
-            }
-        } else {
-            if (result === null) {
-                throw new Error(
-                    `ECC library xOnlyPointAddTweak returned null unexpectedly for: ${vector.pubkey}`,
-                );
-            }
-            if (result.parity !== vector.parity) {
-                throw new Error(
-                    `ECC library xOnlyPointAddTweak parity mismatch for: ${vector.pubkey}`,
-                );
-            }
-            if (!equals(result.xOnlyPubkey, fromHex(vector.result))) {
-                throw new Error(
-                    `ECC library xOnlyPointAddTweak result mismatch for: ${vector.pubkey}`,
-                );
-            }
-        }
-    }
-}

package/src/ecc/index.ts

@@ -7,8 +7,8 @@
  * @packageDocumentation
  */
 
-// Core types
-export type { EccLib, XOnlyPointAddTweakResult, Parity } from './types.js';
+// Core types (CryptoBackend is the canonical name; EccLib is a deprecated alias)
+export type { CryptoBackend, EccLib, XOnlyPointAddTweakResult, Parity } from './types.js';
 
 // Context management
 export { EccContext, initEccLib, getEccLib } from './context.js';