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

package/browser/crypto.d.ts

@@ -1,13 +1,52 @@
-export declare function ripemd160(buffer: Buffer): Buffer;
-export declare function sha1(buffer: Buffer): Buffer;
-export declare function sha256(buffer: Buffer): Buffer;
-export declare function hash160(buffer: Buffer): Buffer;
-export declare function hash256(buffer: Buffer): Buffer;
+import { Bytes20, Bytes32 } from './types.js';
+/**
+ * Computes RIPEMD-160 hash of the input.
+ * @param data - Input data
+ * @returns 20-byte hash (Bytes20)
+ */
+export declare function ripemd160(data: Uint8Array): Bytes20;
+/**
+ * Computes SHA-1 hash of the input.
+ * @param data - Input data
+ * @returns 20-byte hash (Bytes20)
+ */
+export declare function sha1(data: Uint8Array): Bytes20;
+/**
+ * Computes SHA-256 hash of the input.
+ * @param data - Input data
+ * @returns 32-byte hash (Bytes32)
+ */
+export declare function sha256(data: Uint8Array): Bytes32;
+/**
+ * Computes HASH160 (RIPEMD160(SHA256(data))) of the input.
+ * @param data - Input data
+ * @returns 20-byte hash (Bytes20)
+ */
+export declare function hash160(data: Uint8Array): Bytes20;
+/**
+ * Computes double SHA-256 hash of the input.
+ * @param data - Input data
+ * @returns 32-byte hash (Bytes32)
+ */
+export declare function hash256(data: Uint8Array): Bytes32;
+/**
+ * BIP340/Taproot tag names for tagged hashing.
+ */
 export declare const TAGS: readonly ["BIP0340/challenge", "BIP0340/aux", "BIP0340/nonce", "TapLeaf", "TapBranch", "TapSighash", "TapTweak", "KeyAgg list", "KeyAgg coefficient"];
 export type TaggedHashPrefix = (typeof TAGS)[number];
 type TaggedHashPrefixes = {
-    [key in TaggedHashPrefix]: Buffer;
+    [key in TaggedHashPrefix]: Uint8Array;
 };
+/**
+ * Precomputed tagged hash prefixes: SHA256(tag) || SHA256(tag)
+ */
 export declare const TAGGED_HASH_PREFIXES: TaggedHashPrefixes;
-export declare function taggedHash(prefix: TaggedHashPrefix, data: Buffer): Buffer;
+/**
+ * Computes a BIP340-style tagged hash.
+ * @param prefix - The tag name
+ * @param data - Input data
+ * @returns 32-byte hash (Bytes32)
+ */
+export declare function taggedHash(prefix: TaggedHashPrefix, data: Uint8Array): Bytes32;
 export {};
+//# sourceMappingURL=crypto.d.ts.map

package/browser/crypto.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"crypto.d.ts","sourceRoot":"","sources":["../src/crypto.ts"],"names":[],"mappings":"AASA,OAAO,KAAK,EAAE,OAAO,EAAE,OAAO,EAAE,MAAM,YAAY,CAAC;AAEnD;;;;GAIG;AACH,wBAAgB,SAAS,CAAC,IAAI,EAAE,UAAU,GAAG,OAAO,CAEnD;AAED;;;;GAIG;AACH,wBAAgB,IAAI,CAAC,IAAI,EAAE,UAAU,GAAG,OAAO,CAE9C;AAED;;;;GAIG;AACH,wBAAgB,MAAM,CAAC,IAAI,EAAE,UAAU,GAAG,OAAO,CAEhD;AAED;;;;GAIG;AACH,wBAAgB,OAAO,CAAC,IAAI,EAAE,UAAU,GAAG,OAAO,CAEjD;AAED;;;;GAIG;AACH,wBAAgB,OAAO,CAAC,IAAI,EAAE,UAAU,GAAG,OAAO,CAEjD;AAED;;GAEG;AACH,eAAO,MAAM,IAAI,uJAUP,CAAC;AAEX,MAAM,MAAM,gBAAgB,GAAG,CAAC,OAAO,IAAI,CAAC,CAAC,MAAM,CAAC,CAAC;AAErD,KAAK,kBAAkB,GAAG;KACrB,GAAG,IAAI,gBAAgB,GAAG,UAAU;CACxC,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,oBAAoB,EAAE,kBAsDlC,CAAC;AAEF;;;;;GAKG;AACH,wBAAgB,UAAU,CAAC,MAAM,EAAE,gBAAgB,EAAE,IAAI,EAAE,UAAU,GAAG,OAAO,CAE9E"}

