@btc-vision/bitcoin 6.3.0 → 6.3.2

package/src/crypto.ts

@@ -0,0 +1,108 @@
+/**
+ * A module for hashing functions.
+ * include ripemd160、sha1、sha256、hash160、hash256、taggedHash
+ *
+ * @packageDocumentation
+ */
+import { ripemd160 as _ripemd160 } from '@noble/hashes/ripemd160';
+import { sha1 as _sha1 } from '@noble/hashes/sha1';
+import { sha256 as _sha256 } from '@noble/hashes/sha256';
+
+export function ripemd160(buffer: Buffer): Buffer {
+    return Buffer.from(_ripemd160(Uint8Array.from(buffer)));
+}
+
+export function sha1(buffer: Buffer): Buffer {
+    return Buffer.from(_sha1(Uint8Array.from(buffer)));
+}
+
+export function sha256(buffer: Buffer): Buffer {
+    return Buffer.from(_sha256(Uint8Array.from(buffer)));
+}
+
+export function hash160(buffer: Buffer): Buffer {
+    return Buffer.from(_ripemd160(_sha256(Uint8Array.from(buffer))));
+}
+
+export function hash256(buffer: Buffer): Buffer {
+    return Buffer.from(_sha256(_sha256(Uint8Array.from(buffer))));
+}
+
+export const TAGS = [
+    'BIP0340/challenge',
+    'BIP0340/aux',
+    'BIP0340/nonce',
+    'TapLeaf',
+    'TapBranch',
+    'TapSighash',
+    'TapTweak',
+    'KeyAgg list',
+    'KeyAgg coefficient',
+] as const;
+export type TaggedHashPrefix = typeof TAGS[number];
+type TaggedHashPrefixes = {
+    [key in TaggedHashPrefix]: Buffer;
+};
+/** An object mapping tags to their tagged hash prefix of [SHA256(tag) | SHA256(tag)] */
+/**
+ * Defines the tagged hash prefixes used in the crypto module.
+ */
+export const TAGGED_HASH_PREFIXES: TaggedHashPrefixes = {
+    'BIP0340/challenge': Buffer.from([
+        123, 181, 45, 122, 159, 239, 88, 50, 62, 177, 191, 122, 64, 125, 179, 130, 210, 243, 242,
+        216, 27, 177, 34, 79, 73, 254, 81, 143, 109, 72, 211, 124, 123, 181, 45, 122, 159, 239, 88,
+        50, 62, 177, 191, 122, 64, 125, 179, 130, 210, 243, 242, 216, 27, 177, 34, 79, 73, 254, 81,
+        143, 109, 72, 211, 124,
+    ]),
+    'BIP0340/aux': Buffer.from([
+        241, 239, 78, 94, 192, 99, 202, 218, 109, 148, 202, 250, 157, 152, 126, 160, 105, 38, 88,
+        57, 236, 193, 31, 151, 45, 119, 165, 46, 216, 193, 204, 144, 241, 239, 78, 94, 192, 99, 202,
+        218, 109, 148, 202, 250, 157, 152, 126, 160, 105, 38, 88, 57, 236, 193, 31, 151, 45, 119,
+        165, 46, 216, 193, 204, 144,
+    ]),
+    'BIP0340/nonce': Buffer.from([
+        7, 73, 119, 52, 167, 155, 203, 53, 91, 155, 140, 125, 3, 79, 18, 28, 244, 52, 215, 62, 247,
+        45, 218, 25, 135, 0, 97, 251, 82, 191, 235, 47, 7, 73, 119, 52, 167, 155, 203, 53, 91, 155,
+        140, 125, 3, 79, 18, 28, 244, 52, 215, 62, 247, 45, 218, 25, 135, 0, 97, 251, 82, 191, 235,
+        47,
+    ]),
+    TapLeaf: Buffer.from([
+        174, 234, 143, 220, 66, 8, 152, 49, 5, 115, 75, 88, 8, 29, 30, 38, 56, 211, 95, 28, 181, 64,
+        8, 212, 211, 87, 202, 3, 190, 120, 233, 238, 174, 234, 143, 220, 66, 8, 152, 49, 5, 115, 75,
+        88, 8, 29, 30, 38, 56, 211, 95, 28, 181, 64, 8, 212, 211, 87, 202, 3, 190, 120, 233, 238,
+    ]),
+    TapBranch: Buffer.from([
+        25, 65, 161, 242, 229, 110, 185, 95, 162, 169, 241, 148, 190, 92, 1, 247, 33, 111, 51, 237,
+        130, 176, 145, 70, 52, 144, 208, 91, 245, 22, 160, 21, 25, 65, 161, 242, 229, 110, 185, 95,
+        162, 169, 241, 148, 190, 92, 1, 247, 33, 111, 51, 237, 130, 176, 145, 70, 52, 144, 208, 91,
+        245, 22, 160, 21,
+    ]),
+    TapSighash: Buffer.from([
+        244, 10, 72, 223, 75, 42, 112, 200, 180, 146, 75, 242, 101, 70, 97, 237, 61, 149, 253, 102,
+        163, 19, 235, 135, 35, 117, 151, 198, 40, 228, 160, 49, 244, 10, 72, 223, 75, 42, 112, 200,
+        180, 146, 75, 242, 101, 70, 97, 237, 61, 149, 253, 102, 163, 19, 235, 135, 35, 117, 151,
+        198, 40, 228, 160, 49,
+    ]),
+    TapTweak: Buffer.from([
+        232, 15, 225, 99, 156, 156, 160, 80, 227, 175, 27, 57, 193, 67, 198, 62, 66, 156, 188, 235,
+        21, 217, 64, 251, 181, 197, 161, 244, 175, 87, 197, 233, 232, 15, 225, 99, 156, 156, 160,
+        80, 227, 175, 27, 57, 193, 67, 198, 62, 66, 156, 188, 235, 21, 217, 64, 251, 181, 197, 161,
+        244, 175, 87, 197, 233,
+    ]),
+    'KeyAgg list': Buffer.from([
+        72, 28, 151, 28, 60, 11, 70, 215, 240, 178, 117, 174, 89, 141, 78, 44, 126, 215, 49, 156,
+        89, 74, 92, 110, 199, 158, 160, 212, 153, 2, 148, 240, 72, 28, 151, 28, 60, 11, 70, 215,
+        240, 178, 117, 174, 89, 141, 78, 44, 126, 215, 49, 156, 89, 74, 92, 110, 199, 158, 160, 212,
+        153, 2, 148, 240,
+    ]),
+    'KeyAgg coefficient': Buffer.from([
+        191, 201, 4, 3, 77, 28, 136, 232, 200, 14, 34, 229, 61, 36, 86, 109, 100, 130, 78, 214, 66,
+        114, 129, 192, 145, 0, 249, 77, 205, 82, 201, 129, 191, 201, 4, 3, 77, 28, 136, 232, 200,
+        14, 34, 229, 61, 36, 86, 109, 100, 130, 78, 214, 66, 114, 129, 192, 145, 0, 249, 77, 205,
+        82, 201, 129,
+    ]),
+};
+
+export function taggedHash(prefix: TaggedHashPrefix, data: Buffer): Buffer {
+    return sha256(Buffer.concat([TAGGED_HASH_PREFIXES[prefix], data]));
+}

