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

package/build/io/hex.js

@@ -0,0 +1,138 @@
+/**
+ * Hex encoding and decoding utilities.
+ *
+ * Direct implementations with zero dependencies and no wrappers.
+ * Optimized for performance with lookup tables.
+ *
+ * @packageDocumentation
+ */
+/**
+ * Lookup table for byte to hex conversion.
+ * Pre-computed for O(1) lookup per byte.
+ */
+const BYTE_TO_HEX = Array.from({ length: 256 }, (_, i) => i.toString(16).padStart(2, '0'));
+/**
+ * Lookup table for hex character to nibble conversion.
+ * Returns -1 for invalid characters.
+ */
+const HEX_TO_NIBBLE = (() => {
+    const table = new Array(128).fill(-1);
+    for (let i = 0; i < 10; i++) {
+        table[0x30 + i] = i; // '0'-'9'
+    }
+    for (let i = 0; i < 6; i++) {
+        table[0x41 + i] = 10 + i; // 'A'-'F'
+        table[0x61 + i] = 10 + i; // 'a'-'f'
+    }
+    return table;
+})();
+/**
+ * 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 function toHex(bytes) {
+    let result = '';
+    for (let i = 0; i < bytes.length; i++) {
+        result += BYTE_TO_HEX[bytes[i]];
+    }
+    return result;
+}
+/**
+ * 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 function fromHex(hex) {
+    // Strip 0x prefix if present
+    if (hex.length >= 2 && hex[0] === '0' && (hex[1] === 'x' || hex[1] === 'X')) {
+        hex = hex.slice(2);
+    }
+    const len = hex.length;
+    if (len % 2 !== 0) {
+        throw new TypeError('Invalid hex string: odd length');
+    }
+    const byteLength = len / 2;
+    const result = new Uint8Array(byteLength);
+    for (let i = 0; i < byteLength; i++) {
+        const charIndex = i * 2;
+        const highCode = hex.charCodeAt(charIndex);
+        const lowCode = hex.charCodeAt(charIndex + 1);
+        // Bounds check for lookup table
+        if (highCode >= 128 || lowCode >= 128) {
+            throw new TypeError(`Invalid hex character at position ${charIndex}`);
+        }
+        const high = HEX_TO_NIBBLE[highCode];
+        const low = HEX_TO_NIBBLE[lowCode];
+        if (high === -1) {
+            throw new TypeError(`Invalid hex character at position ${charIndex}`);
+        }
+        if (low === -1) {
+            throw new TypeError(`Invalid hex character at position ${charIndex + 1}`);
+        }
+        result[i] = (high << 4) | low;
+    }
+    return result;
+}
+/**
+ * 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 function isHex(value) {
+    let hex = value;
+    if (hex.length >= 2 && hex[0] === '0' && (hex[1] === 'x' || hex[1] === 'X')) {
+        hex = hex.slice(2);
+    }
+    if (hex.length % 2 !== 0) {
+        return false;
+    }
+    for (let i = 0; i < hex.length; i++) {
+        const code = hex.charCodeAt(i);
+        if (code >= 128 || HEX_TO_NIBBLE[code] === -1) {
+            return false;
+        }
+    }
+    return true;
+}
+//# sourceMappingURL=hex.js.map

package/build/io/hex.js.map

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

package/build/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/build/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/build/io/index.js

@@ -0,0 +1,23 @@
+/**
+ * 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';
+// Binary reading and writing
+export { BinaryReader } from './BinaryReader.js';
+export { BinaryWriter, GrowableBinaryWriter } from './BinaryWriter.js';
+// Hex encoding/decoding
+export { toHex, fromHex, isHex } from './hex.js';
+// Base64 decoding
+export { fromBase64 } from './base64.js';
+// Utility functions
+export { concat, equals, compare, isZero, clone, reverse, reverseCopy, alloc, xor, fromUtf8, toUtf8, } from './utils.js';
+// Memory pools
+export { MemoryPool, SimpleMemoryPool } from './MemoryPool.js';
+// Re-export varuint for Bitcoin CompactSize encoding
+export { varuint };
+//# sourceMappingURL=index.js.map

package/build/io/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/io/index.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,KAAK,OAAO,MAAM,iBAAiB,CAAC;AAE3C,6BAA6B;AAC7B,OAAO,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAC;AACjD,OAAO,EAAE,YAAY,EAAE,oBAAoB,EAAE,MAAM,mBAAmB,CAAC;AAEvE,wBAAwB;AACxB,OAAO,EAAE,KAAK,EAAE,OAAO,EAAE,KAAK,EAAE,MAAM,UAAU,CAAC;AAEjD,kBAAkB;AAClB,OAAO,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AAEzC,oBAAoB;AACpB,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;AAEpB,eAAe;AACf,OAAO,EAAE,UAAU,EAAE,gBAAgB,EAAE,MAAM,iBAAiB,CAAC;AAE/D,qDAAqD;AACrD,OAAO,EAAE,OAAO,EAAE,CAAC"}

package/build/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/build/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/build/io/utils.js

@@ -0,0 +1,271 @@
+/**
+ * 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 function concat(arrays) {
+    let totalLength = 0;
+    for (let i = 0; i < arrays.length; i++) {
+        totalLength += arrays[i].length;
+    }
+    const result = new Uint8Array(totalLength);
+    let offset = 0;
+    for (let i = 0; i < arrays.length; i++) {
+        const arr = arrays[i];
+        result.set(arr, offset);
+        offset += arr.length;
+    }
+    return result;
+}
+/**
+ * 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 function equals(a, b) {
+    if (a.length !== b.length) {
+        return false;
+    }
+    for (let i = 0; i < a.length; i++) {
+        if (a[i] !== b[i]) {
+            return false;
+        }
+    }
+    return true;
+}
+/**
+ * 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 function compare(a, b) {
+    const minLength = Math.min(a.length, b.length);
+    for (let i = 0; i < minLength; i++) {
+        const diff = a[i] - b[i];
+        if (diff !== 0) {
+            return diff;
+        }
+    }
+    return a.length - b.length;
+}
+/**
+ * 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 function isZero(bytes) {
+    for (let i = 0; i < bytes.length; i++) {
+        if (bytes[i] !== 0) {
+            return false;
+        }
+    }
+    return true;
+}
+/**
+ * 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 function clone(bytes) {
+    // Create a true copy - .slice() on Buffer returns a view, not a copy
+    const copy = new Uint8Array(bytes.length);
+    copy.set(bytes);
+    return copy;
+}
+/**
+ * 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 function reverse(bytes) {
+    bytes.reverse();
+    return bytes;
+}
+/**
+ * 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 function reverseCopy(bytes) {
+    const result = new Uint8Array(bytes.length);
+    for (let i = 0; i < bytes.length; i++) {
+        result[i] = bytes[bytes.length - 1 - i];
+    }
+    return result;
+}
+/**
+ * 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 function alloc(size, fill = 0) {
+    const result = new Uint8Array(size);
+    if (fill !== 0) {
+        result.fill(fill);
+    }
+    return result;
+}
+/**
+ * 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 function xor(a, b) {
+    if (a.length !== b.length) {
+        throw new TypeError('Arrays must have the same length for XOR operation');
+    }
+    const result = new Uint8Array(a.length);
+    for (let i = 0; i < a.length; i++) {
+        result[i] = a[i] ^ b[i];
+    }
+    return result;
+}
+/**
+ * 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 function fromUtf8(str) {
+    return new TextEncoder().encode(str);
+}
+/**
+ * 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 function toUtf8(bytes) {
+    return new TextDecoder().decode(bytes);
+}
+//# sourceMappingURL=utils.js.map

package/build/io/utils.js.map

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

package/build/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/build/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"}