package/browser/ecc/context.d.ts

@@ -0,0 +1,129 @@
+import { EccLib } from './types.js';
+/**
+ * Context class for managing the ECC library instance.
+ * Uses dependency injection pattern instead of global singleton.
+ *
+ * @example
+ * ```typescript
+ * import { EccContext } from '@btc-vision/bitcoin';
+ * import * as secp256k1 from 'tiny-secp256k1';
+ *
+ * // Initialize once at app startup
+ * EccContext.init(secp256k1);
+ *
+ * // Get instance anywhere in your code
+ * const ecc = EccContext.get();
+ *
+ * // Clear when done (optional, for testing)
+ * EccContext.clear();
+ * ```
+ */
+export declare class EccContext {
+    #private;
+    private constructor();
+    /**
+     * The underlying ECC library instance.
+     */
+    get lib(): EccLib;
+    /**
+     * 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
+     * @returns The initialized EccContext instance
+     * @throws Error if the ECC library fails verification
+     *
+     * @example
+     * ```typescript
+     * import { EccContext } from '@btc-vision/bitcoin';
+     * import * as secp256k1 from 'tiny-secp256k1';
+     *
+     * const context = EccContext.init(secp256k1);
+     * ```
+     */
+    static init(lib: EccLib): EccContext;
+    /**
+     * Gets the initialized ECC context.
+     *
+     * @returns The EccContext instance
+     * @throws Error if the context has not been initialized
+     *
+     * @example
+     * ```typescript
+     * import { EccContext } from '@btc-vision/bitcoin';
+     *
+     * const context = EccContext.get();
+     * const isValid = context.lib.isXOnlyPoint(someKey);
+     * ```
+     */
+    static get(): EccContext;
+    /**
+     * Clears the ECC context.
+     * Useful for testing or when reinitializing with a different library.
+     *
+     * @example
+     * ```typescript
+     * import { EccContext } from '@btc-vision/bitcoin';
+     *
+     * EccContext.clear();
+     * // Context is now uninitialized
+     * ```
+     */
+    static clear(): void;
+    /**
+     * Checks if the ECC context has been initialized.
+     *
+     * @returns True if initialized
+     *
+     * @example
+     * ```typescript
+     * import { EccContext } from '@btc-vision/bitcoin';
+     *
+     * if (!EccContext.isInitialized()) {
+     *     EccContext.init(secp256k1);
+     * }
+     * ```
+     */
+    static isInitialized(): boolean;
+}
+/**
+ * Initializes the ECC library with the provided instance.
+ * 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
+ *
+ * @example
+ * ```typescript
+ * import { initEccLib } from '@btc-vision/bitcoin';
+ * import * as secp256k1 from 'tiny-secp256k1';
+ *
+ * // Initialize the ECC library
+ * initEccLib(secp256k1);
+ *
+ * // Clear the library
+ * initEccLib(undefined);
+ * ```
+ */
+export declare 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
+ * @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';
+ *
+ * initEccLib(secp256k1);
+ *
+ * const ecc = getEccLib();
+ * const isValid = ecc.isXOnlyPoint(somePublicKey);
+ * ```
+ */
+export declare function getEccLib(): EccLib;
+//# sourceMappingURL=context.d.ts.map

package/browser/ecc/context.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"context.d.ts","sourceRoot":"","sources":["../../src/ecc/context.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,YAAY,CAAC;AAIzC;;;;;;;;;;;;;;;;;;GAkBG;AACH,qBAAa,UAAU;;IAInB,OAAO;IAIP;;OAEG;IACH,IAAI,GAAG,IAAI,MAAM,CAEhB;IAED;;;;;;;;;;;;;;;OAeG;IACH,MAAM,CAAC,IAAI,CAAC,GAAG,EAAE,MAAM,GAAG,UAAU;IAMpC;;;;;;;;;;;;;OAaG;IACH,MAAM,CAAC,GAAG,IAAI,UAAU;IASxB;;;;;;;;;;;OAWG;IACH,MAAM,CAAC,KAAK,IAAI,IAAI;IAIpB;;;;;;;;;;;;;OAaG;IACH,MAAM,CAAC,aAAa,IAAI,OAAO;CAGlC;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,UAAU,CAAC,MAAM,EAAE,MAAM,GAAG,SAAS,GAAG,IAAI,CAM3D;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,SAAS,IAAI,MAAM,CAElC"}

package/browser/ecc/index.d.ts

@@ -0,0 +1,11 @@
+/**
+ * ECC (Elliptic Curve Cryptography) module.
+ *
+ * Provides dependency injection for the secp256k1 elliptic curve library
+ * required for Taproot (BIP340/BIP341) operations.
+ *
+ * @packageDocumentation
+ */
+export type { EccLib, XOnlyPointAddTweakResult, Parity } from './types.js';
+export { EccContext, initEccLib, getEccLib } from './context.js';
+//# sourceMappingURL=index.d.ts.map

package/browser/ecc/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/ecc/index.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAGH,YAAY,EAAE,MAAM,EAAE,wBAAwB,EAAE,MAAM,EAAE,MAAM,YAAY,CAAC;AAG3E,OAAO,EAAE,UAAU,EAAE,UAAU,EAAE,SAAS,EAAE,MAAM,cAAc,CAAC"}

package/browser/ecc/types.d.ts

@@ -0,0 +1,128 @@
+import { 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;
+}
+/**
+ * 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);
+ * ```
+ */
+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;
+}
+//# sourceMappingURL=types.d.ts.map

