@btc-vision/bitcoin 6.3.0 → 6.3.2

package/test/tsconfig.json

@@ -0,0 +1,45 @@
+{
+    "compilerOptions": {
+        "target": "ESNext",
+        "module": "commonjs",
+        "outDir": "../",
+        "declaration": false,
+        "rootDir": "../",
+        "rootDirs": [
+            "../src",
+            "../types"
+        ],
+        "types": [
+            "node",
+            "mocha"
+        ],
+        "lib": [
+            "ES2021"
+        ],
+        "allowJs": false,
+        "resolveJsonModule": true,
+        "strict": true,
+        "noImplicitAny": true,
+        "strictNullChecks": true,
+        "strictFunctionTypes": true,
+        "strictBindCallApply": true,
+        "strictPropertyInitialization": true,
+        "noImplicitThis": true,
+        "alwaysStrict": true,
+        "esModuleInterop": false,
+        "noUnusedLocals": true,
+        "noUnusedParameters": true,
+        "baseUrl": ".",
+        "paths": {
+            "../src/*": [
+                "../ts_src/*"
+            ]
+        }
+    },
+    "include": [
+        "./**/*.ts"
+    ],
+    "exclude": [
+        "../ts_src/**/*.ts"
+    ]
+}

package/test/types.spec.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const assert = require("assert");
+const mocha_1 = require("mocha");
+const types = require("../src/types");
+const typeforce = require('typeforce');
+(0, mocha_1.describe)('types', () => {
+    (0, mocha_1.describe)('Buffer Hash160/Hash256', () => {
+        const buffer20byte = Buffer.alloc(20);
+        const buffer32byte = Buffer.alloc(32);
+        (0, mocha_1.it)('return true for valid size', () => {
+            assert(types.Hash160bit(buffer20byte));
+            assert(types.Hash256bit(buffer32byte));
+        });
+        (0, mocha_1.it)('return true for oneOf', () => {
+            assert.doesNotThrow(() => {
+                typeforce(types.oneOf(types.Hash160bit, types.Hash256bit), buffer32byte);
+            });
+            assert.doesNotThrow(() => {
+                typeforce(types.oneOf(types.Hash256bit, types.Hash160bit), buffer32byte);
+            });
+        });
+        (0, mocha_1.it)('throws for invalid size', () => {
+            assert.throws(() => {
+                types.Hash160bit(buffer32byte);
+            }, /Expected Buffer\(Length: 20\), got Buffer\(Length: 32\)/);
+            assert.throws(() => {
+                types.Hash256bit(buffer20byte);
+            }, /Expected Buffer\(Length: 32\), got Buffer\(Length: 20\)/);
+        });
+    });
+    (0, mocha_1.describe)('Satoshi', () => {
+        [
+            { value: -1, result: false },
+            { value: 0, result: true },
+            { value: 1, result: true },
+            { value: 20999999 * 1e8, result: true },
+            { value: 21000000 * 1e8, result: true },
+            { value: 21000001 * 1e8, result: false },
+        ].forEach(f => {
+            (0, mocha_1.it)('returns ' + f.result + ' for valid for ' + f.value, () => {
+                assert.strictEqual(types.Satoshi(f.value), f.result);
+            });
+        });
+    });
+});

package/test/types.spec.ts

@@ -0,0 +1,58 @@
+import * as assert from 'assert';
+import { describe, it } from 'mocha';
+import * as types from '../src/types';
+
+const typeforce = require('typeforce');
+
+describe('types', () => {
+    describe('Buffer Hash160/Hash256', () => {
+        const buffer20byte = Buffer.alloc(20);
+        const buffer32byte = Buffer.alloc(32);
+
+        it('return true for valid size', () => {
+            assert(types.Hash160bit(buffer20byte));
+            assert(types.Hash256bit(buffer32byte));
+        });
+
+        it('return true for oneOf', () => {
+            assert.doesNotThrow(() => {
+                typeforce(
+                    types.oneOf(types.Hash160bit, types.Hash256bit),
+                    buffer32byte,
+                );
+            });
+
+            assert.doesNotThrow(() => {
+                typeforce(
+                    types.oneOf(types.Hash256bit, types.Hash160bit),
+                    buffer32byte,
+                );
+            });
+        });
+
+        it('throws for invalid size', () => {
+            assert.throws(() => {
+                types.Hash160bit(buffer32byte);
+            }, /Expected Buffer\(Length: 20\), got Buffer\(Length: 32\)/);
+
+            assert.throws(() => {
+                types.Hash256bit(buffer20byte);
+            }, /Expected Buffer\(Length: 32\), got Buffer\(Length: 20\)/);
+        });
+    });
+
+    describe('Satoshi', () => {
+        [
+            { value: -1, result: false },
+            { value: 0, result: true },
+            { value: 1, result: true },
+            { value: 20999999 * 1e8, result: true },
+            { value: 21000000 * 1e8, result: true },
+            { value: 21000001 * 1e8, result: false },
+        ].forEach(f => {
+            it('returns ' + f.result + ' for valid for ' + f.value, () => {
+                assert.strictEqual(types.Satoshi(f.value), f.result);
+            });
+        });
+    });
+});

