@btc-vision/bitcoin 6.4.10 → 6.5.1

package/src/ecc_lib.ts

@@ -1,94 +1,94 @@
-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.
- * If `eccLib` is a new instance, it will be verified before setting it as the active library.
- *
- * @param eccLib The instance of the ECC library to initialize.
- */
-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!);
-        _ECCLIB_CACHE.eccLib = eccLib;
-    }
-}
-
-/**
- * Retrieves the ECC Library instance.
- * Throws an error if the ECC Library is not provided.
- * You must call initEccLib() with a valid TinySecp256k1Interface instance before calling this function.
- * @returns The ECC Library instance.
- * @throws Error if the ECC Library is not provided.
- */
-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;
-}
-
-const h = (hex: string): Buffer => Buffer.from(hex, 'hex');
-
-/**
- * Verifies the ECC functionality.
- *
- * @param ecc - The TinySecp256k1Interface object.
- */
-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('0000000000000000000000000000000000000000000000000000000000000000')),
-    );
-    assert(
-        !ecc.isXOnlyPoint(h('fffffffffffffffffffffffffffffffffffffffffffffffffffffffefffffc2f')),
-    );
-
-    assert(typeof ecc.xOnlyPointAddTweak === 'function');
-    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)));
-        }
-    });
-}
-
-function assert(bool: boolean): void {
-    if (!bool) throw new Error('ecc library invalid');
-}
-
-const tweakAddVectors = [
-    {
-        pubkey: '79be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798',
-        tweak: 'fffffffffffffffffffffffffffffffebaaedce6af48a03bbfd25e8cd0364140',
-        parity: -1,
-        result: null,
-    },
-    {
-        pubkey: '1617d38ed8d8657da4d4761e8057bc396ea9e4b9d29776d4be096016dbd2509b',
-        tweak: 'a8397a935f0dfceba6ba9618f6451ef4d80637abf4e6af2669fbc9de6a8fd2ac',
-        parity: 1,
-        result: 'e478f99dab91052ab39a33ea35fd5e6e4933f4d28023cd597c9a1f6760346adf',
-    },
-    {
-        pubkey: '2c0b7cf95324a07d05398b240174dc0c2be444d96b159aa6c7f7b1e668680991',
-        tweak: '823c3cd2142744b075a87eade7e1b8678ba308d566226a0056ca2b7a76f86b47',
-        parity: 0,
-        result: '9534f8dc8c6deda2dc007655981c78b49c5d96c778fbf363462a11ec9dfd948c',
-    },
-];
+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.
+ * If `eccLib` is a new instance, it will be verified before setting it as the active library.
+ *
+ * @param eccLib The instance of the ECC library to initialize.
+ */
+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!);
+        _ECCLIB_CACHE.eccLib = eccLib;
+    }
+}
+
+/**
+ * Retrieves the ECC Library instance.
+ * Throws an error if the ECC Library is not provided.
+ * You must call initEccLib() with a valid TinySecp256k1Interface instance before calling this function.
+ * @returns The ECC Library instance.
+ * @throws Error if the ECC Library is not provided.
+ */
+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;
+}
+
+const h = (hex: string): Buffer => Buffer.from(hex, 'hex');
+
+/**
+ * Verifies the ECC functionality.
+ *
+ * @param ecc - The TinySecp256k1Interface object.
+ */
+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('0000000000000000000000000000000000000000000000000000000000000000')),
+    );
+    assert(
+        !ecc.isXOnlyPoint(h('fffffffffffffffffffffffffffffffffffffffffffffffffffffffefffffc2f')),
+    );
+
+    assert(typeof ecc.xOnlyPointAddTweak === 'function');
+    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)));
+        }
+    });
+}
+
+function assert(bool: boolean): void {
+    if (!bool) throw new Error('ecc library invalid');
+}
+
+const tweakAddVectors = [
+    {
+        pubkey: '79be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798',
+        tweak: 'fffffffffffffffffffffffffffffffebaaedce6af48a03bbfd25e8cd0364140',
+        parity: -1,
+        result: null,
+    },
+    {
+        pubkey: '1617d38ed8d8657da4d4761e8057bc396ea9e4b9d29776d4be096016dbd2509b',
+        tweak: 'a8397a935f0dfceba6ba9618f6451ef4d80637abf4e6af2669fbc9de6a8fd2ac',
+        parity: 1,
+        result: 'e478f99dab91052ab39a33ea35fd5e6e4933f4d28023cd597c9a1f6760346adf',
+    },
+    {
+        pubkey: '2c0b7cf95324a07d05398b240174dc0c2be444d96b159aa6c7f7b1e668680991',
+        tweak: '823c3cd2142744b075a87eade7e1b8678ba308d566226a0056ca2b7a76f86b47',
+        parity: 0,
+        result: '9534f8dc8c6deda2dc007655981c78b49c5d96c778fbf363462a11ec9dfd948c',
+    },
+];