package/browser/ecc/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/ecc/types.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,KAAK,EAAE,OAAO,EAAE,UAAU,EAAE,SAAS,EAAE,gBAAgB,EAAE,SAAS,EAAE,cAAc,EAAG,MAAM,eAAe,CAAC;AAElH;;;;GAIG;AACH,MAAM,MAAM,MAAM,GAAG,CAAC,GAAG,CAAC,CAAC;AAE3B;;GAEG;AACH,MAAM,WAAW,wBAAwB;IACrC,+DAA+D;IAC/D,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,sCAAsC;IACtC,QAAQ,CAAC,WAAW,EAAE,cAAc,CAAC;CACxC;AAED;;;;;;;;;;;;;GAaG;AACH,MAAM,WAAW,MAAM;IACnB;;;;;OAKG;IACH,YAAY,CAAC,CAAC,EAAE,UAAU,GAAG,OAAO,CAAC;IAErC;;;;;;OAMG;IACH,kBAAkB,CAAC,CAAC,EAAE,cAAc,EAAE,KAAK,EAAE,OAAO,GAAG,wBAAwB,GAAG,IAAI,CAAC;IAEvF;;;;;;;OAOG;IACH,IAAI,CAAC,CAAC,IAAI,EAAE,OAAO,EAAE,UAAU,EAAE,UAAU,GAAG,SAAS,CAAC;IAExD;;;;;;;OAOG;IACH,WAAW,CAAC,CAAC,IAAI,EAAE,OAAO,EAAE,UAAU,EAAE,UAAU,GAAG,gBAAgB,CAAC;IAEtE;;;;;;;;OAQG;IACH,MAAM,CAAC,CAAC,IAAI,EAAE,OAAO,EAAE,SAAS,EAAE,SAAS,EAAE,SAAS,EAAE,SAAS,GAAG,OAAO,CAAC;IAE5E;;;;;;;;OAQG;IACH,aAAa,CAAC,CAAC,IAAI,EAAE,OAAO,EAAE,SAAS,EAAE,cAAc,EAAE,SAAS,EAAE,gBAAgB,GAAG,OAAO,CAAC;IAE/F;;;;;;;OAOG;IACH,eAAe,CAAC,CAAC,UAAU,EAAE,UAAU,EAAE,UAAU,CAAC,EAAE,OAAO,GAAG,SAAS,GAAG,IAAI,CAAC;IAEjF;;;;;;OAMG;IACH,oBAAoB,CAAC,CAAC,UAAU,EAAE,UAAU,GAAG,cAAc,GAAG,IAAI,CAAC;IAErE;;;;;;OAMG;IACH,mBAAmB,CAAC,CAAC,MAAM,EAAE,SAAS,GAAG,cAAc,CAAC;IAExD;;;;;;;OAOG;IACH,UAAU,CAAC,CAAC,UAAU,EAAE,UAAU,EAAE,KAAK,EAAE,OAAO,GAAG,UAAU,GAAG,IAAI,CAAC;IAEvE;;;;;;OAMG;IACH,aAAa,CAAC,CAAC,UAAU,EAAE,UAAU,GAAG,UAAU,CAAC;CACtD"}

