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

package/src/io/utils.ts

@@ -0,0 +1,283 @@
+/**
+ * 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: readonly Uint8Array[]): Uint8Array {
+    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: Uint8Array, b: Uint8Array): boolean {
+    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: Uint8Array, b: Uint8Array): number {
+    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: Uint8Array): boolean {
+    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: Uint8Array): Uint8Array {
+    // 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: Uint8Array): Uint8Array {
+    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: Uint8Array): Uint8Array {
+    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: number, fill: number = 0): Uint8Array {
+    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: Uint8Array, b: Uint8Array): Uint8Array {
+    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: string): Uint8Array {
+    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: Uint8Array): string {
+    return new TextDecoder().decode(bytes);
+}

package/src/merkle.ts

@@ -1,12 +1,15 @@
 /**
- * Calculates the Merkle root of an array of buffers using a specified digest function.
+ * Calculates the Merkle root of an array of Uint8Arrays using a specified digest function.
  *
- * @param values - The array of buffers.
- * @param digestFn - The digest function used to calculate the hash of the concatenated buffers.
- * @returns The Merkle root as a buffer.
+ * @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 function fastMerkleRoot(values: Buffer[], digestFn: (b: Buffer) => Buffer): Buffer {
+export function fastMerkleRoot(
+    values: Uint8Array[],
+    digestFn: (b: Uint8Array) => Uint8Array,
+): Uint8Array {
     if (!Array.isArray(values)) throw TypeError('Expected values Array');
     if (typeof digestFn !== 'function') throw TypeError('Expected digest Function');
 
@@ -17,9 +20,11 @@ export function fastMerkleRoot(values: Buffer[], digestFn: (b: Buffer) => Buffer
         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]);
+            const left = results[i]!;
+            const right = i + 1 === length ? left : results[i + 1]!;
+            const data = new Uint8Array(left.length + right.length);
+            data.set(left);
+            data.set(right, left.length);
 
             results[j] = digestFn(data);
         }
@@ -27,5 +32,5 @@ export function fastMerkleRoot(values: Buffer[], digestFn: (b: Buffer) => Buffer
         length = j;
     }
 
-    return results[0];
+    return results[0]!;
 }

package/src/networks.ts

@@ -8,18 +8,18 @@
  */
 
 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;
 }
 
 /**

package/src/payments/bip341.ts

@@ -1,26 +1,25 @@
-import { Buffer as NBuffer } from 'buffer';
 import * as bcrypto from '../crypto.js';
-import { getEccLib } from '../ecc_lib.js';
-
-import { varuint } from '../bufferutils.js';
-import { isTapleaf, Tapleaf, Taptree } from '../types.js';
+import { getEccLib } from '../ecc/context.js';
+import { alloc, compare, concat, equals, varuint } from '../io/index.js';
+import type { Bytes32, Tapleaf, Taptree, XOnlyPublicKey } from '../types.js';
+import { isTapleaf } from '../types.js';
 
 export const LEAF_VERSION_TAPSCRIPT = 0xc0;
 export const MAX_TAPTREE_DEPTH = 128;
 
 interface HashLeaf {
-    hash: Buffer;
+    hash: Bytes32;
 }
 
 interface HashBranch {
-    hash: Buffer;
+    hash: Bytes32;
     left: HashTree;
     right: HashTree;
 }
 
 interface TweakedPublicKey {
     parity: number;
-    x: Buffer;
+    x: XOnlyPublicKey;
 }
 
 const isHashBranch = (ht: HashTree): ht is HashBranch => 'left' in ht && 'right' in ht;
@@ -35,12 +34,12 @@ export type HashTree = HashLeaf | HashBranch;
 
 /**
  * Calculates the root hash from a given control block and leaf hash.
- * @param controlBlock - The control block buffer.
- * @param leafHash - The leaf hash buffer.
- * @returns The root hash buffer.
+ * @param controlBlock - The control block.
+ * @param leafHash - The leaf hash.
+ * @returns The root hash.
  * @throws {TypeError} If the control block length is less than 33.
  */
