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

package/src/block.ts

@@ -1,49 +1,91 @@
-import { BufferReader, BufferWriter, reverseBuffer, varuint } from './bufferutils.js';
 import * as bcrypto from './crypto.js';
+import {
+    alloc,
+    BinaryReader,
+    BinaryWriter,
+    compare,
+    equals,
+    fromHex,
+    reverse,
+    toHex,
+    varuint,
+} from './io/index.js';
 import { fastMerkleRoot } from './merkle.js';
 import { Transaction } from './transaction.js';
-import * as types from './types.js';
-
-const { typeforce } = types;
+import type { Bytes32 } from './types.js';
 
 const errorMerkleNoTxes = new TypeError('Cannot compute merkle root for zero transactions');
 const errorWitnessNotSegwit = new TypeError('Cannot compute witness commit for non-segwit block');
 
+const WITNESS_COMMIT_PREFIX = fromHex('6a24aa21a9ed');
+
+/**
+ * Represents a Bitcoin block with header fields and optional transactions.
+ *
+ * @example
+ * ```typescript
+ * import { Block, fromHex } from '@btc-vision/bitcoin';
+ *
+ * // Parse a block from hex
+ * const block = Block.fromHex('0100000000000000...');
+ *
+ * // Access block properties
+ * console.log(block.version);
+ * console.log(block.getId());
+ * console.log(block.timestamp);
+ *
+ * // Check proof of work
+ * if (block.checkProofOfWork()) {
+ *     console.log('Valid PoW');
+ * }
+ * ```
+ */
 export class Block {
+    /** Block version number */
     version: number = 1;
-    prevHash?: Buffer = undefined;
-    merkleRoot?: Buffer = undefined;
+    /** Hash of the previous block (32 bytes) */
+    prevHash?: Bytes32 = undefined;
+    /** Merkle root of the transactions (32 bytes) */
+    merkleRoot?: Bytes32 = undefined;
+    /** Block timestamp (Unix time) */
     timestamp: number = 0;
-    witnessCommit?: Buffer = undefined;
+    /** Witness commitment for SegWit blocks (32 bytes) */
+    witnessCommit?: Bytes32 = undefined;
+    /** Compact representation of the target threshold */
     bits: number = 0;
+    /** Nonce used for proof of work */
     nonce: number = 0;
+    /** Array of transactions included in the block */
     transactions?: Transaction[] = undefined;
 
-    static fromBuffer(buffer: Buffer): Block {
+    /**
+     * Parses a Block from a Uint8Array.
+     * @param buffer - The raw block data (minimum 80 bytes for header only)
+     * @returns Parsed Block instance
+     * @throws Error if buffer is too small
+     */
+    static fromBuffer(buffer: Uint8Array): Block {
         if (buffer.length < 80) throw new Error('Buffer too small (< 80 bytes)');
 
-        const bufferReader = new BufferReader(buffer);
+        const reader = new BinaryReader(buffer);
 
         const block = new Block();
-        block.version = bufferReader.readInt32();
-        block.prevHash = bufferReader.readSlice(32);
-        block.merkleRoot = bufferReader.readSlice(32);
-        block.timestamp = bufferReader.readUInt32();
-        block.bits = bufferReader.readUInt32();
-        block.nonce = bufferReader.readUInt32();
+        block.version = reader.readInt32LE();
+        block.prevHash = reader.readBytes(32) as Bytes32;
+        block.merkleRoot = reader.readBytes(32) as Bytes32;
+        block.timestamp = reader.readUInt32LE();
+        block.bits = reader.readUInt32LE();
+        block.nonce = reader.readUInt32LE();
 
         if (buffer.length === 80) return block;
 
         const readTransaction = (): Transaction => {
-            const tx = Transaction.fromBuffer(
-                bufferReader.buffer.subarray(bufferReader.offset),
-                true,
-            );
-            bufferReader.offset += tx.byteLength();
+            const tx = Transaction.fromBuffer(reader.data.subarray(reader.offset), true);
+            reader.offset += tx.byteLength();
             return tx;
         };
 
-        const nTransactions = bufferReader.readVarInt();
+        const nTransactions = reader.readVarInt();
         block.transactions = [];
 
         for (let i = 0; i < nTransactions; ++i) {
@@ -58,20 +100,43 @@ export class Block {
         return block;
     }
 
+    /**
+     * Parses a Block from a hex string.
+     * @param hex - Hexadecimal representation of the block
+     * @returns Parsed Block instance
+     */
     static fromHex(hex: string): Block {
-        return Block.fromBuffer(Buffer.from(hex, 'hex'));
+        return Block.fromBuffer(fromHex(hex));
     }
 
-    static calculateTarget(bits: number): Buffer {
+    /**
+     * Calculates the target threshold from the compact bits representation.
+     * @param bits - Compact bits value from block header
+     * @returns 32-byte target threshold
+     */
+    static calculateTarget(bits: number): Bytes32 {
         const exponent = ((bits & 0xff000000) >> 24) - 3;
         const mantissa = bits & 0x007fffff;
-        const target = Buffer.alloc(32, 0);
-        target.writeUIntBE(mantissa, 29 - exponent, 3);
-        return target;
+        const target = alloc(32);
+        // Write mantissa as big-endian at the computed offset
+        const offset = 29 - exponent;
+        target[offset] = (mantissa >> 16) & 0xff;
+        target[offset + 1] = (mantissa >> 8) & 0xff;
+        target[offset + 2] = mantissa & 0xff;
+        return target as Bytes32;
     }
 
-    static calculateMerkleRoot(transactions: Transaction[], forWitness?: boolean): Buffer {
-        typeforce([{ getHash: types.Function }], transactions);
+    /**
+     * Calculates the merkle root for a list of transactions.
+     * @param transactions - Array of transactions
+     * @param forWitness - If true, calculate witness merkle root (for SegWit)
+     * @returns 32-byte merkle root hash
+     * @throws TypeError if transactions is empty or not an array
+     */
+    static calculateMerkleRoot(transactions: Transaction[], forWitness?: boolean): Bytes32 {
+        if (!Array.isArray(transactions)) {
+            throw new TypeError('Expected an array of transactions');
+        }
         if (transactions.length === 0) throw errorMerkleNoTxes;
         if (forWitness && !txesHaveWitnessCommit(transactions)) throw errorWitnessNotSegwit;
 
@@ -79,45 +144,74 @@ export class Block {
 
         const rootHash = fastMerkleRoot(hashes, bcrypto.hash256);
 
-        return forWitness
-            ? bcrypto.hash256(Buffer.concat([rootHash, transactions[0].ins[0].witness[0]]))
-            : rootHash;
+        if (forWitness) {
+            const witness = transactions[0]!.ins[0]!.witness![0]!;
+            const combined = new Uint8Array(rootHash.length + witness.length);
+            combined.set(rootHash);
+            combined.set(witness, rootHash.length);
+            return bcrypto.hash256(combined) as Bytes32;
+        }
+        return rootHash as Bytes32;
     }
 
-    getWitnessCommit(): Buffer | null {
-        if (!txesHaveWitnessCommit(this.transactions!)) return null;
+    /**
+     * Extracts the witness commitment from the coinbase transaction.
+     * @returns 32-byte witness commitment or null if not found
+     */
+    getWitnessCommit(): Bytes32 | null {
+        if (!this.transactions || !txesHaveWitnessCommit(this.transactions)) return null;
 
         // The merkle root for the witness data is in an OP_RETURN output.
         // There is no rule for the index of the output, so use filter to find it.
         // The root is prepended with 0xaa21a9ed so check for 0x6a24aa21a9ed
         // If multiple commits are found, the output with highest index is assumed.
-        const witnessCommits = this.transactions![0].outs.filter((out) =>
-            out.script.subarray(0, 6).equals(Buffer.from('6a24aa21a9ed', 'hex')),
+        const witnessCommits = this.transactions[0]!.outs.filter((out) =>
+            equals(out.script.subarray(0, 6), WITNESS_COMMIT_PREFIX),
         ).map((out) => out.script.subarray(6, 38));
         if (witnessCommits.length === 0) return null;
         // Use the commit with the highest output (should only be one though)
         const result = witnessCommits[witnessCommits.length - 1];
 
-        if (!(result instanceof Buffer && result.length === 32)) return null;
-        return result;
+        if (!(result instanceof Uint8Array && result.length === 32)) return null;
+        return result as Bytes32;
     }
 
+    /**
+     * Checks if this block has a witness commitment.
+     * @returns True if the block has a witness commitment
+     */
     hasWitnessCommit(): boolean {
-        if (this.witnessCommit instanceof Buffer && this.witnessCommit.length === 32) return true;
+        if (this.witnessCommit instanceof Uint8Array && this.witnessCommit.length === 32)
+            return true;
         if (this.getWitnessCommit() !== null) return true;
         return false;
     }
 
+    /**
+     * Checks if any transaction in this block has witness data.
+     * @returns True if any transaction has witness data
+     */
     hasWitness(): boolean {
-        return anyTxHasWitness(this.transactions!);
+        return this.transactions ? anyTxHasWitness(this.transactions) : false;
     }
 
+    /**
+     * Calculates the weight of this block.
+     * Weight = (base size * 3) + total size
+     * @returns Block weight in weight units
+     */
     weight(): number {
         const base = this.byteLength(false, false);
         const total = this.byteLength(false, true);
         return base * 3 + total;
     }
 
+    /**
+     * Calculates the serialized byte length of this block.
+     * @param headersOnly - If true, return only header size (80 bytes)
+     * @param allowWitness - If true, include witness data in calculation
+     * @returns Byte length of the serialized block
+     */
     byteLength(headersOnly?: boolean, allowWitness: boolean = true): number {
         if (headersOnly || !this.transactions) return 80;
 
@@ -128,14 +222,26 @@ export class Block {
         );
     }
 
-    getHash(): Buffer {
+    /**
+     * Computes the double-SHA256 hash of the block header.
+     * @returns 32-byte block hash
+     */
+    getHash(): Bytes32 {
         return bcrypto.hash256(this.toBuffer(true));
     }
 
+    /**
+     * Returns the block ID (hash in reversed hex format, as displayed in block explorers).
+     * @returns Block ID as hex string
+     */
     getId(): string {
-        return reverseBuffer(this.getHash()).toString('hex');
+        return toHex(reverse(this.getHash()));
     }
 
+    /**
+     * Converts the block timestamp to a Date object.
+     * @returns UTC date of the block
+     */
     getUTCDate(): Date {
         const date = new Date(0); // epoch
         date.setUTCSeconds(this.timestamp);
@@ -143,94 +249,107 @@ export class Block {
         return date;
     }
 
-    // TODO: buffer, offset compatibility
-    toBuffer(headersOnly?: boolean): Buffer {
-        const buffer: Buffer = Buffer.allocUnsafe(this.byteLength(headersOnly));
+    /**
+     * Serializes the block to a Uint8Array.
+     * @param headersOnly - If true, only serialize the 80-byte header
+     * @returns Serialized block data
+     */
+    toBuffer(headersOnly?: boolean): Uint8Array {
+        if (!this.prevHash) throw new TypeError('Block prevHash is required');
+        if (!this.merkleRoot) throw new TypeError('Block merkleRoot is required');
 
-        const bufferWriter = new BufferWriter(buffer);
+        const buffer = new Uint8Array(this.byteLength(headersOnly));
 
-        bufferWriter.writeInt32(this.version);
-        bufferWriter.writeSlice(this.prevHash!);
-        bufferWriter.writeSlice(this.merkleRoot!);
-        bufferWriter.writeUInt32(this.timestamp);
-        bufferWriter.writeUInt32(this.bits);
-        bufferWriter.writeUInt32(this.nonce);
+        const writer = new BinaryWriter(buffer);
+
+        writer.writeInt32LE(this.version);
+        writer.writeBytes(this.prevHash);
+        writer.writeBytes(this.merkleRoot);
+        writer.writeUInt32LE(this.timestamp);
+        writer.writeUInt32LE(this.bits);
+        writer.writeUInt32LE(this.nonce);
 
         if (headersOnly || !this.transactions) return buffer;
 
-        const encoded = varuint.encode(this.transactions.length, buffer, bufferWriter.offset);
-        bufferWriter.offset += encoded.bytes;
+        writer.writeVarInt(this.transactions.length);
 
         this.transactions.forEach((tx) => {
             const txSize = tx.byteLength(); // TODO: extract from toBuffer?
-            tx.toBuffer(buffer, bufferWriter.offset);
-            bufferWriter.offset += txSize;
+            tx.toBuffer(buffer.subarray(writer.offset));
+            writer.offset += txSize;
         });
 
         return buffer;
     }
 
+    /**
+     * Serializes the block to a hex string.
+     * @param headersOnly - If true, only serialize the 80-byte header
+     * @returns Hex string representation of the block
+     */
     toHex(headersOnly?: boolean): string {
-        return this.toBuffer(headersOnly).toString('hex');
+        return toHex(this.toBuffer(headersOnly));
     }
 
+    /**
+     * Validates the merkle root and witness commitment (if present).
+     * @returns True if the transaction roots are valid
+     */
     checkTxRoots(): boolean {
         // If the Block has segwit transactions but no witness commit,
         // there's no way it can be valid, so fail the check.
         const hasWitnessCommit = this.hasWitnessCommit();
         if (!hasWitnessCommit && this.hasWitness()) return false;
-        return this.__checkMerkleRoot() && (hasWitnessCommit ? this.__checkWitnessCommit() : true);
+        return this.#checkMerkleRoot() && (hasWitnessCommit ? this.#checkWitnessCommit() : true);
     }
 
+    /**
+     * Validates that the block hash meets the target threshold (proof of work).
+     * @returns True if the block's proof of work is valid
+     */
     checkProofOfWork(): boolean {
-        const hash: Buffer = reverseBuffer(this.getHash());
+        const hash = reverse(this.getHash());
         const target = Block.calculateTarget(this.bits);
 
-        return hash.compare(target) <= 0;
+        return compare(hash, target) <= 0;
     }
 
-    private __checkMerkleRoot(): boolean {
+    #checkMerkleRoot(): boolean {
         if (!this.transactions) throw errorMerkleNoTxes;
+        if (!this.merkleRoot) throw new TypeError('Block merkleRoot is required');
 
         const actualMerkleRoot = Block.calculateMerkleRoot(this.transactions);
-        return this.merkleRoot!.compare(actualMerkleRoot) === 0;
+        return compare(this.merkleRoot, actualMerkleRoot) === 0;
     }
 
-    private __checkWitnessCommit(): boolean {
+    #checkWitnessCommit(): boolean {
         if (!this.transactions) throw errorMerkleNoTxes;
         if (!this.hasWitnessCommit()) throw errorWitnessNotSegwit;
+        if (!this.witnessCommit) throw errorWitnessNotSegwit;
 
         const actualWitnessCommit = Block.calculateMerkleRoot(this.transactions, true);
-        return this.witnessCommit!.compare(actualWitnessCommit) === 0;
+        return compare(this.witnessCommit, actualWitnessCommit) === 0;
     }
 }
 
+/**
+ * Checks if the coinbase transaction has witness data (required for witness commitment).
+ * @param transactions - Array of transactions
+ * @returns True if coinbase has witness data
+ */
 function txesHaveWitnessCommit(transactions: Transaction[]): boolean {
-    return (
-        transactions instanceof Array &&
-        transactions[0] &&
-        transactions[0].ins &&
-        transactions[0].ins instanceof Array &&
-        transactions[0].ins[0] &&
-        transactions[0].ins[0].witness &&
-        transactions[0].ins[0].witness instanceof Array &&
-        transactions[0].ins[0].witness.length > 0
-    );
+    const coinbase = transactions[0];
+    if (!coinbase?.ins?.[0]?.witness) return false;
+    return coinbase.ins[0].witness.length > 0;
 }
 
+/**
+ * Checks if any transaction in the array has witness data.
+ * @param transactions - Array of transactions
+ * @returns True if any transaction has witness data
+ */
 function anyTxHasWitness(transactions: Transaction[]): boolean {
-    return (
-        transactions instanceof Array &&
-        transactions.some(
-            (tx) =>
-                typeof tx === 'object' &&
-                tx.ins instanceof Array &&
-                tx.ins.some(
-                    (input) =>
-                        typeof input === 'object' &&
-                        input.witness instanceof Array &&
-                        input.witness.length > 0,
-                ),
-        )
+    return transactions.some((tx) =>
+        tx.ins?.some((input) => input.witness && input.witness.length > 0),
     );
 }

package/src/branded.ts

@@ -0,0 +1,18 @@
+/**
+ * Branded type definitions for type-safe primitives.
+ *
+ * @packageDocumentation
+ */
+
+declare const __brand: unique symbol;
+type Brand<T, B extends string> = T & { readonly [__brand]: B };
+
+export type Bytes32 = Brand<Uint8Array, 'Bytes32'>;
+export type Bytes20 = Brand<Uint8Array, 'Bytes20'>;
+export type PublicKey = Brand<Uint8Array, 'PublicKey'>;
+export type XOnlyPublicKey = Brand<Uint8Array, 'XOnlyPublicKey'>;
+export type Satoshi = Brand<bigint, 'Satoshi'>;
+export type PrivateKey = Brand<Uint8Array, 'PrivateKey'>;
+export type Signature = Brand<Uint8Array, 'Signature'>;
+export type SchnorrSignature = Brand<Uint8Array, 'SchnorrSignature'>;
+export type Script = Brand<Uint8Array, 'Script'>;

package/src/crypto.ts

@@ -1,32 +1,62 @@
 /**
- * A module for hashing functions.
- * include ripemd160、sha1、sha256、hash160、hash256、taggedHash
+ * Cryptographic hashing functions for Bitcoin.
+ * Includes ripemd160, sha1, sha256, hash160, hash256, and taggedHash.
  *
  * @packageDocumentation
  */
 import { ripemd160 as _ripemd160, sha1 as _sha1 } from '@noble/hashes/legacy.js';
 import { sha256 as _sha256 } from '@noble/hashes/sha2.js';
+import { concat } from './io/index.js';
+import type { Bytes20, Bytes32 } from './types.js';
 
-export function ripemd160(buffer: Buffer): Buffer {
-    return Buffer.from(_ripemd160(Uint8Array.from(buffer)));
+/**
+ * Computes RIPEMD-160 hash of the input.
+ * @param data - Input data
+ * @returns 20-byte hash (Bytes20)
+ */
+export function ripemd160(data: Uint8Array): Bytes20 {
+    return _ripemd160(data) as Bytes20;
 }
 
-export function sha1(buffer: Buffer): Buffer {
-    return Buffer.from(_sha1(Uint8Array.from(buffer)));
+/**
+ * Computes SHA-1 hash of the input.
+ * @param data - Input data
+ * @returns 20-byte hash (Bytes20)
+ */
+export function sha1(data: Uint8Array): Bytes20 {
+    return _sha1(data) as Bytes20;
 }
 
-export function sha256(buffer: Buffer): Buffer {
-    return Buffer.from(_sha256(Uint8Array.from(buffer)));
+/**
+ * Computes SHA-256 hash of the input.
+ * @param data - Input data
+ * @returns 32-byte hash (Bytes32)
+ */
+export function sha256(data: Uint8Array): Bytes32 {
+    return _sha256(data) as Bytes32;
 }
 
-export function hash160(buffer: Buffer): Buffer {
-    return Buffer.from(_ripemd160(_sha256(Uint8Array.from(buffer))));
+/**
+ * Computes HASH160 (RIPEMD160(SHA256(data))) of the input.
+ * @param data - Input data
+ * @returns 20-byte hash (Bytes20)
+ */
+export function hash160(data: Uint8Array): Bytes20 {
+    return _ripemd160(_sha256(data)) as Bytes20;
 }
 
-export function hash256(buffer: Buffer): Buffer {
-    return Buffer.from(_sha256(_sha256(Uint8Array.from(buffer))));
+/**
+ * Computes double SHA-256 hash of the input.
+ * @param data - Input data
+ * @returns 32-byte hash (Bytes32)
+ */
+export function hash256(data: Uint8Array): Bytes32 {
+    return _sha256(_sha256(data)) as Bytes32;
 }
 
+/**
+ * BIP340/Taproot tag names for tagged hashing.
+ */
 export const TAGS = [
     'BIP0340/challenge',
     'BIP0340/aux',
@@ -38,63 +68,65 @@ export const TAGS = [
     'KeyAgg list',
     'KeyAgg coefficient',
 ] as const;
+
 export type TaggedHashPrefix = (typeof TAGS)[number];
+
 type TaggedHashPrefixes = {
-    [key in TaggedHashPrefix]: Buffer;
+    [key in TaggedHashPrefix]: Uint8Array;
 };
-/** An object mapping tags to their tagged hash prefix of [SHA256(tag) | SHA256(tag)] */
+
 /**
- * Defines the tagged hash prefixes used in the crypto module.
+ * Precomputed tagged hash prefixes: SHA256(tag) || SHA256(tag)
  */
 export const TAGGED_HASH_PREFIXES: TaggedHashPrefixes = {
-    'BIP0340/challenge': Buffer.from([
+    'BIP0340/challenge': new Uint8Array([
         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([
+    'BIP0340/aux': new Uint8Array([
         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([
+    'BIP0340/nonce': new Uint8Array([
         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([
+    TapLeaf: new Uint8Array([
         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([
+    TapBranch: new Uint8Array([
         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([
+    TapSighash: new Uint8Array([
         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([
+    TapTweak: new Uint8Array([
         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([
+    'KeyAgg list': new Uint8Array([
         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([
+    'KeyAgg coefficient': new Uint8Array([
         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,
@@ -102,6 +134,12 @@ export const TAGGED_HASH_PREFIXES: TaggedHashPrefixes = {
     ]),
 };
 
-export function taggedHash(prefix: TaggedHashPrefix, data: Buffer): Buffer {
-    return sha256(Buffer.concat([TAGGED_HASH_PREFIXES[prefix], data]));
+/**
+ * Computes a BIP340-style tagged hash.
+ * @param prefix - The tag name
+ * @param data - Input data
+ * @returns 32-byte hash (Bytes32)
+ */
+export function taggedHash(prefix: TaggedHashPrefix, data: Uint8Array): Bytes32 {
+    return sha256(concat([TAGGED_HASH_PREFIXES[prefix], data]));
 }