@btc-vision/bitcoin 6.3.0 → 6.3.2

package/build/bufferutils.js

@@ -0,0 +1,141 @@
+import * as varuint from 'varuint-bitcoin';
+import * as types from './types.js';
+const { typeforce } = types;
+export { varuint };
+function verifuint(value, max) {
+    if (typeof value !== 'number')
+        throw new Error('cannot write a non-number as a number');
+    if (value < 0)
+        throw new Error('specified a negative value for writing an unsigned value');
+    if (value > max)
+        throw new Error('RangeError: value out of range');
+    if (Math.floor(value) !== value)
+        throw new Error('value has a fractional component');
+}
+export function readUInt64LE(buffer, offset) {
+    const a = buffer.readUInt32LE(offset);
+    let b = buffer.readUInt32LE(offset + 4);
+    b *= 0x100000000;
+    verifuint(b + a, 0x001fffffffffffff);
+    return b + a;
+}
+export function writeUInt64LE(buffer, value, offset) {
+    verifuint(value, 0x001fffffffffffff);
+    buffer.writeInt32LE(value & -1, offset);
+    buffer.writeUInt32LE(Math.floor(value / 0x100000000), offset + 4);
+    return offset + 8;
+}
+export function reverseBuffer(buffer) {
+    if (buffer.length < 1)
+        return buffer;
+    let j = buffer.length - 1;
+    let tmp = 0;
+    for (let i = 0; i < buffer.length / 2; i++) {
+        tmp = buffer[i];
+        buffer[i] = buffer[j];
+        buffer[j] = tmp;
+        j--;
+    }
+    return buffer;
+}
+export function cloneBuffer(buffer) {
+    const clone = Buffer.allocUnsafe(buffer.length);
+    buffer.copy(clone);
+    return clone;
+}
+export class BufferWriter {
+    constructor(buffer, offset = 0) {
+        this.buffer = buffer;
+        this.offset = offset;
+        typeforce(types.tuple(types.Buffer, types.UInt32), [buffer, offset]);
+    }
+    static withCapacity(size) {
+        return new BufferWriter(Buffer.alloc(size));
+    }
+    writeUInt8(i) {
+        this.offset = this.buffer.writeUInt8(i, this.offset);
+    }
+    writeInt32(i) {
+        this.offset = this.buffer.writeInt32LE(i, this.offset);
+    }
+    writeUInt32(i) {
+        this.offset = this.buffer.writeUInt32LE(i, this.offset);
+    }
+    writeUInt64(i) {
+        this.offset = writeUInt64LE(this.buffer, i, this.offset);
+    }
+    writeVarInt(i) {
+        varuint.encode(i, this.buffer, this.offset);
+        this.offset += varuint.encode.bytes;
+    }
+    writeSlice(slice) {
+        if (this.buffer.length < this.offset + slice.length) {
+            throw new Error('Cannot write slice out of bounds');
+        }
+        this.offset += slice.copy(this.buffer, this.offset);
+    }
+    writeVarSlice(slice) {
+        this.writeVarInt(slice.length);
+        this.writeSlice(slice);
+    }
+    writeVector(vector) {
+        this.writeVarInt(vector.length);
+        vector.forEach((buf) => this.writeVarSlice(buf));
+    }
+    end() {
+        if (this.buffer.length === this.offset) {
+            return this.buffer;
+        }
+        throw new Error(`buffer size ${this.buffer.length}, offset ${this.offset}`);
+    }
+}
+export class BufferReader {
+    constructor(buffer, offset = 0) {
+        this.buffer = buffer;
+        this.offset = offset;
+        typeforce(types.tuple(types.Buffer, types.UInt32), [buffer, offset]);
+    }
+    readUInt8() {
+        const result = this.buffer.readUInt8(this.offset);
+        this.offset++;
+        return result;
+    }
+    readInt32() {
+        const result = this.buffer.readInt32LE(this.offset);
+        this.offset += 4;
+        return result;
+    }
+    readUInt32() {
+        const result = this.buffer.readUInt32LE(this.offset);
+        this.offset += 4;
+        return result;
+    }
+    readUInt64() {
+        const result = readUInt64LE(this.buffer, this.offset);
+        this.offset += 8;
+        return result;
+    }
+    readVarInt() {
+        const vi = varuint.decode(this.buffer, this.offset);
+        this.offset += varuint.decode.bytes;
+        return vi;
+    }
+    readSlice(n) {
+        if (this.buffer.length < this.offset + n) {
+            throw new Error('Cannot read slice out of bounds');
+        }
+        const result = this.buffer.slice(this.offset, this.offset + n);
+        this.offset += n;
+        return result;
+    }
+    readVarSlice() {
+        return this.readSlice(this.readVarInt());
+    }
+    readVector() {
+        const count = this.readVarInt();
+        const vector = [];
+        for (let i = 0; i < count; i++)
+            vector.push(this.readVarSlice());
+        return vector;
+    }
+}

