@btc-vision/bitcoin 6.3.0

package/src/crypto.js

@@ -0,0 +1,128 @@
+'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

@@ -0,0 +1,17 @@
+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/ecc_lib.js

@@ -0,0 +1,122 @@
+'use strict';
+Object.defineProperty(exports, '__esModule', { value: true });
+exports.getEccLib = exports.initEccLib = void 0;
+const _ECCLIB_CACHE = {};
+/**
+ * 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.
+ */
+function initEccLib(eccLib) {
+    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;
+    }
+}
+exports.initEccLib = initEccLib;
+/**
+ * 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.
+ */
+function getEccLib() {
+    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');
+/**
+ * Verifies the ECC functionality.
+ *
+ * @param ecc - The TinySecp256k1Interface object.
+ */
+function verifyEcc(ecc) {
+    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) {
+    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.d.ts

@@ -0,0 +1,44 @@
+/// <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/AdvancedSignatureManager.js

@@ -0,0 +1,88 @@
+'use strict';
+Object.defineProperty(exports, '__esModule', { value: true });
+exports.AdvancedSignatureManager = void 0;
+class AdvancedSignatureManager {
+    static instance;
+    /**
+     * Map to index cache entries by signer public key.
+     * Key: Public Key (string)
+     * Value: Set of CacheEntries
+     */
+    cacheBySigner = new Map();
+    /**
+     * FinalizationRegistry to clean up cache entries when their data buffers are garbage collected.
+     */
+    registry;
+    constructor() {
+        this.registry = new FinalizationRegistry(entry => {
+            // 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
+    static getInstance() {
+        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 = {
+            pubKey,
+            dataRef: new WeakRef(data),
+            signature,
+        };
+        if (!this.cacheBySigner.has(pubKey)) {
+            this.cacheBySigner.set(pubKey, new Set());
+        }
+        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) {
+        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.
+     */
+    clearCache() {
+        this.cacheBySigner.clear();
+    }
+    /**
+     * Clears the cache for a specific signer.
+     * @param pubKey The signer's public key.
+     */
+    clearCacheForSigner(pubKey) {
+        this.cacheBySigner.delete(pubKey);
+    }
+}
+exports.AdvancedSignatureManager = AdvancedSignatureManager;

package/src/hooks/HookedSigner.d.ts

@@ -0,0 +1,4 @@
+import { BIP32Interface } from 'bip32';
+import { ECPairInterface } from 'ecpair';
+import { Signer, SignerAlternative, SignerAsync } from '../psbt.js';
+export declare function hookSigner(keyPair: Signer | SignerAlternative | SignerAsync | BIP32Interface | ECPairInterface): void;

package/src/hooks/HookedSigner.js

@@ -0,0 +1,90 @@
+'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

@@ -0,0 +1,35 @@
+/// <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;
+}

package/src/hooks/SignatureManager.js

@@ -0,0 +1,72 @@
+'use strict';
+Object.defineProperty(exports, '__esModule', { value: true });
+exports.SignatureManager = void 0;
+class SignatureManager {
+    /**
+     * Map to index cache entries by buffer length.
+     * Key: Buffer length
+     * Value: Set of CacheEntries with that buffer length
+     */
+    cacheByLength = new Map();
+    /**
+     * FinalizationRegistry to clean up cache entries when their data buffers are garbage collected.
+     */
+    registry;
+    constructor() {
+        this.registry = new FinalizationRegistry(entry => {
+            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.
+     */
+    addSignature(data, signature) {
+        const length = data.length;
+        const entry = {
+            length,
+            dataRef: new WeakRef(data),
+            signature,
+        };
+        if (!this.cacheByLength.has(length)) {
+            this.cacheByLength.set(length, new Set());
+        }
+        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) {
+        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.
+     */
+    clearCache() {
+        this.cacheByLength.clear();
+    }
+}
+exports.SignatureManager = SignatureManager;

package/src/index.d.ts

@@ -0,0 +1,42 @@
+import * as address from './address';
+import * as crypto from './crypto';
+import * as networks from './networks';
+import * as payments from './payments';
+import * as script from './script';
+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';
+export { address, crypto, networks, payments, script };
+export { Block } from './block';
+/** @hidden */
+export { TaggedHashPrefix } from './crypto';
+export * from './psbt';
+/** @hidden */
+export { OPS as opcodes } from './ops';
+export { Transaction } from './transaction';
+/** @hidden */
+export { Network } from './networks';
+/** @hidden */
+export { Payment, PaymentCreator, PaymentOpts, Stack, StackElement, } from './payments';
+export { Input as TxInput, Output as TxOutput } from './transaction';
+export { initEccLib } from './ecc_lib';
+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 {
+}