-export function rootHashFromPath(controlBlock: Buffer, leafHash: Buffer): Buffer {
+export function rootHashFromPath(controlBlock: Uint8Array, leafHash: Uint8Array): Bytes32 {
     if (controlBlock.length < 33)
         throw new TypeError(
             `The control-block length is too small. Got ${controlBlock.length}, expected min 33.`,
@@ -50,14 +49,14 @@ export function rootHashFromPath(controlBlock: Buffer, leafHash: Buffer): Buffer
     let kj = leafHash;
     for (let j = 0; j < m; j++) {
         const ej = controlBlock.subarray(33 + 32 * j, 65 + 32 * j);
-        if (kj.compare(ej) < 0) {
+        if (compare(kj, ej) < 0) {
             kj = tapBranchHash(kj, ej);
         } else {
             kj = tapBranchHash(ej, kj);
         }
     }
 
-    return kj;
+    return kj as Bytes32;
 }
 
 /**
@@ -68,13 +67,13 @@ export function toHashTree(scriptTree: Taptree): HashTree {
     if (isTapleaf(scriptTree)) return { hash: tapleafHash(scriptTree) };
 
     const hashes = [toHashTree(scriptTree[0]), toHashTree(scriptTree[1])];
-    hashes.sort((a, b) => a.hash.compare(b.hash));
+    hashes.sort((a, b) => compare(a.hash, b.hash));
     const [left, right] = hashes;
 
     return {
-        hash: tapBranchHash(left.hash, right.hash),
-        left,
-        right,
+        hash: tapBranchHash(left!.hash, right!.hash),
+        left: left!,
+        right: right!,
     };
 }
 
@@ -86,34 +85,34 @@ export function toHashTree(scriptTree: Taptree): HashTree {
  * (exclusive) needed to prove inclusion of the specified hash. undefined if no
  * path is found
  */
-export function findScriptPath(node: HashTree, hash: Buffer): Buffer[] | undefined {
+export function findScriptPath(node: HashTree, hash: Bytes32): Bytes32[] | undefined {
     if (isHashBranch(node)) {
         const leftPath = findScriptPath(node.left, hash);
         if (leftPath !== undefined) return [...leftPath, node.right.hash];
 
         const rightPath = findScriptPath(node.right, hash);
         if (rightPath !== undefined) return [...rightPath, node.left.hash];
-    } else if (node.hash.equals(hash)) {
+    } else if (equals(node.hash, hash)) {
         return [];
     }
 
     return undefined;
 }
 
-export function tapleafHash(leaf: Tapleaf): Buffer {
+export function tapleafHash(leaf: Tapleaf): Bytes32 {
     const version = leaf.version || LEAF_VERSION_TAPSCRIPT;
     return bcrypto.taggedHash(
         'TapLeaf',
-        NBuffer.concat([NBuffer.from([version]), serializeScript(leaf.output)]),
-    );
+        concat([new Uint8Array([version]), serializeScript(leaf.output)]),
+    ) as Bytes32;
 }
 
-export function tapTweakHash(pubKey: Buffer, h: Buffer | undefined): Buffer {
-    return bcrypto.taggedHash('TapTweak', NBuffer.concat(h ? [pubKey, h] : [pubKey]));
+export function tapTweakHash(pubKey: XOnlyPublicKey, h: Bytes32 | undefined): Bytes32 {
+    return bcrypto.taggedHash('TapTweak', h ? concat([pubKey, h]) : pubKey) as Bytes32;
 }
 
-export function tweakKey(pubKey: Buffer, h: Buffer | undefined): TweakedPublicKey | null {
-    if (!NBuffer.isBuffer(pubKey)) return null;
+export function tweakKey(pubKey: XOnlyPublicKey, h: Bytes32 | undefined): TweakedPublicKey | null {
+    if (!(pubKey instanceof Uint8Array)) return null;
     if (pubKey.length !== 32) return null;
     if (h && h.length !== 32) return null;
 
@@ -124,17 +123,17 @@ export function tweakKey(pubKey: Buffer, h: Buffer | undefined): TweakedPublicKe
 
     return {
         parity: res.parity,
-        x: NBuffer.from(res.xOnlyPubkey),
+        x: new Uint8Array(res.xOnlyPubkey) as XOnlyPublicKey,
     };
 }
 
-function tapBranchHash(a: Buffer, b: Buffer): Buffer {
-    return bcrypto.taggedHash('TapBranch', NBuffer.concat([a, b]));
+function tapBranchHash(a: Uint8Array, b: Uint8Array): Bytes32 {
+    return bcrypto.taggedHash('TapBranch', concat([a, b])) as Bytes32;
 }
 
-function serializeScript(s: Buffer): Buffer {
+function serializeScript(s: Uint8Array): Uint8Array {
     const varintLen = varuint.encodingLength(s.length);
-    const buffer = NBuffer.allocUnsafe(varintLen); // better
+    const buffer = alloc(varintLen);
     varuint.encode(s.length, buffer);
-    return NBuffer.concat([buffer, s]);
+    return concat([buffer, s]);
 }