@btc-vision/bitcoin 6.5.5 → 7.0.0-alpha.0

package/browser/io/MemoryPool.d.ts

@@ -0,0 +1,220 @@
+/**
+ * Memory pool using SharedArrayBuffer for zero-allocation operations.
+ *
+ * Provides thread-safe memory allocation using Atomics for concurrent access.
+ * Ideal for parsing operations where temporary buffers are needed.
+ *
+ * @packageDocumentation
+ */
+/**
+ * Thread-safe memory pool using SharedArrayBuffer.
+ *
+ * Allocates memory from a pre-allocated SharedArrayBuffer pool,
+ * eliminating garbage collection pressure from repeated allocations.
+ *
+ * Uses Atomics for thread-safe allocation when used with Workers.
+ *
+ * @example
+ * ```typescript
+ * import { MemoryPool } from '@btc-vision/bitcoin';
+ *
+ * // Create a 1MB pool
+ * const pool = new MemoryPool(1024 * 1024);
+ *
+ * // Allocate memory for transaction parsing
+ * const txBuffer = pool.alloc(500);
+ * // ... use txBuffer ...
+ *
+ * // Reset pool when done (all allocations become invalid)
+ * pool.reset();
+ * ```
+ */
+export declare class MemoryPool {
+    #private;
+    /**
+     * Creates a new MemoryPool.
+     *
+     * @param size - Size of the pool in bytes (default 4MB)
+     *
+     * @example
+     * ```typescript
+     * import { MemoryPool } from '@btc-vision/bitcoin';
+     *
+     * // 4MB pool (default)
+     * const pool = new MemoryPool();
+     *
+     * // 16MB pool
+     * const largePool = new MemoryPool(16 * 1024 * 1024);
+     * ```
+     */
+    constructor(size?: number);
+    /**
+     * Creates a MemoryPool from an existing SharedArrayBuffer.
+     *
+     * Useful for sharing a pool between Workers.
+     *
+     * @param buffer - Existing SharedArrayBuffer
+     * @returns A new MemoryPool instance wrapping the buffer
+     *
+     * @example
+     * ```typescript
+     * // Main thread
+     * const pool = new MemoryPool(1024 * 1024);
+     * worker.postMessage({ buffer: pool.sharedBuffer });
+     *
+     * // Worker thread
+     * self.onmessage = (e) => {
+     *     const pool = MemoryPool.fromSharedBuffer(e.data.buffer);
+     *     const mem = pool.alloc(100);
+     * };
+     * ```
+     */
+    static fromSharedBuffer(buffer: SharedArrayBuffer): MemoryPool;
+    /**
+     * Total capacity of the pool in bytes.
+     */
+    get capacity(): number;
+    /**
+     * Current allocation offset (bytes used).
+     *
+     * Uses Atomics for thread-safe reading.
+     */
+    get used(): number;
+    /**
+     * Remaining available bytes.
+     */
+    get available(): number;
+    /**
+     * The underlying SharedArrayBuffer.
+     *
+     * Can be transferred to Workers for shared memory access.
+     */
+    get sharedBuffer(): SharedArrayBuffer;
+    /**
+     * Allocates memory from the pool.
+     *
+     * Thread-safe using Atomics.add for concurrent access.
+     *
+     * @param size - Number of bytes to allocate
+     * @returns Uint8Array view into the pool
+     * @throws RangeError if pool is exhausted
+     *
+     * @example
+     * ```typescript
+     * const pool = new MemoryPool(1024);
+     * const buf1 = pool.alloc(100); // First 100 bytes
+     * const buf2 = pool.alloc(200); // Next 200 bytes
+     * ```
+     */
+    alloc(size: number): Uint8Array;
+    /**
+     * Allocates memory and fills it with zeros.
+     *
+     * @param size - Number of bytes to allocate
+     * @returns Uint8Array view into the pool, filled with zeros
+     * @throws RangeError if pool is exhausted
+     */
+    allocZeroed(size: number): Uint8Array;
+    /**
+     * Allocates memory for a specific typed array.
+     *
+     * @param length - Number of elements
+     * @param bytesPerElement - Size of each element in bytes
+     * @returns Uint8Array view (use constructor of target type on underlying buffer)
+     * @throws RangeError if pool is exhausted
+     *
+     * @example
+     * ```typescript
+     * const pool = new MemoryPool(1024);
+     * const bytes = pool.allocTyped(10, 4); // 40 bytes for 10 Uint32
+     * const u32View = new Uint32Array(bytes.buffer, bytes.byteOffset, 10);
+     * ```
+     */
+    allocTyped(length: number, bytesPerElement: number): Uint8Array;
+    /**
+     * Resets the pool, making all memory available again.
+     *
+     * WARNING: All previously allocated views become invalid.
+     * Only call when you're sure no references are held.
+     *
+     * Thread-safe using Atomics.store.
+     *
+     * @example
+     * ```typescript
+     * const pool = new MemoryPool(1024);
+     * const buf = pool.alloc(100);
+     * // ... use buf ...
+     * pool.reset(); // buf is now invalid!
+     * ```
+     */
+    reset(): void;
+    /**
+     * Checks if the pool can accommodate an allocation.
+     *
+     * @param size - Number of bytes needed
+     * @returns True if allocation would succeed
+     */
+    canAlloc(size: number): boolean;
+}
+/**
+ * Non-shared memory pool using regular ArrayBuffer.
+ *
+ * Use when SharedArrayBuffer is not available (e.g., browsers without
+ * proper COOP/COEP headers) or when thread-safety is not needed.
+ *
+ * @example
+ * ```typescript
+ * import { SimpleMemoryPool } from '@btc-vision/bitcoin';
+ *
+ * const pool = new SimpleMemoryPool(1024 * 1024);
+ * const buf = pool.alloc(100);
+ * ```
+ */
+export declare class SimpleMemoryPool {
+    #private;
+    /**
+     * Creates a new SimpleMemoryPool.
+     *
+     * @param size - Size of the pool in bytes
+     */
+    constructor(size: number);
+    /**
+     * Total capacity of the pool in bytes.
+     */
+    get capacity(): number;
+    /**
+     * Current allocation offset (bytes used).
+     */
+    get used(): number;
+    /**
+     * Remaining available bytes.
+     */
+    get available(): number;
+    /**
+     * Allocates memory from the pool.
+     *
+     * @param size - Number of bytes to allocate
+     * @returns Uint8Array view into the pool
+     * @throws RangeError if pool is exhausted
+     */
+    alloc(size: number): Uint8Array;
+    /**
+     * Allocates memory and fills it with zeros.
+     *
+     * @param size - Number of bytes to allocate
+     * @returns Uint8Array view into the pool, filled with zeros
+     */
+    allocZeroed(size: number): Uint8Array;
+    /**
+     * Resets the pool, making all memory available again.
+     */
+    reset(): void;
+    /**
+     * Checks if the pool can accommodate an allocation.
+     *
+     * @param size - Number of bytes needed
+     * @returns True if allocation would succeed
+     */
+    canAlloc(size: number): boolean;
+}
+//# sourceMappingURL=MemoryPool.d.ts.map