package/browser/ecpair.d.ts

@@ -0,0 +1,99 @@
+/**
+ * Ambient module declaration for ecpair.
+ *
+ * The upstream ecpair@3 .d.ts files depend on valibot@^0.37 type-level APIs.
+ * When a different valibot major is hoisted (e.g. v1.x required by bip32),
+ * @typescript-eslint resolves valibot from the project root instead of
+ * ecpair's nested node_modules, turning every ecpair type into an error type.
+ *
+ * This local declaration re-exports the subset of ecpair's public API that
+ * this project actually uses, without any valibot dependency.
+ */
+declare module 'ecpair' {
+    interface Network {
+        messagePrefix: string | Uint8Array;
+        bech32: string;
+        bip32: {
+            public: number;
+            private: number;
+        };
+        pubKeyHash: number;
+        scriptHash: number;
+        wif: number;
+    }
+
+    interface Signer {
+        publicKey: Uint8Array;
+        network?: unknown;
+        sign(hash: Uint8Array, lowR?: boolean): Uint8Array;
+    }
+
+    interface SignerAsync {
+        publicKey: Uint8Array;
+        network?: unknown;
+        sign(hash: Uint8Array, lowR?: boolean): Promise<Uint8Array>;
+    }
+
+    interface ECPairInterface extends Signer {
+        compressed: boolean;
+        network: Network;
+        lowR: boolean;
+        privateKey?: Uint8Array;
+        toWIF(): string;
+        tweak(t: Uint8Array): ECPairInterface;
+        verify(hash: Uint8Array, signature: Uint8Array): boolean;
+        verifySchnorr(hash: Uint8Array, signature: Uint8Array): boolean;
+        signSchnorr(hash: Uint8Array): Uint8Array;
+    }
+
+    interface ECPairOptions {
+        compressed?: boolean;
+        network?: Network;
+        rng?: (arg?: number) => Uint8Array;
+    }
+
+    interface ECPairAPI {
+        isPoint(maybePoint: unknown): boolean;
+        fromPrivateKey(buffer: Uint8Array, options?: ECPairOptions): ECPairInterface;
+        fromPublicKey(buffer: Uint8Array, options?: ECPairOptions): ECPairInterface;
+        fromWIF(wifString: string, network?: Network | Network[]): ECPairInterface;
+        makeRandom(options?: ECPairOptions): ECPairInterface;
+    }
+
+    interface TinySecp256k1Interface {
+        isPoint(p: Uint8Array): boolean;
+        pointCompress(p: Uint8Array, compressed?: boolean): Uint8Array;
+        isPrivate(d: Uint8Array): boolean;
+        pointFromScalar(d: Uint8Array, compressed?: boolean): Uint8Array | null;
+        xOnlyPointAddTweak(
+            p: Uint8Array,
+            tweak: Uint8Array,
+        ): { parity: 1 | 0; xOnlyPubkey: Uint8Array } | null;
+        privateAdd(d: Uint8Array, tweak: Uint8Array): Uint8Array | null;
+        privateNegate(d: Uint8Array): Uint8Array;
+        sign(h: Uint8Array, d: Uint8Array, e?: Uint8Array): Uint8Array;
+        signSchnorr?(h: Uint8Array, d: Uint8Array, e?: Uint8Array): Uint8Array;
+        verify(h: Uint8Array, Q: Uint8Array, signature: Uint8Array, strict?: boolean): boolean;
+        verifySchnorr?(h: Uint8Array, Q: Uint8Array, signature: Uint8Array): boolean;
+    }
+
+    const networks: {
+        bitcoin: Network;
+        testnet: Network;
+    };
+
+    function ECPairFactory(ecc: TinySecp256k1Interface): ECPairAPI;
+    export default ECPairFactory;
+
+    export {
+        ECPairFactory,
+        Signer,
+        SignerAsync,
+        ECPairAPI,
+        ECPairInterface,
+        ECPairOptions,
+        TinySecp256k1Interface,
+        Network,
+        networks,
+    };
+}