package/tsconfig.base.json

@@ -0,0 +1,27 @@
+{
+    "compilerOptions": {
+        "declaration": true,
+        "noImplicitAny": true,
+        "removeComments": true,
+        "suppressImplicitAnyIndexErrors": false,
+        "preserveConstEnums": true,
+        "resolveJsonModule": true,
+        "skipLibCheck": true,
+        "sourceMap": false,
+        "moduleDetection": "force",
+        "experimentalDecorators": true,
+        "lib": ["es6", "es2020", "es2021", "es2022", "esnext", "webworker", "dom", "scripthost"],
+        "strict": true,
+        "strictNullChecks": true,
+        "strictFunctionTypes": true,
+        "strictBindCallApply": true,
+        "strictPropertyInitialization": true,
+        "alwaysStrict": true,
+        "moduleResolution": "node",
+        "allowJs": true,
+        "incremental": true,
+        "allowSyntheticDefaultImports": true,
+        "esModuleInterop": true
+    },
+    "include": ["src/**/*.ts", "src/*", "src/**/*.js", "src/*.ts", "src/*.js", "src/*.cjs"]
+}

package/tsconfig.json

@@ -0,0 +1,19 @@
+{
+    "extends": "./tsconfig.base.json",
+    "compilerOptions": {
+        "module": "ESNext",
+        "target": "ES2020",
+        "declaration": true,
+        "outDir": "./build",
+        "moduleResolution": "node",
+        "esModuleInterop": true,
+        "skipLibCheck": true,
+        "allowSyntheticDefaultImports": true
+    },
+    "include": [
+        "src/**/*.ts"
+    ],
+    "exclude": [
+        "node_modules"
+    ]
+}

package/tsconfig.webpack.json

@@ -0,0 +1,18 @@
+{
+    "extends": "./tsconfig.json",
+    "compilerOptions": {
+        "module": "esnext",
+        "outDir": "browser",
+        "target": "esnext",
+        "declaration": true,
+        "esModuleInterop": true,
+        "skipLibCheck": true,
+        "strict": true,
+        "baseUrl": ".",
+        "paths": {
+            "@btc-vision/logger": ["node_modules/@btc-vision/logger"]
+        },
+        "moduleResolution": "bundler"
+    },
+    "exclude": ["./src/tests"]
+}

package/webpack.config.js

@@ -0,0 +1,79 @@
+import webpack from 'webpack';
+import path from 'node:path';
+
+export default {
+    mode: 'production',
+    target: 'web',
+    entry: {
+        index: {
+            import: './src/index.ts',
+        },
+    },
+    watch: false,
+    output: {
+        filename: 'index.js',
+        path: path.join(import.meta.dirname, './browser'),
+        libraryTarget: 'module',
+    },
+    node: {
+        __dirname: false,
+    },
+    experiments: {
+        outputModule: true,
+        asyncWebAssembly: false,
+        syncWebAssembly: true,
+    },
+    resolve: {
+        extensionAlias: {
+            '.js': ['.js', '.ts'],
+        },
+        modules: ['.', 'node_modules'],
+        extensions: ['.*', '.js', '.jsx', '.tsx', '.ts', '.wasm'],
+        fallback: {
+            buffer: import.meta.resolve('buffer/'),
+
+            assert: import.meta.resolve('assert/'),
+            crypto: import.meta.resolve('./src/crypto/crypto-browser.js'),
+            http: import.meta.resolve('stream-http/'),
+            https: import.meta.resolve('https-browserify/'),
+            os: import.meta.resolve('os-browserify/browser/'),
+            stream: import.meta.resolve('stream-browserify'),
+            process: import.meta.resolve('process/browser'),
+            zlib: import.meta.resolve('browserify-zlib'),
+        },
+    },
+    cache: false,
+    module: {
+        rules: [
+            {
+                test: /\.(js|jsx|tsx|ts)$/,
+                exclude: /node_modules/,
+                resolve: {
+                    fullySpecified: false,
+                },
+                use: [
+                    {
+                        loader: 'babel-loader',
+                    },
+                    {
+                        loader: 'ts-loader',
+                        options: {
+                            configFile: 'tsconfig.webpack.json',
+                        },
+                    },
+                ],
+            },
+        ],
+    },
+    optimization: {
+        usedExports: true,
+    },
+    plugins: [
+        new webpack.ProvidePlugin({
+            Buffer: ['buffer', 'Buffer'],
+            process: 'process/browser',
+            stream: 'stream-browserify',
+            zlib: 'browserify-zlib',
+        }),
+    ],
+};