package/browser/io/MemoryPool.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"MemoryPool.d.ts","sourceRoot":"","sources":["../../src/io/MemoryPool.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,qBAAa,UAAU;;IAsBnB;;;;;;;;;;;;;;;OAeG;gBACgB,IAAI,GAAE,MAAwB;IASjD;;;;;;;;;;;;;;;;;;;;OAoBG;WACW,gBAAgB,CAAC,MAAM,EAAE,iBAAiB,GAAG,UAAU;IAarE;;OAEG;IACH,IAAW,QAAQ,IAAI,MAAM,CAE5B;IAED;;;;OAIG;IACH,IAAW,IAAI,IAAI,MAAM,CAExB;IAED;;OAEG;IACH,IAAW,SAAS,IAAI,MAAM,CAE7B;IAED;;;;OAIG;IACH,IAAW,YAAY,IAAI,iBAAiB,CAE3C;IAED;;;;;;;;;;;;;;;OAeG;IACI,KAAK,CAAC,IAAI,EAAE,MAAM,GAAG,UAAU;IAmBtC;;;;;;OAMG;IACI,WAAW,CAAC,IAAI,EAAE,MAAM,GAAG,UAAU;IAM5C;;;;;;;;;;;;;;OAcG;IACI,UAAU,CAAC,MAAM,EAAE,MAAM,EAAE,eAAe,EAAE,MAAM,GAAG,UAAU;IAItE;;;;;;;;;;;;;;;OAeG;IACI,KAAK,IAAI,IAAI;IAIpB;;;;;OAKG;IACI,QAAQ,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO;CAGzC;AAED;;;;;;;;;;;;;GAaG;AACH,qBAAa,gBAAgB;;IAIzB;;;;OAIG;gBACgB,IAAI,EAAE,MAAM;IAI/B;;OAEG;IACH,IAAW,QAAQ,IAAI,MAAM,CAE5B;IAED;;OAEG;IACH,IAAW,IAAI,IAAI,MAAM,CAExB;IAED;;OAEG;IACH,IAAW,SAAS,IAAI,MAAM,CAE7B;IAED;;;;;;OAMG;IACI,KAAK,CAAC,IAAI,EAAE,MAAM,GAAG,UAAU;IAgBtC;;;;;OAKG;IACI,WAAW,CAAC,IAAI,EAAE,MAAM,GAAG,UAAU;IAM5C;;OAEG;IACI,KAAK,IAAI,IAAI;IAIpB;;;;;OAKG;IACI,QAAQ,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO;CAGzC"}