package/browser/errors.d.ts

@@ -0,0 +1,124 @@
+/**
+ * Custom error types for the Bitcoin library.
+ * @packageDocumentation
+ */
+/**
+ * Base error class for all Bitcoin-related errors.
+ *
+ * @example
+ * ```typescript
+ * import { BitcoinError } from '@btc-vision/bitcoin';
+ *
+ * if (error instanceof BitcoinError) {
+ *     console.log('Bitcoin library error:', error.message);
+ * }
+ * ```
+ */
+export declare class BitcoinError extends Error {
+    constructor(message: string);
+}
+/**
+ * Error thrown when input validation fails.
+ *
+ * @example
+ * ```typescript
+ * import { ValidationError } from '@btc-vision/bitcoin';
+ *
+ * throw new ValidationError('Invalid public key length');
+ * ```
+ */
+export declare class ValidationError extends BitcoinError {
+    constructor(message: string);
+}
+/**
+ * Error thrown when an invalid input is provided to a transaction.
+ *
+ * @example
+ * ```typescript
+ * import { InvalidInputError } from '@btc-vision/bitcoin';
+ *
+ * throw new InvalidInputError('Input index out of range');
+ * ```
+ */
+export declare class InvalidInputError extends BitcoinError {
+    constructor(message: string);
+}
+/**
+ * Error thrown when an invalid output is provided to a transaction.
+ *
+ * @example
+ * ```typescript
+ * import { InvalidOutputError } from '@btc-vision/bitcoin';
+ *
+ * throw new InvalidOutputError('Output value exceeds maximum');
+ * ```
+ */
+export declare class InvalidOutputError extends BitcoinError {
+    constructor(message: string);
+}
+/**
+ * Error thrown when a script operation fails.
+ *
+ * @example
+ * ```typescript
+ * import { ScriptError } from '@btc-vision/bitcoin';
+ *
+ * throw new ScriptError('Failed to decompile script');
+ * ```
+ */
+export declare class ScriptError extends BitcoinError {
+    constructor(message: string);
+}
+/**
+ * Error thrown when a PSBT operation fails.
+ *
+ * @example
+ * ```typescript
+ * import { PsbtError } from '@btc-vision/bitcoin';
+ *
+ * throw new PsbtError('Cannot finalize unsigned input');
+ * ```
+ */
+export declare class PsbtError extends BitcoinError {
+    constructor(message: string);
+}
+/**
+ * Error thrown when ECC library is not initialized.
+ *
+ * @example
+ * ```typescript
+ * import { EccError } from '@btc-vision/bitcoin';
+ *
+ * throw new EccError('ECC library must be initialized before use');
+ * ```
+ */
+export declare class EccError extends BitcoinError {
+    constructor(message: string);
+}
+/**
+ * Error thrown when address encoding/decoding fails.
+ *
+ * @example
+ * ```typescript
+ * import { AddressError } from '@btc-vision/bitcoin';
+ *
+ * throw new AddressError('Invalid address checksum');
+ * ```
+ */
+export declare class AddressError extends BitcoinError {
+    constructor(message: string);
+}
+/**
+ * Error thrown when signature operations fail.
+ *
+ * @example
+ * ```typescript
+ * import { SignatureError } from '@btc-vision/bitcoin';
+ *
+ * throw new SignatureError('Invalid signature format');
+ * ```
+ */
+export declare class SignatureError extends BitcoinError {
+    constructor(message: string);
+}
+//# sourceMappingURL=errors.d.ts.map