package/build/crypto/crypto.d.ts

@@ -0,0 +1 @@
+export { createHash, createHmac, pbkdf2Sync, randomBytes } from 'crypto';

package/build/crypto/crypto.js

@@ -0,0 +1 @@
+export { createHash, createHmac, pbkdf2Sync, randomBytes } from 'crypto';

package/build/crypto.d.ts

@@ -0,0 +1,13 @@
+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;
+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;
+};
+export declare const TAGGED_HASH_PREFIXES: TaggedHashPrefixes;
+export declare function taggedHash(prefix: TaggedHashPrefix, data: Buffer): Buffer;
+export {};

package/build/crypto.js

@@ -0,0 +1,87 @@
+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) {
+    return Buffer.from(_ripemd160(Uint8Array.from(buffer)));
+}
+export function sha1(buffer) {
+    return Buffer.from(_sha1(Uint8Array.from(buffer)));
+}
+export function sha256(buffer) {
+    return Buffer.from(_sha256(Uint8Array.from(buffer)));
+}
+export function hash160(buffer) {
+    return Buffer.from(_ripemd160(_sha256(Uint8Array.from(buffer))));
+}
+export function hash256(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',
+];
+export const 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,
+    ]),
+};
+export function taggedHash(prefix, data) {
+    return sha256(Buffer.concat([TAGGED_HASH_PREFIXES[prefix], data]));
+}

package/build/ecc_lib.d.ts

@@ -0,0 +1,3 @@
+import { TinySecp256k1Interface } from './types.js';
+export declare function initEccLib(eccLib: TinySecp256k1Interface | undefined): void;
+export declare function getEccLib(): TinySecp256k1Interface;

package/build/ecc_lib.js

@@ -0,0 +1,61 @@
+const _ECCLIB_CACHE = {};
+export function initEccLib(eccLib) {
+    if (!eccLib) {
+        _ECCLIB_CACHE.eccLib = eccLib;
+    }
+    else if (eccLib !== _ECCLIB_CACHE.eccLib) {
+        verifyEcc(eccLib);
+        _ECCLIB_CACHE.eccLib = eccLib;
+    }
+}
+export 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;
+}
+const h = (hex) => Buffer.from(hex, 'hex');
+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/build/hooks/AdvancedSignatureManager.d.ts

@@ -0,0 +1,16 @@
+export interface CacheEntry {
+    pubKey: string;
+    dataRef: WeakRef<Buffer>;
+    signature: Buffer;
+}
+export declare class AdvancedSignatureManager {
+    private static instance;
+    private cacheBySigner;
+    private registry;
+    private constructor();
+    static getInstance(): AdvancedSignatureManager;
+    addSignature(pubKey: string, data: Buffer, signature: Buffer): Buffer;
+    getSignature(pubKey: string, data: Buffer): Buffer | undefined;
+    clearCache(): void;
+    clearCacheForSigner(pubKey: string): void;
+}

package/build/hooks/AdvancedSignatureManager.js

@@ -0,0 +1,52 @@
+export class AdvancedSignatureManager {
+    constructor() {
+        this.cacheBySigner = new Map();
+        this.registry = new FinalizationRegistry((entry) => {
+            const set = this.cacheBySigner.get(entry.pubKey);
+            if (set) {
+                set.delete(entry);
+                if (set.size === 0) {
+                    this.cacheBySigner.delete(entry.pubKey);
+                }
+            }
+        });
+    }
+    static getInstance() {
+        if (!AdvancedSignatureManager.instance) {
+            AdvancedSignatureManager.instance = new AdvancedSignatureManager();
+        }
+        return AdvancedSignatureManager.instance;
+    }
+    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);
+        this.registry.register(data, entry);
+        return signature;
+    }
+    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;
+    }
+    clearCache() {
+        this.cacheBySigner.clear();
+    }
+    clearCacheForSigner(pubKey) {
+        this.cacheBySigner.delete(pubKey);
+    }
+}