package/browser/io/base64.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Base64 encoding and decoding utilities.
+ *
+ * @packageDocumentation
+ */
+/**
+ * Decodes a base64 string to a Uint8Array.
+ *
+ * @param base64 - The base64-encoded string to decode
+ * @returns Uint8Array containing the decoded bytes
+ */
+export declare function fromBase64(base64: string): Uint8Array;
+//# sourceMappingURL=base64.d.ts.map

package/browser/io/base64.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"base64.d.ts","sourceRoot":"","sources":["../../src/io/base64.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH;;;;;GAKG;AACH,wBAAgB,UAAU,CAAC,MAAM,EAAE,MAAM,GAAG,UAAU,CAOrD"}

package/browser/io/hex.d.ts

@@ -0,0 +1,67 @@
+/**
+ * Hex encoding and decoding utilities.
+ *
+ * Direct implementations with zero dependencies and no wrappers.
+ * Optimized for performance with lookup tables.
+ *
+ * @packageDocumentation
+ */
+/**
+ * Converts a Uint8Array to a lowercase hex string.
+ *
+ * @param bytes - The byte array to convert
+ * @returns Lowercase hex string representation
+ *
+ * @example
+ * ```typescript
+ * import { toHex } from '@btc-vision/bitcoin';
+ *
+ * const bytes = new Uint8Array([0xde, 0xad, 0xbe, 0xef]);
+ * const hex = toHex(bytes);
+ * console.log(hex); // 'deadbeef'
+ * ```
+ */
+export declare function toHex(bytes: Uint8Array): string;
+/**
+ * Converts a hex string to a Uint8Array.
+ *
+ * Accepts hex strings with or without '0x' prefix.
+ * Case-insensitive (accepts both 'DEADBEEF' and 'deadbeef').
+ *
+ * @param hex - The hex string to convert
+ * @returns Uint8Array containing the decoded bytes
+ * @throws TypeError if hex string has odd length
+ * @throws TypeError if hex string contains invalid characters
+ *
+ * @example
+ * ```typescript
+ * import { fromHex, toHex } from '@btc-vision/bitcoin';
+ *
+ * const bytes = fromHex('deadbeef');
+ * console.log(bytes); // Uint8Array [222, 173, 190, 239]
+ *
+ * // Also works with 0x prefix
+ * const bytes2 = fromHex('0xCAFEBABE');
+ * console.log(toHex(bytes2)); // 'cafebabe'
+ * ```
+ */
+export declare function fromHex(hex: string): Uint8Array;
+/**
+ * Checks if a string is valid hexadecimal.
+ *
+ * @param value - The string to check
+ * @returns True if the string is valid hex (even length, valid chars)
+ *
+ * @example
+ * ```typescript
+ * import { isHex } from '@btc-vision/bitcoin';
+ *
+ * isHex('deadbeef'); // true
+ * isHex('0xdeadbeef'); // true
+ * isHex('DEADBEEF'); // true
+ * isHex('deadbee'); // false (odd length)
+ * isHex('deadbeeg'); // false (invalid char)
+ * ```
+ */
+export declare function isHex(value: string): boolean;
+//# sourceMappingURL=hex.d.ts.map