package/browser/errors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../src/errors.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH;;;;;;;;;;;GAWG;AACH,qBAAa,YAAa,SAAQ,KAAK;gBACvB,OAAO,EAAE,MAAM;CAQ9B;AAED;;;;;;;;;GASG;AACH,qBAAa,eAAgB,SAAQ,YAAY;gBACjC,OAAO,EAAE,MAAM;CAI9B;AAED;;;;;;;;;GASG;AACH,qBAAa,iBAAkB,SAAQ,YAAY;gBACnC,OAAO,EAAE,MAAM;CAI9B;AAED;;;;;;;;;GASG;AACH,qBAAa,kBAAmB,SAAQ,YAAY;gBACpC,OAAO,EAAE,MAAM;CAI9B;AAED;;;;;;;;;GASG;AACH,qBAAa,WAAY,SAAQ,YAAY;gBAC7B,OAAO,EAAE,MAAM;CAI9B;AAED;;;;;;;;;GASG;AACH,qBAAa,SAAU,SAAQ,YAAY;gBAC3B,OAAO,EAAE,MAAM;CAI9B;AAED;;;;;;;;;GASG;AACH,qBAAa,QAAS,SAAQ,YAAY;gBAC1B,OAAO,EAAE,MAAM;CAI9B;AAED;;;;;;;;;GASG;AACH,qBAAa,YAAa,SAAQ,YAAY;gBAC9B,OAAO,EAAE,MAAM;CAI9B;AAED;;;;;;;;;GASG;AACH,qBAAa,cAAe,SAAQ,YAAY;gBAChC,OAAO,EAAE,MAAM;CAI9B"}

package/browser/index.d.ts

@@ -1,4 +1,5 @@
-import { PsbtInput as _PsbtInput, PsbtInputUpdate as _PsbtInputUpdate, PsbtOutput as _PsbtOutput, TapBip32Derivation as _TapBip32Derivation, TapInternalKey as _TapInternalKey, TapKeySig as _TapKeySig, TapLeaf as _TapLeaf, TapLeafScript as _TapLeafScript, TapMerkleRoot as _TapMerkleRoot, TapScriptSig as _TapScriptSig, TapTree as _TapTree } from 'bip174/src/lib/interfaces.js';
+import { PsbtInput as _PsbtInput, PsbtInputUpdate as _PsbtInputUpdate, PsbtOutput as _PsbtOutput, TapBip32Derivation as _TapBip32Derivation, TapInternalKey as _TapInternalKey, TapKeySig as _TapKeySig, TapLeaf as _TapLeaf, TapLeafScript as _TapLeafScript, TapMerkleRoot as _TapMerkleRoot, TapScriptSig as _TapScriptSig, TapTree as _TapTree } from 'bip174';
+import { AddressError, BitcoinError, EccError, InvalidInputError, InvalidOutputError, PsbtError, ScriptError, SignatureError, ValidationError } from './errors.js';
 import * as networks from './networks.js';
 import * as address from './address.js';
 import * as payments from './payments/index.js';
@@ -11,12 +12,18 @@ export * as networks from './networks.js';
 export * as payments from './payments/index.js';
 export * as script from './script.js';
 export { Block } from './block.js';