package/src/address.d.ts

@@ -1,42 +0,0 @@
-/// <reference types="node" />
-import { Network } from './networks';
-/** base58check decode result */
-export interface Base58CheckResult {
-    /** address hash */
-    hash: Buffer;
-    /** address version: 0x00 for P2PKH, 0x05 for P2SH */
-    version: number;
-}
-/** bech32 decode result */
-export interface Bech32Result {
-    /** address version: 0x00 for P2WPKH、P2WSH, 0x01 for P2TR*/
-    version: number;
-    /** address prefix: bc for P2WPKH、P2WSH、P2TR */
-    prefix: string;
-    /** address data：20 bytes for P2WPKH, 32 bytes for P2WSH、P2TR */
-    data: Buffer;
-}
-/**
- * decode address with base58 specification,  return address version and address hash if valid
- */
-export declare function fromBase58Check(address: string): Base58CheckResult;
-/**
- * decode address with bech32 specification,  return address version、address prefix and address data if valid
- */
-export declare function fromBech32(address: string): Bech32Result;
-/**
- * encode address hash to base58 address with version
- */
-export declare function toBase58Check(hash: Buffer, version: number): string;
-/**
- * encode address hash to bech32 address with version and prefix
- */
-export declare function toBech32(data: Buffer, version: number, prefix: string): string;
-/**
- * decode address from output script with network, return address if matched
- */
-export declare function fromOutputScript(output: Buffer, network?: Network): string;
-/**
- * encodes address to output script with network, return output script if address matched
- */
-export declare function toOutputScript(address: string, network?: Network): Buffer;

package/src/crypto.js

@@ -1,128 +0,0 @@
-'use strict';
-Object.defineProperty(exports, '__esModule', { value: true });
-exports.taggedHash =
-    exports.TAGGED_HASH_PREFIXES =
-    exports.TAGS =
-    exports.hash256 =
-    exports.hash160 =
-    exports.sha256 =
-    exports.sha1 =
-    exports.ripemd160 =
-        void 0;
-/**
- * A module for hashing functions.
- * include ripemd160、sha1、sha256、hash160、hash256、taggedHash
- *
- * @packageDocumentation
- */
-const ripemd160_1 = require('@noble/hashes/ripemd160');
-const sha1_1 = require('@noble/hashes/sha1');
-const sha256_1 = require('@noble/hashes/sha256');
-function ripemd160(buffer) {
-    return Buffer.from((0, ripemd160_1.ripemd160)(Uint8Array.from(buffer)));
-}
-exports.ripemd160 = ripemd160;
-function sha1(buffer) {
-    return Buffer.from((0, sha1_1.sha1)(Uint8Array.from(buffer)));
-}
-exports.sha1 = sha1;
-function sha256(buffer) {
-    return Buffer.from((0, sha256_1.sha256)(Uint8Array.from(buffer)));
-}
-exports.sha256 = sha256;
-function hash160(buffer) {
-    return Buffer.from(
-        (0, ripemd160_1.ripemd160)(
-            (0, sha256_1.sha256)(Uint8Array.from(buffer)),
-        ),
-    );
-}
-exports.hash160 = hash160;
-function hash256(buffer) {
-    return Buffer.from(
-        (0, sha256_1.sha256)((0, sha256_1.sha256)(Uint8Array.from(buffer))),
-    );
-}
-exports.hash256 = hash256;
-exports.TAGS = [
-    'BIP0340/challenge',
-    'BIP0340/aux',
-    'BIP0340/nonce',
-    'TapLeaf',
-    'TapBranch',
-    'TapSighash',
-    'TapTweak',
-    'KeyAgg list',
-    'KeyAgg coefficient',
-];
-/** An object mapping tags to their tagged hash prefix of [SHA256(tag) | SHA256(tag)] */
-/**
- * Defines the tagged hash prefixes used in the crypto module.
- */
-exports.TAGGED_HASH_PREFIXES = {
-    '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,
-    ]),
-};
-function taggedHash(prefix, data) {
-    return sha256(Buffer.concat([exports.TAGGED_HASH_PREFIXES[prefix], data]));
-}
-exports.taggedHash = taggedHash;