package/browser/io/hex.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hex.d.ts","sourceRoot":"","sources":["../../src/io/hex.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AA0BH;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,KAAK,CAAC,KAAK,EAAE,UAAU,GAAG,MAAM,CAM/C;AAED;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,wBAAgB,OAAO,CAAC,GAAG,EAAE,MAAM,GAAG,UAAU,CAsC/C;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,KAAK,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAkB5C"}

package/browser/io/index.d.ts

@@ -0,0 +1,17 @@
+/**
+ * High-performance binary I/O module.
+ *
+ * This module provides efficient binary reading and writing with
+ * zero-allocation operations through stateful DataView instances.
+ *
+ * @packageDocumentation
+ */
+import * as varuint from 'varuint-bitcoin';
+export { BinaryReader } from './BinaryReader.js';
+export { BinaryWriter, GrowableBinaryWriter } from './BinaryWriter.js';
+export { toHex, fromHex, isHex } from './hex.js';
+export { fromBase64 } from './base64.js';
+export { concat, equals, compare, isZero, clone, reverse, reverseCopy, alloc, xor, fromUtf8, toUtf8, } from './utils.js';
+export { MemoryPool, SimpleMemoryPool } from './MemoryPool.js';
+export { varuint };
+//# sourceMappingURL=index.d.ts.map

package/browser/io/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/io/index.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,KAAK,OAAO,MAAM,iBAAiB,CAAC;AAG3C,OAAO,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAC;AACjD,OAAO,EAAE,YAAY,EAAE,oBAAoB,EAAE,MAAM,mBAAmB,CAAC;AAGvE,OAAO,EAAE,KAAK,EAAE,OAAO,EAAE,KAAK,EAAE,MAAM,UAAU,CAAC;AAGjD,OAAO,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AAGzC,OAAO,EACH,MAAM,EACN,MAAM,EACN,OAAO,EACP,MAAM,EACN,KAAK,EACL,OAAO,EACP,WAAW,EACX,KAAK,EACL,GAAG,EACH,QAAQ,EACR,MAAM,GACT,MAAM,YAAY,CAAC;AAGpB,OAAO,EAAE,UAAU,EAAE,gBAAgB,EAAE,MAAM,iBAAiB,CAAC;AAG/D,OAAO,EAAE,OAAO,EAAE,CAAC"}

package/browser/io/utils.d.ts