+/** @hidden */
 export * from './crypto.js';
 export * from './psbt.js';
+/** @hidden */
 export { opcodes } from './opcodes.js';
 export { Transaction } from './transaction.js';
+export type { TaprootHashCache } from './transaction.js';
+/** @hidden */
 export type { Network } from './networks.js';
-export { initEccLib } from './ecc_lib.js';
+/** @hidden */
+export { initEccLib, getEccLib, EccContext } from './ecc/context.js';
+export type { EccLib } from './ecc/types.js';
 export { PaymentType } from './payments/index.js';
 export type { Payment, PaymentCreator, PaymentOpts, P2WSHPayment, P2PKPayment, BasePayment, P2SHPayment, P2TRPayment, P2WPKHPayment, P2PKHPayment, P2MSPayment, EmbedPayment, P2OPPayment, P2OPPaymentParams, } from './payments/index.js';
 export type { Stack, StackElement, StackFunction } from './types.js';
@@ -45,12 +52,31 @@ export interface PsbtInputUpdate extends _PsbtInputUpdate {
 }
 export * from './psbt/bip371.js';
 export * from './address.js';
-export * from './bufferutils.js';
+export { toHex, fromHex, isHex, concat, equals, compare, isZero, clone, reverse, reverseCopy, alloc, xor, fromUtf8, toUtf8, MemoryPool, SimpleMemoryPool, varuint, } from './io/index.js';
 export * from './payments/bip341.js';
 export * from './psbt/psbtutils.js';
-export { toXOnly, decompressPublicKey, pubkeysMatch, type UncompressedPublicKey } from './pubkey.js';
+export { toXOnly, decompressPublicKey, pubkeysMatch, type UncompressedPublicKey, } from './pubkey.js';
 export { TAPLEAF_VERSION_MASK } from './types.js';
-export type { Taptree, XOnlyPointAddTweakResult, Tapleaf, TinySecp256k1Interface, } from './types.js';
+export type { Taptree, Tapleaf } from './types.js';
+export type { Bytes32, Bytes20, PublicKey, XOnlyPublicKey, Satoshi, PrivateKey, Signature, SchnorrSignature, Script, } from './types.js';
+export { isPrivateKey, isSchnorrSignature, isSignature, isScript, isBytes32, isBytes20, isPoint, isXOnlyPublicKey, isSatoshi, assertXOnlyPublicKey, assertPrivateKey, toBytes32, toBytes20, toSatoshi, } from './types.js';
+export type { XOnlyPointAddTweakResult } from './ecc/types.js';
+export { BitcoinError, ValidationError, InvalidInputError, InvalidOutputError, ScriptError, PsbtError, EccError, AddressError, SignatureError, };
+/** All error classes grouped as a namespace */
+export declare const errors: {
+    readonly BitcoinError: typeof BitcoinError;
+    readonly ValidationError: typeof ValidationError;
+    readonly InvalidInputError: typeof InvalidInputError;
+    readonly InvalidOutputError: typeof InvalidOutputError;
+    readonly ScriptError: typeof ScriptError;
+    readonly PsbtError: typeof PsbtError;
+    readonly EccError: typeof EccError;
+    readonly AddressError: typeof AddressError;
+    readonly SignatureError: typeof SignatureError;
+};
+export * as workers from './workers/index.js';
+export { WorkerSigningPool, getSigningPool, SignatureType, createSigningPool, signPsbtParallel, } from './workers/index.js';
+export type { WorkerPoolConfig, SigningTask, ParallelSignerKeyPair, ParallelSigningResult, ParallelSignOptions, PsbtParallelKeyPair, } from './workers/index.js';
 declare const bitcoin: {
     networks: typeof networks;
     address: typeof address;
@@ -60,3 +86,4 @@ declare const bitcoin: {
     Transaction: typeof Transaction;
 };
 export default bitcoin;
+//# sourceMappingURL=index.d.ts.map

package/browser/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"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"}