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

package/src/ecc/context.ts

@@ -4,9 +4,8 @@
  *
  * @packageDocumentation
  */
-import type { EccLib } from './types.js';
-import { equals, fromHex } 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,16 +29,16 @@ 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(): EccLib {
+    get lib(): CryptoBackend {
         return this.#lib;
     }
 
@@ -46,24 +46,24 @@ export class EccContext {
      * 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 {
+    static init(lib: CryptoBackend): EccContext {
         // Skip re-verification if same lib is already initialized
         if (EccContext.#instance && EccContext.#instance.#lib === lib) {
             return EccContext.#instance;
         }
-        verifyEcc(lib);
+        verifyCryptoBackend(lib);
         EccContext.#instance = new EccContext(lib);
         return EccContext.#instance;
     }
@@ -79,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 {
@@ -117,7 +117,7 @@ export class EccContext {
      * import { EccContext } from '@btc-vision/bitcoin';
      *
      * if (!EccContext.isInitialized()) {
-     *     EccContext.init(secp256k1);
+     *     EccContext.init(createNobleBackend());
      * }
      * ```
      */
@@ -131,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;
@@ -158,141 +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: Uint8Array;
-    tweak: Uint8Array;
-    parity: 0 | 1 | -1;
-    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;
-}
-
-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.
- * 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 (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 (pre-decoded)
-    for (const point of getInvalidPoints()) {
-        if (ecc.isXOnlyPoint(point)) {
-            throw new Error('ECC library isXOnlyPoint should reject invalid point');
-        }
-    }
-
-    // Test xOnlyPointAddTweak
-    if (typeof ecc.xOnlyPointAddTweak !== 'function') {
-        throw new Error('ECC library missing xOnlyPointAddTweak function');
-    }
-
-    for (const vector of getTweakVectors()) {
-        const result = ecc.xOnlyPointAddTweak(
-            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 test vector',
-                );
-            }
-        } else {
-            if (result === null) {
-                throw new Error('ECC library xOnlyPointAddTweak returned null unexpectedly');
-            }
-            if (result.parity !== vector.parity) {
-                throw new Error('ECC library xOnlyPointAddTweak parity mismatch');
-            }
-            if (!equals(result.xOnlyPubkey, vector.result)) {
-                throw new Error('ECC library xOnlyPointAddTweak result mismatch');
-            }
-        }
-    }
-}

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';

package/src/ecc/types.ts

@@ -1,147 +1,16 @@
 /**
  * ECC (Elliptic Curve Cryptography) type definitions.
- * Defines interfaces for secp256k1 operations used in Taproot and signatures.
+ *
+ * Re-exports {@link CryptoBackend} from `@btc-vision/ecpair` as the canonical
+ * interface for secp256k1 operations. The legacy `EccLib` name is kept as a
+ * type alias for backward compatibility.
  *
  * @packageDocumentation
  */
 
-import type { Bytes32, PrivateKey, PublicKey, SchnorrSignature, Signature, XOnlyPublicKey, } from '../branded.js';
-
-/**
- * Parity of the y-coordinate for an x-only public key.
- * - 0: even y-coordinate
- * - 1: odd y-coordinate
- */
-export type Parity = 0 | 1;
-
-/**
- * Result of x-only point addition with tweak.
- */
-export interface XOnlyPointAddTweakResult {
-    /** Parity of the resulting y-coordinate (0 = even, 1 = odd) */
-    readonly parity: Parity;
-    /** The resulting x-only public key */
-    readonly xOnlyPubkey: XOnlyPublicKey;
-}
+export type { CryptoBackend, XOnlyPointAddTweakResult, Parity } from '@btc-vision/ecpair';
 
 /**
- * Interface for the ECC library used by this library.
- * This is compatible with tiny-secp256k1 and @noble/secp256k1.
- *
- * @example
- * ```typescript
- * import { EccLib, initEccLib } from '@btc-vision/bitcoin';
- * import * as secp256k1 from 'tiny-secp256k1';
- *
- * // tiny-secp256k1 implements EccLib
- * const ecc: EccLib = secp256k1;
- * initEccLib(ecc);
- * ```
+ * @deprecated Use {@link CryptoBackend} from `@btc-vision/ecpair` instead.
  */
-export interface EccLib {
-    /**
-     * Checks if a 32-byte value is a valid x-only public key.
-     *
-     * @param p - 32-byte x-coordinate
-     * @returns True if the point is valid on the secp256k1 curve
-     */
-    isXOnlyPoint(p: Uint8Array): boolean;
-
-    /**
-     * Adds a tweak to an x-only public key.
-     *
-     * @param p - 32-byte x-only public key
-     * @param tweak - 32-byte scalar to add
-     * @returns The tweaked public key with parity, or null if result is invalid
-     */
-    xOnlyPointAddTweak(p: XOnlyPublicKey, tweak: Bytes32): XOnlyPointAddTweakResult | null;
-
-    /**
-     * Signs a 32-byte message hash with a private key (ECDSA).
-     * Optional - only needed for signing operations.
-     *
-     * @param hash - 32-byte message hash
-     * @param privateKey - 32-byte private key
-     * @returns DER-encoded signature
-     */
-    sign?(hash: Bytes32, privateKey: PrivateKey): Signature;
-
-    /**
-     * Signs a 32-byte message hash with a private key (Schnorr/BIP340).
-     * Optional - only needed for Taproot key-path signing.
-     *
-     * @param hash - 32-byte message hash
-     * @param privateKey - 32-byte private key
-     * @returns 64-byte Schnorr signature
-     */
-    signSchnorr?(hash: Bytes32, privateKey: PrivateKey): SchnorrSignature;
-
-    /**
-     * Verifies an ECDSA signature.
-     * Optional - only needed for signature verification.
-     *
-     * @param hash - 32-byte message hash
-     * @param publicKey - 33 or 65-byte public key
-     * @param signature - DER-encoded signature
-     * @returns True if signature is valid
-     */
-    verify?(hash: Bytes32, publicKey: PublicKey, signature: Signature): boolean;
-
-    /**
-     * Verifies a Schnorr/BIP340 signature.
-     * Optional - only needed for Taproot signature verification.
-     *
-     * @param hash - 32-byte message hash
-     * @param publicKey - 32-byte x-only public key
-     * @param signature - 64-byte Schnorr signature
-     * @returns True if signature is valid
-     */
-    verifySchnorr?(hash: Bytes32, publicKey: XOnlyPublicKey, signature: SchnorrSignature): boolean;
-
-    /**
-     * Derives a public key from a private key.
-     * Optional - only needed for key derivation.
-     *
-     * @param privateKey - 32-byte private key
-     * @param compressed - Whether to return compressed (33-byte) or uncompressed (65-byte)
-     * @returns The public key, or null if private key is invalid
-     */
-    pointFromScalar?(privateKey: PrivateKey, compressed?: boolean): PublicKey | null;
-
-    /**
-     * Computes the x-only public key from a private key.
-     * Optional - only needed for Taproot key derivation.
-     *
-     * @param privateKey - 32-byte private key
-     * @returns 32-byte x-only public key, or null if private key is invalid
-     */
-    xOnlyPointFromScalar?(privateKey: PrivateKey): XOnlyPublicKey | null;
-
-    /**
-     * Converts a full public key to x-only format.
-     * Optional - only needed when working with x-only keys.
-     *
-     * @param pubkey - 33 or 65-byte public key
-     * @returns 32-byte x-only public key
-     */
-    xOnlyPointFromPoint?(pubkey: PublicKey): XOnlyPublicKey;
-
-    /**
-     * Adds a scalar to a private key.
-     * Optional - only needed for key tweaking.
-     *
-     * @param privateKey - 32-byte private key
-     * @param tweak - 32-byte scalar to add
-     * @returns The tweaked private key, or null if result is invalid
-     */
-    privateAdd?(privateKey: PrivateKey, tweak: Bytes32): PrivateKey | null;
-
-    /**
-     * Negates a private key.
-     * Optional - only needed for Taproot parity handling.
-     *
-     * @param privateKey - 32-byte private key
-     * @returns The negated private key
-     */
-    privateNegate?(privateKey: PrivateKey): PrivateKey;
-}
+export type { CryptoBackend as EccLib } from '@btc-vision/ecpair';

package/src/index.ts

@@ -63,7 +63,6 @@ export type {
     PsbtOutputExtendedScript,
     HDSigner,
     HDSignerAsync,
-    SignerAlternative,
     Signer,
     SignerAsync,
     TaprootHashCheckSigner,
@@ -83,7 +82,7 @@ export type { TaprootHashCache } from './transaction.js';
 export type { Network } from './networks.js';
 /** @hidden */
 export { initEccLib, getEccLib, EccContext } from './ecc/context.js';
-export type { EccLib } from './ecc/types.js';
+export type { CryptoBackend, EccLib } from './ecc/types.js';
 export { PaymentType } from './payments/index.js';
 export type {
     Payment,

package/src/payments/p2tr.ts

@@ -9,11 +9,11 @@
 
 import { bech32m } from 'bech32';
 import { fromBech32 } from '../bech32utils.js';
-import { getEccLib } from '../ecc/context.js';
 import { bitcoin as BITCOIN_NETWORK, type Network } from '../networks.js';
 import * as bscript from '../script.js';
 import {
     type Bytes32,
+    isXOnlyPublicKey,
     type SchnorrSignature,
     type Script,
     stacksEqual,
@@ -716,7 +716,7 @@ export class P2TR {
                     throw new TypeError('Internal pubkey mismatch');
                 }
 
-                if (!getEccLib().isXOnlyPoint(internalPk)) {
+                if (!isXOnlyPublicKey(internalPk)) {
                     throw new TypeError('Invalid internalPubkey for p2tr witness');
                 }
 

package/src/psbt/types.ts

@@ -6,7 +6,7 @@
 import type { Psbt as PsbtBase, PsbtGlobal, PsbtInput, PsbtOutput } from 'bip174';
 import type { Network } from '../networks.js';
 import type { TaprootHashCache, Transaction } from '../transaction.js';
-import type { Bytes32, MessageHash, PublicKey, Satoshi, SchnorrSignature, Script, Signature } from '../types.js';
+import type { Bytes32, MessageHash, PublicKey, Satoshi, Script } from '../types.js';
 
 /**
  * Transaction input interface for PSBT.
@@ -102,89 +102,7 @@ export interface PsbtOutputExtendedScript extends PsbtOutput {
     readonly value: Satoshi;
 }
 
-/**
- * Base interface for HD signers.
- */
-interface HDSignerBase {
-    /**
-     * DER format compressed publicKey Uint8Array
-     */
-    readonly publicKey: PublicKey;
-    /**
-     * The first 4 bytes of the sha256-ripemd160 of the publicKey
-     */
-    readonly fingerprint: Uint8Array;
-}
-
-/**
- * HD signer interface for synchronous signing.
- */
-export interface HDSigner extends HDSignerBase {
-    /**
-     * The path string must match /^m(\/\d+'?)+$/
-     * ex. m/44'/0'/0'/1/23 levels with ' must be hard derivations
-     */
-    derivePath(path: string): HDSigner;
-
-    /**
-     * Input hash (the "message digest") for the signature algorithm
-     * Return a 64 byte signature (32 byte r and 32 byte s in that order)
-     */
-    sign(hash: MessageHash): Uint8Array;
-}
-
-/**
- * HD signer interface for asynchronous signing.
- */
-export interface HDSignerAsync extends HDSignerBase {
-    derivePath(path: string): HDSignerAsync;
-
-    sign(hash: MessageHash): Promise<Uint8Array>;
-}
-
-/**
- * Alternative signer interface with lowR support.
- */
-export interface SignerAlternative {
-    readonly publicKey: PublicKey;
-    readonly lowR: boolean;
-
-    sign(hash: MessageHash, lowR?: boolean): Signature;
-
-    verify(hash: MessageHash, signature: Signature): boolean;
-
-    signSchnorr(hash: MessageHash): SchnorrSignature;
-
-    verifySchnorr(hash: MessageHash, signature: SchnorrSignature): boolean;
-}
-
-/**
- * Basic signer interface for synchronous signing.
- */
-export interface Signer {
-    readonly publicKey: PublicKey;
-    readonly network?: Network | undefined;
-
-    sign(hash: MessageHash, lowR?: boolean): Signature;
-
-    signSchnorr?(hash: MessageHash): SchnorrSignature;
-
-    getPublicKey?(): PublicKey;
-}
-
-/**
- * Basic signer interface for asynchronous signing.
- */
-export interface SignerAsync {
-    readonly publicKey: PublicKey;
-    readonly network?: Network | undefined;
-
-    sign(hash: MessageHash, lowR?: boolean): Promise<Signature>;
-
-    signSchnorr?(hash: MessageHash): Promise<SchnorrSignature>;
-
-    getPublicKey?(): PublicKey;
-}
+export type { Signer, SignerAsync, HDSigner, HDSignerAsync } from '@btc-vision/ecpair';
 
 /**
  * Minimal key pair interface for checking Taproot hashes.