@@ -0,0 +1,199 @@
+/**
+ * Pure utility functions for Uint8Array operations.
+ *
+ * No DataView allocations. No wrappers.
+ * Optimized for performance with minimal allocations.
+ *
+ * @packageDocumentation
+ */
+/**
+ * Concatenates multiple Uint8Arrays into a single Uint8Array.
+ *
+ * Allocates exactly once for the result array.
+ *
+ * @param arrays - Arrays to concatenate
+ * @returns A new Uint8Array containing all input arrays
+ *
+ * @example
+ * ```typescript
+ * import { concat, fromHex } from '@btc-vision/bitcoin';
+ *
+ * const a = fromHex('deadbeef');
+ * const b = fromHex('cafebabe');
+ * const result = concat([a, b]);
+ * // result contains deadbeefcafebabe
+ * ```
+ */
+export declare function concat(arrays: readonly Uint8Array[]): Uint8Array;
+/**
+ * Checks if two Uint8Arrays have identical contents.
+ *
+ * @param a - First array
+ * @param b - Second array
+ * @returns True if arrays have the same length and contents
+ *
+ * @example
+ * ```typescript
+ * import { equals, fromHex } from '@btc-vision/bitcoin';
+ *
+ * const a = fromHex('deadbeef');
+ * const b = fromHex('deadbeef');
+ * const c = fromHex('cafebabe');
+ *
+ * equals(a, b); // true
+ * equals(a, c); // false
+ * ```
+ */
+export declare function equals(a: Uint8Array, b: Uint8Array): boolean;
+/**
+ * Compares two Uint8Arrays lexicographically.
+ *
+ * @param a - First array
+ * @param b - Second array
+ * @returns Negative if a < b, positive if a > b, 0 if equal
+ *
+ * @example
+ * ```typescript
+ * import { compare, fromHex } from '@btc-vision/bitcoin';
+ *
+ * const a = fromHex('0001');
+ * const b = fromHex('0002');
+ *
+ * compare(a, b); // -1 (a < b)
+ * compare(b, a); // 1 (b > a)
+ * compare(a, a); // 0 (equal)
+ * ```
+ */
+export declare function compare(a: Uint8Array, b: Uint8Array): number;
+/**
+ * Checks if a Uint8Array contains only zero bytes.
+ *
+ * @param bytes - Array to check
+ * @returns True if all bytes are zero
+ *
+ * @example
+ * ```typescript
+ * import { isZero } from '@btc-vision/bitcoin';
+ *
+ * isZero(new Uint8Array(32)); // true
+ * isZero(new Uint8Array([0, 0, 1])); // false
+ * ```
+ */
+export declare function isZero(bytes: Uint8Array): boolean;
+/**
+ * Creates a copy of a Uint8Array.
+ *
+ * @param bytes - Array to clone
+ * @returns A new Uint8Array with the same contents
+ *
+ * @example
+ * ```typescript
+ * import { clone, fromHex } from '@btc-vision/bitcoin';
+ *
+ * const original = fromHex('deadbeef');
+ * const copy = clone(original);
+ * copy[0] = 0; // Modifying copy doesn't affect original
+ * ```
+ */
+export declare function clone(bytes: Uint8Array): Uint8Array;
+/**
+ * Reverses a Uint8Array in place.
+ *
+ * @param bytes - Array to reverse
+ * @returns The same array, reversed
+ *
+ * @example
+ * ```typescript
+ * import { reverse, fromHex, toHex } from '@btc-vision/bitcoin';
+ *
+ * const bytes = fromHex('01020304');
+ * reverse(bytes);
+ * toHex(bytes); // '04030201'
+ * ```
+ */
+export declare function reverse(bytes: Uint8Array): Uint8Array;
+/**
+ * Creates a reversed copy of a Uint8Array.
+ *
+ * @param bytes - Array to copy and reverse
+ * @returns A new reversed Uint8Array
+ *
+ * @example
+ * ```typescript
+ * import { reverseCopy, fromHex, toHex } from '@btc-vision/bitcoin';
+ *
+ * const bytes = fromHex('01020304');
+ * const reversed = reverseCopy(bytes);
+ * toHex(reversed); // '04030201'
+ * toHex(bytes); // '01020304' (original unchanged)
+ * ```
+ */
+export declare function reverseCopy(bytes: Uint8Array): Uint8Array;
+/**
+ * Allocates a new Uint8Array of the specified size.
+ *
+ * @param size - Number of bytes to allocate
+ * @param fill - Optional fill value (default 0)
+ * @returns A new Uint8Array filled with the specified value
+ *
+ * @example
+ * ```typescript
+ * import { alloc, toHex } from '@btc-vision/bitcoin';
+ *
+ * const zeros = alloc(4); // 4 zero bytes
+ * const ones = alloc(4, 0xff); // 4 bytes of 0xff
+ * toHex(ones); // 'ffffffff'
+ * ```
+ */
+export declare function alloc(size: number, fill?: number): Uint8Array;
+/**
+ * XORs two Uint8Arrays together.
+ *
+ * @param a - First array
+ * @param b - Second array
+ * @returns A new Uint8Array with the XOR result
+ * @throws TypeError if arrays have different lengths
+ *
+ * @example
+ * ```typescript
+ * import { xor, fromHex, toHex } from '@btc-vision/bitcoin';
+ *
+ * const a = fromHex('ff00ff00');
+ * const b = fromHex('0f0f0f0f');
+ * const result = xor(a, b);
+ * toHex(result); // 'f00ff00f'
+ * ```
+ */
+export declare function xor(a: Uint8Array, b: Uint8Array): Uint8Array;
+/**
+ * Creates a Uint8Array from a UTF-8 string.
+ *
+ * @param str - String to encode
+ * @returns Uint8Array containing UTF-8 encoded bytes
+ *
+ * @example
+ * ```typescript
+ * import { fromUtf8, toHex } from '@btc-vision/bitcoin';
+ *
+ * const bytes = fromUtf8('hello');
+ * toHex(bytes); // '68656c6c6f'
+ * ```
+ */
+export declare function fromUtf8(str: string): Uint8Array;
+/**
+ * Decodes a Uint8Array to a UTF-8 string.
+ *
+ * @param bytes - Uint8Array to decode
+ * @returns Decoded string
+ *
+ * @example
+ * ```typescript
+ * import { toUtf8, fromHex } from '@btc-vision/bitcoin';
+ *
+ * const bytes = fromHex('68656c6c6f');
+ * const str = toUtf8(bytes);
+ * // str is 'hello'
+ * ```
+ */
+export declare function toUtf8(bytes: Uint8Array): string;
+//# sourceMappingURL=utils.d.ts.map