package/src/hooks/AdvancedSignatureManager.ts

@@ -1,104 +1,104 @@
-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
-     */
-    private cacheBySigner: Map<string, Set<CacheEntry>> = new Map();
-
-    /**
-     * FinalizationRegistry to clean up cache entries when their data buffers are garbage collected.
-     */
-    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);
-                }
-            }
-        });
-    }
-
-    // Singleton instance accessor
-    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.
-     */
-    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<CacheEntry>());
-        }
-
-        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.
-     */
-    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)) {
-                return entry.signature;
-            }
-        }
-        return undefined;
-    }
-
-    /**
-     * Use with caution as it removes all cached signatures for all signers.
-     */
-    public clearCache(): void {
-        this.cacheBySigner.clear();
-    }
-
-    /**
-     * Clears the cache for a specific signer.
-     * @param pubKey The signer's public key.
-     */
-    public clearCacheForSigner(pubKey: string): void {
-        this.cacheBySigner.delete(pubKey);
-    }
-}
+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
+     */
+    private cacheBySigner: Map<string, Set<CacheEntry>> = new Map();
+
+    /**
+     * FinalizationRegistry to clean up cache entries when their data buffers are garbage collected.
+     */
+    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);
+                }
+            }
+        });
+    }
+
+    // Singleton instance accessor
+    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.
+     */
+    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<CacheEntry>());
+        }
+
+        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.
+     */
+    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)) {
+                return entry.signature;
+            }
+        }
+        return undefined;
+    }
+
+    /**
+     * Use with caution as it removes all cached signatures for all signers.
+     */
+    public clearCache(): void {
+        this.cacheBySigner.clear();
+    }
+
+    /**
+     * Clears the cache for a specific signer.
+     * @param pubKey The signer's public key.
+     */
+    public clearCacheForSigner(pubKey: string): void {
+        this.cacheBySigner.delete(pubKey);
+    }
+}

package/src/hooks/SignatureManager.ts

@@ -1,84 +1,84 @@
-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
-     */
-    private cacheByLength: Map<number, Set<CacheEntry>> = new Map();
-
-    /**
-     * FinalizationRegistry to clean up cache entries when their data buffers are garbage collected.
-     */
-    private registry: FinalizationRegistry<CacheEntry>;
-
-    constructor() {
-        this.registry = new FinalizationRegistry((entry: CacheEntry) => {
-            const set = this.cacheByLength.get(entry.length);
-            if (set) {
-                set.delete(entry);
-                // Clean up the set if it's empty
-                if (set.size === 0) {
-                    this.cacheByLength.delete(entry.length);
-                }
-            }
-        });
-    }
-
-    /**
-     * Adds (caches) the signature for the given data buffer.
-     * @param data The data buffer.
-     * @param signature The signature buffer.
-     */
-    public addSignature(data: Buffer, signature: Buffer): Buffer {
-        const length = data.length;
-        const entry: CacheEntry = {
-            length,
-            dataRef: new WeakRef(data),
-            signature,
-        };
-
-        if (!this.cacheByLength.has(length)) {
-            this.cacheByLength.set(length, new Set<CacheEntry>());
-        }
-
-        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.
-     */
-    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)) {
-                return entry.signature;
-            }
-        }
-        return undefined;
-    }
-
-    /**
-     * Use with caution as it removes all cached signatures.
-     */
-    public clearCache(): void {
-        this.cacheByLength.clear();
-    }
-}
+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
+     */
+    private cacheByLength: Map<number, Set<CacheEntry>> = new Map();
+
+    /**
+     * FinalizationRegistry to clean up cache entries when their data buffers are garbage collected.
+     */
+    private registry: FinalizationRegistry<CacheEntry>;
+
+    constructor() {
+        this.registry = new FinalizationRegistry((entry: CacheEntry) => {
+            const set = this.cacheByLength.get(entry.length);
+            if (set) {
+                set.delete(entry);
+                // Clean up the set if it's empty
+                if (set.size === 0) {
+                    this.cacheByLength.delete(entry.length);
+                }
+            }
+        });
+    }
+
+    /**
+     * Adds (caches) the signature for the given data buffer.
+     * @param data The data buffer.
+     * @param signature The signature buffer.
+     */
+    public addSignature(data: Buffer, signature: Buffer): Buffer {
+        const length = data.length;
+        const entry: CacheEntry = {
+            length,
+            dataRef: new WeakRef(data),
+            signature,
+        };
+
+        if (!this.cacheByLength.has(length)) {
+            this.cacheByLength.set(length, new Set<CacheEntry>());
+        }
+
+        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.
+     */
+    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)) {
+                return entry.signature;
+            }
+        }
+        return undefined;
+    }
+
+    /**
+     * Use with caution as it removes all cached signatures.
+     */
+    public clearCache(): void {
+        this.cacheByLength.clear();
+    }
+}