package/src/{ecc_lib.js → ecc_lib.ts}

@@ -1,7 +1,7 @@
-'use strict';
-Object.defineProperty(exports, '__esModule', { value: true });
-exports.getEccLib = exports.initEccLib = void 0;
-const _ECCLIB_CACHE = {};
+import { TinySecp256k1Interface } from './types.js';
+
+const _ECCLIB_CACHE: { eccLib?: TinySecp256k1Interface } = {};
+
 /**
  * Initializes the ECC library with the provided instance.
  * If `eccLib` is `undefined`, the library will be cleared.
@@ -9,17 +9,17 @@ const _ECCLIB_CACHE = {};
  *
  * @param eccLib The instance of the ECC library to initialize.
  */
-function initEccLib(eccLib) {
+export function initEccLib(eccLib: TinySecp256k1Interface | undefined): void {
     if (!eccLib) {
         // allow clearing the library
         _ECCLIB_CACHE.eccLib = eccLib;
     } else if (eccLib !== _ECCLIB_CACHE.eccLib) {
         // new instance, verify it
-        verifyEcc(eccLib);
+        verifyEcc(eccLib!);
         _ECCLIB_CACHE.eccLib = eccLib;
     }
 }
-exports.initEccLib = initEccLib;
+
 /**
  * Retrieves the ECC Library instance.
  * Throws an error if the ECC Library is not provided.
@@ -27,79 +27,51 @@ exports.initEccLib = initEccLib;
  * @returns The ECC Library instance.
  * @throws Error if the ECC Library is not provided.
  */
-function getEccLib() {
+export function getEccLib(): TinySecp256k1Interface {
     if (!_ECCLIB_CACHE.eccLib)
         throw new Error(
             'No ECC Library provided. You must call initEccLib() with a valid TinySecp256k1Interface instance',
         );
     return _ECCLIB_CACHE.eccLib;
 }
-exports.getEccLib = getEccLib;
-const h = hex => Buffer.from(hex, 'hex');
+
+const h = (hex: string): Buffer => Buffer.from(hex, 'hex');
+
 /**
  * Verifies the ECC functionality.
  *
  * @param ecc - The TinySecp256k1Interface object.
  */
-function verifyEcc(ecc) {
+function verifyEcc(ecc: TinySecp256k1Interface): void {
     assert(typeof ecc.isXOnlyPoint === 'function');
+    assert(ecc.isXOnlyPoint(h('79be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798')));
+    assert(ecc.isXOnlyPoint(h('fffffffffffffffffffffffffffffffffffffffffffffffffffffffeeffffc2e')));
+    assert(ecc.isXOnlyPoint(h('f9308a019258c31049344f85f89d5229b531c845836f99b08601f113bce036f9')));
+    assert(ecc.isXOnlyPoint(h('0000000000000000000000000000000000000000000000000000000000000001')));
     assert(
-        ecc.isXOnlyPoint(
-            h(
-                '79be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798',
-            ),
-        ),
+        !ecc.isXOnlyPoint(h('0000000000000000000000000000000000000000000000000000000000000000')),
     );
     assert(
-        ecc.isXOnlyPoint(
-            h(
-                'fffffffffffffffffffffffffffffffffffffffffffffffffffffffeeffffc2e',
-            ),
-        ),
-    );
-    assert(
-        ecc.isXOnlyPoint(
-            h(
-                'f9308a019258c31049344f85f89d5229b531c845836f99b08601f113bce036f9',
-            ),
-        ),
-    );
-    assert(
-        ecc.isXOnlyPoint(
-            h(
-                '0000000000000000000000000000000000000000000000000000000000000001',
-            ),
-        ),
-    );
-    assert(
-        !ecc.isXOnlyPoint(
-            h(
-                '0000000000000000000000000000000000000000000000000000000000000000',
-            ),
-        ),
-    );
-    assert(
-        !ecc.isXOnlyPoint(
-            h(
-                'fffffffffffffffffffffffffffffffffffffffffffffffffffffffefffffc2f',
-            ),
-        ),
+        !ecc.isXOnlyPoint(h('fffffffffffffffffffffffffffffffffffffffffffffffffffffffefffffc2f')),
     );
+
     assert(typeof ecc.xOnlyPointAddTweak === 'function');
-    tweakAddVectors.forEach(t => {
+    tweakAddVectors.forEach((t) => {
         const r = ecc.xOnlyPointAddTweak(h(t.pubkey), h(t.tweak));
         if (t.result === null) {
             assert(r === null);
         } else {
             assert(r !== null);
-            assert(r.parity === t.parity);
-            assert(Buffer.from(r.xOnlyPubkey).equals(h(t.result)));
+            assert(r!.parity === t.parity);
+            assert(Buffer.from(r!.xOnlyPubkey).equals(h(t.result)));
         }
     });
 }
-function assert(bool) {
+
+function assert(bool: boolean): void {
     if (!bool) throw new Error('ecc library invalid');
 }
+
 const tweakAddVectors = [
     {
         pubkey: '79be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798',

package/src/hooks/{AdvancedSignatureManager.js → AdvancedSignatureManager.ts}

@@ -1,24 +1,31 @@
-'use strict';
-Object.defineProperty(exports, '__esModule', { value: true });
-exports.AdvancedSignatureManager = void 0;
-class AdvancedSignatureManager {
-    static instance;
+export interface CacheEntry {
+    pubKey: string;
+    dataRef: WeakRef<Buffer>;
+    signature: Buffer;
+}
+
+export class AdvancedSignatureManager {
+    private static instance: AdvancedSignatureManager;
+
     /**
      * Map to index cache entries by signer public key.
      * Key: Public Key (string)
      * Value: Set of CacheEntries
      */
-    cacheBySigner = new Map();
+    private cacheBySigner: Map<string, Set<CacheEntry>> = new Map();
+
     /**
      * FinalizationRegistry to clean up cache entries when their data buffers are garbage collected.
      */
-    registry;
-    constructor() {
-        this.registry = new FinalizationRegistry(entry => {
+    private registry: FinalizationRegistry<CacheEntry>;
+
+    private constructor() {
+        this.registry = new FinalizationRegistry((entry: CacheEntry) => {
             // Remove the entry directly using its pubKey
             const set = this.cacheBySigner.get(entry.pubKey);
             if (set) {
                 set.delete(entry);
+
                 // Clean up the set if it's empty
                 if (set.size === 0) {
                     this.cacheBySigner.delete(entry.pubKey);
@@ -26,43 +33,51 @@ class AdvancedSignatureManager {
             }
         });
     }
+
     // Singleton instance accessor
-    static getInstance() {
+    public static getInstance(): AdvancedSignatureManager {
         if (!AdvancedSignatureManager.instance) {
             AdvancedSignatureManager.instance = new AdvancedSignatureManager();
         }
         return AdvancedSignatureManager.instance;
     }
+
     /**
      * Adds (caches) the signature for the given data buffer and signer public key.
      * @param pubKey The signer's public key.
      * @param data The data buffer.
      * @param signature The signature buffer.
      */
-    addSignature(pubKey, data, signature) {
-        const entry = {
+    public addSignature(pubKey: string, data: Buffer, signature: Buffer): Buffer {
+        const entry: CacheEntry = {
             pubKey,
             dataRef: new WeakRef(data),
             signature,
         };
+
         if (!this.cacheBySigner.has(pubKey)) {
-            this.cacheBySigner.set(pubKey, new Set());
+            this.cacheBySigner.set(pubKey, new Set<CacheEntry>());
         }
-        const set = this.cacheBySigner.get(pubKey);
+
+        const set = this.cacheBySigner.get(pubKey)!;
         set.add(entry);
+
         // Register the data buffer with the FinalizationRegistry.
         this.registry.register(data, entry);
+
         return signature;
     }
+
     /**
      * Retrieves the signature for the given data buffer and signer public key.
      * @param pubKey The signer's public key.
      * @param data The data buffer.
      * @returns The signature buffer if found; otherwise, undefined.
      */
-    getSignature(pubKey, data) {
+    public getSignature(pubKey: string, data: Buffer): Buffer | undefined {
         const set = this.cacheBySigner.get(pubKey);
         if (!set) return undefined;
+
         for (const entry of set) {
             const cachedData = entry.dataRef.deref();
             if (cachedData && cachedData.equals(data)) {
@@ -71,18 +86,19 @@ class AdvancedSignatureManager {
         }
         return undefined;
     }
+
     /**
      * Use with caution as it removes all cached signatures for all signers.
      */
-    clearCache() {
+    public clearCache(): void {
         this.cacheBySigner.clear();
     }
+
     /**
      * Clears the cache for a specific signer.
      * @param pubKey The signer's public key.
      */
-    clearCacheForSigner(pubKey) {
+    public clearCacheForSigner(pubKey: string): void {
         this.cacheBySigner.delete(pubKey);
     }
 }
-exports.AdvancedSignatureManager = AdvancedSignatureManager;

package/src/hooks/HookedSigner.ts

@@ -0,0 +1,108 @@
+import { BIP32Interface } from 'bip32';
+import { ECPairInterface } from 'ecpair';
+import { Signer, SignerAlternative, SignerAsync } from '../psbt.js';
+
+import { SignatureManager } from './SignatureManager.js';
+import { AdvancedSignatureManager } from './AdvancedSignatureManager.js';
+
+interface HookSigner {
+    hasHook?: boolean;
+    signatureManager: SignatureManager;
+}
+
+type HookedSigner = (Signer | SignerAlternative | SignerAsync | BIP32Interface | ECPairInterface) &
+    HookSigner;
+
+const advancedSignatureManager: AdvancedSignatureManager = AdvancedSignatureManager.getInstance();
+
+function getPublicKey(keyPair: HookedSigner): string | undefined {
+    if (keyPair.publicKey && Buffer.isBuffer(keyPair.publicKey)) {
+        return keyPair.publicKey.toString('hex');
+    }
+}
+
+function hookKeyPair(keyPair: HookedSigner) {
+    const oldSign = keyPair.sign;
+
+    if (oldSign) {
+        keyPair.sign = new Proxy(oldSign, {
+            apply: function (target, thisArg, argumentsList) {
+                const publicKey = getPublicKey(keyPair);
+                const hash = argumentsList[0];
+
+                if (publicKey) {
+                    let possibleSignature = advancedSignatureManager.getSignature(publicKey, hash);
+
+                    if (!possibleSignature) {
+                        possibleSignature = advancedSignatureManager.addSignature(
+                            publicKey,
+                            hash,
+                            Reflect.apply(target, thisArg, argumentsList),
+                        );
+                    }
+
+                    return possibleSignature;
+                } else {
+                    let possibleSignature = keyPair.signatureManager.getSignature(hash);
+
+                    if (!possibleSignature) {
+                        possibleSignature = keyPair.signatureManager.addSignature(
+                            hash,
+                            Reflect.apply(target, thisArg, argumentsList),
+                        );
+                    }
+
+                    return possibleSignature;
+                }
+            },
+        });
+    }
+
+    const oldSignSchnorr = keyPair.signSchnorr;
+    if (oldSignSchnorr) {
+        keyPair.signSchnorr = new Proxy(oldSignSchnorr, {
+            apply: function (target, thisArg, argumentsList) {
+                const publicKey = getPublicKey(keyPair);
+                const hash = argumentsList[0];
+
+                if (publicKey) {
+                    let possibleSignature = advancedSignatureManager.getSignature(publicKey, hash);
+
+                    if (!possibleSignature) {
+                        possibleSignature = advancedSignatureManager.addSignature(
+                            publicKey,
+                            hash,
+                            Reflect.apply(target, thisArg, argumentsList),
+                        );
+                    }
+
+                    return possibleSignature;
+                } else {
+                    let possibleSignature = keyPair.signatureManager.getSignature(hash);
+
+                    if (!possibleSignature) {
+                        possibleSignature = keyPair.signatureManager.addSignature(
+                            hash,
+                            Reflect.apply(target, thisArg, argumentsList),
+                        );
+                    }
+
+                    return possibleSignature;
+                }
+            },
+        });
+    }
+}
+
+export function hookSigner(
+    keyPair: Signer | SignerAlternative | SignerAsync | BIP32Interface | ECPairInterface,
+) {
+    const newKeypair: HookedSigner = keyPair as HookedSigner;
+
+    if (!newKeypair.hasHook) {
+        newKeypair.hasHook = true;
+        newKeypair.signatureManager = new SignatureManager();
+
+        hookKeyPair(newKeypair);
+    }
+}

package/src/hooks/{SignatureManager.js → SignatureManager.ts}

@@ -1,19 +1,24 @@
-'use strict';
-Object.defineProperty(exports, '__esModule', { value: true });
-exports.SignatureManager = void 0;
-class SignatureManager {
+export interface CacheEntry {
+    length: number;
+    dataRef: WeakRef<Buffer>;
+    signature: Buffer;
+}
+
+export class SignatureManager {
     /**
      * Map to index cache entries by buffer length.
      * Key: Buffer length
      * Value: Set of CacheEntries with that buffer length
      */
-    cacheByLength = new Map();
+    private cacheByLength: Map<number, Set<CacheEntry>> = new Map();
+
     /**
      * FinalizationRegistry to clean up cache entries when their data buffers are garbage collected.
      */
-    registry;
+    private registry: FinalizationRegistry<CacheEntry>;
+
     constructor() {
-        this.registry = new FinalizationRegistry(entry => {
+        this.registry = new FinalizationRegistry((entry: CacheEntry) => {
             const set = this.cacheByLength.get(entry.length);
             if (set) {
                 set.delete(entry);
@@ -24,36 +29,43 @@ class SignatureManager {
             }
         });
     }
+
     /**
      * Adds (caches) the signature for the given data buffer.
      * @param data The data buffer.
      * @param signature The signature buffer.
      */
-    addSignature(data, signature) {
+    public addSignature(data: Buffer, signature: Buffer): Buffer {
         const length = data.length;
-        const entry = {
+        const entry: CacheEntry = {
             length,
             dataRef: new WeakRef(data),
             signature,
         };
+
         if (!this.cacheByLength.has(length)) {
-            this.cacheByLength.set(length, new Set());
+            this.cacheByLength.set(length, new Set<CacheEntry>());
         }
-        const set = this.cacheByLength.get(length);
+
+        const set = this.cacheByLength.get(length)!;
         set.add(entry);
+
         // Register the data buffer with the FinalizationRegistry.
         this.registry.register(data, entry);
+
         return signature;
     }
+
     /**
      * Retrieves the signature for the given data buffer.
      * @param data The data buffer.
      * @returns The signature buffer if found; otherwise, undefined.
      */
-    getSignature(data) {
+    public getSignature(data: Buffer): Buffer | undefined {
         const length = data.length;
         const set = this.cacheByLength.get(length);
         if (!set) return undefined;
+
         for (const entry of set) {
             const cachedData = entry.dataRef.deref();
             if (cachedData && cachedData.equals(data)) {
@@ -62,11 +74,11 @@ class SignatureManager {
         }
         return undefined;
     }
+
     /**
      * Use with caution as it removes all cached signatures.
      */
-    clearCache() {
+    public clearCache(): void {
         this.cacheByLength.clear();
     }
 }
-exports.SignatureManager = SignatureManager;

package/src/index.ts

@@ -0,0 +1,86 @@
+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 * as networks from './networks.js';
+import * as address from './address.js';
+import * as payments from './payments/index.js';
+import * as script from './script.js';
+import * as crypto from './crypto.js';
+import * as Transaction from './transaction.js';
+
+export * as address from './address.js';
+export * as crypto from './crypto.js';
+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 { OPS as opcodes } from './ops.js';
+export { Transaction } from './transaction.js';
+/** @hidden */
+export { Network } from './networks.js';
+/** @hidden */
+export { initEccLib } from './ecc_lib.js';
+export { Payment, PaymentCreator, PaymentOpts, Stack, StackElement } from './payments/index.js';
+export { Input as TxInput, Output as TxOutput } from './transaction.js';
+
+export interface PsbtInput extends _PsbtInput {}
+
+export interface PsbtOutput extends _PsbtOutput {}
+
+export interface TapInternalKey extends _TapInternalKey {}
+
+export interface TapLeaf extends _TapLeaf {}
+
+export interface TapScriptSig extends _TapScriptSig {}
+
+export interface TapKeySig extends _TapKeySig {}
+
+export interface TapTree extends _TapTree {}
+
+export interface TapMerkleRoot extends _TapMerkleRoot {}
+
+export interface TapLeafScript extends _TapLeafScript {}
+
+export interface TapBip32Derivation extends _TapBip32Derivation {}
+
+export interface PsbtInputUpdate extends _PsbtInputUpdate {}
+
+export * from './psbt/bip371.js';
+export * from './address.js';
+export * from './bufferutils.js';
+export * from './payments/bip341.js';
+export * from './psbt/psbtutils.js';
+
+export {
+    Taptree,
+    XOnlyPointAddTweakResult,
+    Tapleaf,
+    TinySecp256k1Interface,
+    TAPLEAF_VERSION_MASK,
+} from './types.js';
+
+const bitcoin = {
+    networks,
+    address,
+    payments,
+    script,
+    crypto,
+    Transaction,
+};
+
+export default bitcoin;

package/src/{merkle.js → merkle.ts}

@@ -1,6 +1,3 @@
-'use strict';
-Object.defineProperty(exports, '__esModule', { value: true });
-exports.fastMerkleRoot = void 0;
 /**
  * Calculates the Merkle root of an array of buffers using a specified digest function.
  *
@@ -9,22 +6,26 @@ exports.fastMerkleRoot = void 0;
  * @returns The Merkle root as a buffer.
  * @throws {TypeError} If the values parameter is not an array or the digestFn parameter is not a function.
  */
-function fastMerkleRoot(values, digestFn) {
+export function fastMerkleRoot(values: Buffer[], digestFn: (b: Buffer) => Buffer): Buffer {
     if (!Array.isArray(values)) throw TypeError('Expected values Array');
-    if (typeof digestFn !== 'function')
-        throw TypeError('Expected digest Function');
+    if (typeof digestFn !== 'function') throw TypeError('Expected digest Function');
+
     let length = values.length;
     const results = values.concat();
+
     while (length > 1) {
         let j = 0;
+
         for (let i = 0; i < length; i += 2, ++j) {
             const left = results[i];
             const right = i + 1 === length ? left : results[i + 1];
             const data = Buffer.concat([left, right]);
+
             results[j] = digestFn(data);
         }
+
         length = j;
     }
+
     return results[0];
 }
-exports.fastMerkleRoot = fastMerkleRoot;