package/browser/io/utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../src/io/utils.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,MAAM,CAAC,MAAM,EAAE,SAAS,UAAU,EAAE,GAAG,UAAU,CAehE;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,MAAM,CAAC,CAAC,EAAE,UAAU,EAAE,CAAC,EAAE,UAAU,GAAG,OAAO,CAU5D;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,OAAO,CAAC,CAAC,EAAE,UAAU,EAAE,CAAC,EAAE,UAAU,GAAG,MAAM,CAS5D;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,MAAM,CAAC,KAAK,EAAE,UAAU,GAAG,OAAO,CAOjD;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,KAAK,CAAC,KAAK,EAAE,UAAU,GAAG,UAAU,CAKnD;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,OAAO,CAAC,KAAK,EAAE,UAAU,GAAG,UAAU,CAGrD;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,WAAW,CAAC,KAAK,EAAE,UAAU,GAAG,UAAU,CAMzD;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,KAAK,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,GAAE,MAAU,GAAG,UAAU,CAMhE;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,GAAG,CAAC,CAAC,EAAE,UAAU,EAAE,CAAC,EAAE,UAAU,GAAG,UAAU,CAS5D;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,QAAQ,CAAC,GAAG,EAAE,MAAM,GAAG,UAAU,CAEhD;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,MAAM,CAAC,KAAK,EAAE,UAAU,GAAG,MAAM,CAEhD"}

package/browser/merkle.d.ts

@@ -1 +1,10 @@
-export declare function fastMerkleRoot(values: Buffer[], digestFn: (b: Buffer) => Buffer): Buffer;
+/**
+ * Calculates the Merkle root of an array of Uint8Arrays using a specified digest function.
+ *
+ * @param values - The array of Uint8Arrays.
+ * @param digestFn - The digest function used to calculate the hash of the concatenated arrays.
+ * @returns The Merkle root as a Uint8Array.
+ * @throws {TypeError} If the values parameter is not an array or the digestFn parameter is not a function.
+ */
+export declare function fastMerkleRoot(values: Uint8Array[], digestFn: (b: Uint8Array) => Uint8Array): Uint8Array;
+//# sourceMappingURL=merkle.d.ts.map

package/browser/merkle.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"merkle.d.ts","sourceRoot":"","sources":["../src/merkle.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AACH,wBAAgB,cAAc,CAC1B,MAAM,EAAE,UAAU,EAAE,EACpB,QAAQ,EAAE,CAAC,CAAC,EAAE,UAAU,KAAK,UAAU,GACxC,UAAU,CAwBZ"}

package/browser/networks.d.ts

@@ -1,24 +1,85 @@
+/**
+ * Represents a Bitcoin network configuration，including messagePrefix, bech32, bip32, pubKeyHash, scriptHash, wif.
+ * Support bitcoin、bitcoin testnet and bitcoin regtest.
+ * @packageDocumentation
+ */
 export interface Bip32 {
-    public: number;
-    private: number;
+    readonly public: number;
+    readonly private: number;
 }
 export interface Network {
-    wif: number;
-    bip32: Bip32;
-    messagePrefix: string;
-    bech32: string;
-    bech32Opnet?: string;
-    pubKeyHash: number;
-    scriptHash: number;
+    readonly wif: number;
+    readonly bip32: Bip32;
+    readonly messagePrefix: string;
+    readonly bech32: string;
+    readonly bech32Opnet?: string;
+    readonly pubKeyHash: number;
+    readonly scriptHash: number;
 }