package/src/ecc_lib.d.ts

@@ -1,17 +0,0 @@
-import { TinySecp256k1Interface } from './types';
-/**
- * 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 declare function initEccLib(eccLib: TinySecp256k1Interface | undefined): void;
-/**
- * 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 declare function getEccLib(): TinySecp256k1Interface;

package/src/hooks/AdvancedSignatureManager.d.ts

@@ -1,44 +0,0 @@
-/// <reference types="node" />
-export interface CacheEntry {
-    pubKey: string;
-    dataRef: WeakRef<Buffer>;
-    signature: Buffer;
-}
-export declare class AdvancedSignatureManager {
-    private static instance;
-    /**
-     * Map to index cache entries by signer public key.
-     * Key: Public Key (string)
-     * Value: Set of CacheEntries
-     */
-    private cacheBySigner;
-    /**
-     * FinalizationRegistry to clean up cache entries when their data buffers are garbage collected.
-     */
-    private registry;
-    private constructor();
-    static getInstance(): AdvancedSignatureManager;
-    /**
-     * 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: string, data: Buffer, signature: Buffer): Buffer;
-    /**
-     * 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: string, data: Buffer): Buffer | undefined;
-    /**
-     * Use with caution as it removes all cached signatures for all signers.
-     */
-    clearCache(): void;
-    /**
-     * Clears the cache for a specific signer.
-     * @param pubKey The signer's public key.
-     */
-    clearCacheForSigner(pubKey: string): void;
-}

package/src/hooks/HookedSigner.js

@@ -1,90 +0,0 @@
-'use strict';
-Object.defineProperty(exports, '__esModule', { value: true });
-exports.hookSigner = void 0;
-const SignatureManager_js_1 = require('./SignatureManager.js');
-const AdvancedSignatureManager_js_1 = require('./AdvancedSignatureManager.js');
-const advancedSignatureManager =
-    AdvancedSignatureManager_js_1.AdvancedSignatureManager.getInstance();
-function getPublicKey(keyPair) {
-    if (keyPair.publicKey && Buffer.isBuffer(keyPair.publicKey)) {
-        return keyPair.publicKey.toString('hex');
-    }
-}
-function hookKeyPair(keyPair) {
-    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;
-                }
-            },
-        });
-    }
-}
-function hookSigner(keyPair) {
-    const newKeypair = keyPair;
-    if (!newKeypair.hasHook) {
-        newKeypair.hasHook = true;
-        newKeypair.signatureManager =
-            new SignatureManager_js_1.SignatureManager();
-        hookKeyPair(newKeypair);
-    }
-}
-exports.hookSigner = hookSigner;

package/src/hooks/SignatureManager.d.ts

@@ -1,35 +0,0 @@
-/// <reference types="node" />
-export interface CacheEntry {
-    length: number;
-    dataRef: WeakRef<Buffer>;
-    signature: Buffer;
-}
-export declare class SignatureManager {
-    /**
-     * Map to index cache entries by buffer length.
-     * Key: Buffer length
-     * Value: Set of CacheEntries with that buffer length
-     */
-    private cacheByLength;
-    /**
-     * FinalizationRegistry to clean up cache entries when their data buffers are garbage collected.
-     */
-    private registry;
-    constructor();
-    /**
-     * Adds (caches) the signature for the given data buffer.
-     * @param data The data buffer.
-     * @param signature The signature buffer.
-     */
-    addSignature(data: Buffer, signature: Buffer): Buffer;
-    /**
-     * Retrieves the signature for the given data buffer.
-     * @param data The data buffer.
-     * @returns The signature buffer if found; otherwise, undefined.
-     */
-    getSignature(data: Buffer): Buffer | undefined;
-    /**
-     * Use with caution as it removes all cached signatures.
-     */
-    clearCache(): void;
-}