package/build/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/build/hooks/HookedSigner.js

@@ -0,0 +1,64 @@
+import { SignatureManager } from './SignatureManager.js';
+import { AdvancedSignatureManager } from './AdvancedSignatureManager.js';
+const advancedSignatureManager = 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;
+                }
+            },
+        });
+    }
+}
+export function hookSigner(keyPair) {
+    const newKeypair = keyPair;
+    if (!newKeypair.hasHook) {
+        newKeypair.hasHook = true;
+        newKeypair.signatureManager = new SignatureManager();
+        hookKeyPair(newKeypair);
+    }
+}

package/build/hooks/SignatureManager.d.ts

@@ -0,0 +1,13 @@
+export interface CacheEntry {
+    length: number;
+    dataRef: WeakRef<Buffer>;
+    signature: Buffer;
+}
+export declare class SignatureManager {
+    private cacheByLength;
+    private registry;
+    constructor();
+    addSignature(data: Buffer, signature: Buffer): Buffer;
+    getSignature(data: Buffer): Buffer | undefined;
+    clearCache(): void;
+}

package/build/hooks/SignatureManager.js

@@ -0,0 +1,45 @@
+export class SignatureManager {
+    constructor() {
+        this.cacheByLength = new Map();
+        this.registry = new FinalizationRegistry((entry) => {
+            const set = this.cacheByLength.get(entry.length);
+            if (set) {
+                set.delete(entry);
+                if (set.size === 0) {
+                    this.cacheByLength.delete(entry.length);
+                }
+            }
+        });
+    }
+    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);
+        this.registry.register(data, entry);
+        return signature;
+    }
+    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;
+    }
+    clearCache() {
+        this.cacheByLength.clear();
+    }
+}

package/build/index.d.ts

@@ -0,0 +1,58 @@
+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';
+export * from './crypto.js';
+export * from './psbt.js';
+export { OPS as opcodes } from './ops.js';
+export { Transaction } from './transaction.js';
+export { Network } from './networks.js';
+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';
+declare const bitcoin: {
+    networks: typeof networks;
+    address: typeof address;
+    payments: typeof payments;
+    script: typeof script;
+    crypto: typeof crypto;
+    Transaction: typeof Transaction;
+};
+export default bitcoin;

package/build/index.js

@@ -0,0 +1,32 @@
+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';
+export * from './crypto.js';
+export * from './psbt.js';
+export { OPS as opcodes } from './ops.js';
+export { Transaction } from './transaction.js';
+export { initEccLib } from './ecc_lib.js';
+export * from './psbt/bip371.js';
+export * from './address.js';
+export * from './bufferutils.js';
+export * from './payments/bip341.js';
+export * from './psbt/psbtutils.js';
+export { TAPLEAF_VERSION_MASK, } from './types.js';
+const bitcoin = {
+    networks,
+    address,
+    payments,
+    script,
+    crypto,
+    Transaction,
+};
+export default bitcoin;

package/build/merkle.d.ts

@@ -0,0 +1 @@
+export declare function fastMerkleRoot(values: Buffer[], digestFn: (b: Buffer) => Buffer): Buffer;

package/build/merkle.js

@@ -0,0 +1,19 @@
+export function fastMerkleRoot(values, digestFn) {
+    if (!Array.isArray(values))
+        throw TypeError('Expected values Array');
+    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];
+}

package/build/networks.d.ts

@@ -0,0 +1,23 @@
+export interface Bip32 {
+    public: number;
+    private: number;
+}
+export interface Network {
+    wif: number;
+    bip32: Bip32;
+    messagePrefix: string;
+    bech32: string;
+    pubKeyHash: number;
+    scriptHash: number;
+}
+export declare const bitcoin: Network;
+export declare const regtest: Network;
+export declare const testnet: Network;
+export declare const dogecoin: Network;
+export declare const dogecoinTestnet: Network;
+export declare const litecoin: Network;
+export declare const litecoinTestnet: Network;
+export declare const bitcoinCash: Network;
+export declare const bitcoinCashTestnet: Network;
+export declare const dash: Network;
+export declare const dashTestnet: Network;