+/**
+ * Represents the Bitcoin network configuration.
+ */
 export declare const bitcoin: Network;
+/**
+ * Represents the regtest network configuration.
+ */
 export declare const regtest: Network;
+/**
+ * Represents the testnet network configuration.
+ */
 export declare const testnet: Network;
+/**
+ * Represents the Dogecoin mainnet configuration.
+ *
+ * Prefixes from:
+ * - P2PKH: 0x1e (30 decimal) - addresses start with 'D'
+ * - P2SH: 0x16 (22 decimal) - addresses often start with '9' or 'A'
+ * - WIF: 0x9e (158 decimal)
+ * - BIP32:
+ *   - public: 0x02facafd
+ *   - private: 0x02fac398
+ * Message prefix:
+ *   - Dogecoin uses "\x19Dogecoin Signed Message:\n"
+ */
 export declare const dogecoin: Network;
+/**
+ * Represents the Dogecoin testnet configuration.
+ *
+ * Prefixes from Dogecoin testnet chainparams:
+ * - P2PKH: 0x71 (113 decimal)
+ * - P2SH: 0xc4 (196 decimal)
+ * - WIF: 0xf1 (241 decimal)
+ * - BIP32:
+ *   - public: 0x0432a9a8
+ *   - private: 0x0432a243
+ * Message prefix:
+ *   - Same as mainnet: "\x19Dogecoin Signed Message:\n"
+ */
 export declare const dogecoinTestnet: Network;
+/**
+ * Litecoin mainnet configuration.
+ */
 export declare const litecoin: Network;
+/**
+ * Litecoin testnet configuration.
+ */
 export declare const litecoinTestnet: Network;
+/**
+ * Bitcoin Cash mainnet configuration (legacy).
+ * Note: Bitcoin Cash uses Cashaddr starting with 'q' or 'p',
+ * but we retain the legacy prefixes for compatibility.
+ */
 export declare const bitcoinCash: Network;
+/**
+ * Bitcoin Cash testnet configuration (legacy).
+ */
 export declare const bitcoinCashTestnet: Network;
+/**
+ * Dash mainnet configuration.
+ */
 export declare const dash: Network;
+/**
+ * Dash testnet configuration.
+ */
 export declare const dashTestnet: Network;
+//# sourceMappingURL=networks.d.ts.map

package/browser/networks.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"networks.d.ts","sourceRoot":"","sources":["../src/networks.ts"],"names":[],"mappings":"AAGA;;;;GAIG;AAEH,MAAM,WAAW,KAAK;IAClB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;CAC5B;AAED,MAAM,WAAW,OAAO;IACpB,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;IACrB,QAAQ,CAAC,KAAK,EAAE,KAAK,CAAC;IACtB,QAAQ,CAAC,aAAa,EAAE,MAAM,CAAC;IAC/B,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,WAAW,CAAC,EAAE,MAAM,CAAC;IAC9B,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;CAC/B;AAED;;GAEG;AACH,eAAO,MAAM,OAAO,EAAE,OAmCrB,CAAC;AACF;;GAEG;AACH,eAAO,MAAM,OAAO,EAAE,OAWrB,CAAC;AACF;;GAEG;AACH,eAAO,MAAM,OAAO,EAAE,OAWrB,CAAC;AAEF;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,QAAQ,EAAE,OAWtB,CAAC;AAEF;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,eAAe,EAAE,OAW7B,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,QAAQ,EAAE,OAWtB,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,eAAe,EAAE,OAW7B,CAAC;AAEF;;;;GAIG;AACH,eAAO,MAAM,WAAW,EAAE,OAazB,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,kBAAkB,EAAE,OAWhC,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,IAAI,EAAE,OAalB,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,WAAW,EAAE,OAWzB,CAAC"}

package/browser/opcodes.d.ts

@@ -123,3 +123,4 @@ export declare const opcodes: Opcodes;
 export declare const REVERSE_OPS: {
     [key: number]: string;
 };
+//# sourceMappingURL=opcodes.d.ts.map

package/browser/opcodes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"opcodes.d.ts","sourceRoot":"","sources":["../src/opcodes.ts"],"names":[],"mappings":"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"}