@btc-vision/transaction 1.8.0-beta.0 → 1.8.0-beta.10

package/src/buffer/BinaryWriter.ts

@@ -18,10 +18,10 @@ import {
     U64_BYTE_LENGTH,
     U8_BYTE_LENGTH,
 } from '../utils/lengths.js';
-import { i16, i32, i64, i8, Selector, u16, u32, u64, u8 } from '../utils/types.js';
+import type { i16, i32, i64, i8, Selector, u16, u32, u64, u8 } from '../utils/types.js';
 import { BinaryReader } from './BinaryReader.js';
 
-export class BinaryWriter {
+export class BinaryWriter implements Disposable {
     private currentOffset: u32 = 0;
     private buffer: DataView;
 
@@ -34,7 +34,7 @@ export class BinaryWriter {
         let totalLength: u32 = U16_BYTE_LENGTH;
 
         for (let i = 0; i < values.length; i++) {
-            totalLength += U32_BYTE_LENGTH + values[i].length; // each entry has a u32 length prefix
+            totalLength += U32_BYTE_LENGTH + (values[i] as Uint8Array).length; // each entry has a u32 length prefix
         }
 
         return totalLength;
@@ -99,7 +99,8 @@ export class BinaryWriter {
      * Writes a signed 32-bit integer. By default big-endian (be = true).
      */
     public writeI32(value: i32, be: boolean = true): void {
-        if (value < -2147483648 || value > 2147483647) throw new Error('i32 value is out of range.');
+        if (value < -2147483648 || value > 2147483647)
+            throw new Error('i32 value is out of range.');
 
         this.allocSafe(I32_BYTE_LENGTH);
         this.buffer.setInt32(this.currentOffset, value, !be);
@@ -146,11 +147,11 @@ export class BinaryWriter {
 
         if (be) {
             for (let i = 0; i < bytesToHex.byteLength; i++) {
-                this.writeU8(bytesToHex[i]);
+                this.writeU8(bytesToHex[i] as number);
             }
         } else {
             for (let i = bytesToHex.byteLength - 1; i >= 0; i--) {
-                this.writeU8(bytesToHex[i]);
+                this.writeU8(bytesToHex[i] as number);
             }
         }
     }
@@ -173,11 +174,11 @@ export class BinaryWriter {
 
         if (be) {
             for (let i = 0; i < bytesToHex.byteLength; i++) {
-                this.writeU8(bytesToHex[i]);
+                this.writeU8(bytesToHex[i] as number);
             }
         } else {
             for (let i = bytesToHex.byteLength - 1; i >= 0; i--) {
-                this.writeU8(bytesToHex[i]);
+                this.writeU8(bytesToHex[i] as number);
             }
         }
     }
@@ -196,11 +197,11 @@ export class BinaryWriter {
 
         if (be) {
             for (let i = 0; i < bytesToHex.byteLength; i++) {
-                this.writeU8(bytesToHex[i]);
+                this.writeU8(bytesToHex[i] as number);
             }
         } else {
             for (let i = bytesToHex.byteLength - 1; i >= 0; i--) {
-                this.writeU8(bytesToHex[i]);
+                this.writeU8(bytesToHex[i] as number);
             }
         }
     }
@@ -209,7 +210,7 @@ export class BinaryWriter {
         this.allocSafe(value.byteLength);
 
         for (let i = 0; i < value.byteLength; i++) {
-            this.writeU8(value[i]);
+            this.writeU8(value[i] as number);
         }
     }
 
@@ -322,6 +323,10 @@ export class BinaryWriter {
         this.buffer = this.getDefaultBuffer();
     }
 
+    public [Symbol.dispose](): void {
+        this.clear();
+    }
+
     public allocSafe(size: u32): void {
         if (this.currentOffset + size > this.buffer.byteLength) {
             this.resize(size);
@@ -335,7 +340,7 @@ export class BinaryWriter {
 
         const keys = Array.from(map.keys());
         for (let i = 0; i < keys.length; i++) {
-            const key = keys[i];
+            const key = keys[i] as Address;
             const value = map.get(key);
 
             if (value === null || value === undefined) throw new Error('Value not found');
@@ -374,8 +379,8 @@ export class BinaryWriter {
         this.writeU16(values.length, be);
 
         for (let i = 0; i < values.length; i++) {
-            this.writeU32(values[i].length, be);
-            this.writeBytes(values[i]);
+            this.writeU32((values[i] as Uint8Array).length, be);
+            this.writeBytes(values[i] as Uint8Array);
         }
     }
 
@@ -385,7 +390,7 @@ export class BinaryWriter {
         this.writeU16(value.length);
 
         for (let i = 0; i < value.length; i++) {
-            this.writeAddress(value[i]);
+            this.writeAddress(value[i] as Address);
         }
     }
 
@@ -400,7 +405,7 @@ export class BinaryWriter {
         this.writeU16(value.length);
 
         for (let i = 0; i < value.length; i++) {
-            this.writeExtendedAddress(value[i]);
+            this.writeExtendedAddress(value[i] as Address);
         }
     }
 
@@ -410,7 +415,7 @@ export class BinaryWriter {
         this.writeU16(value.length, be);
 
         for (let i = 0; i < value.length; i++) {
-            this.writeU32(value[i], be);
+            this.writeU32(value[i] as u32, be);
         }
     }
 
@@ -420,7 +425,7 @@ export class BinaryWriter {
         this.writeU16(value.length, be);
 
         for (let i = 0; i < value.length; i++) {
-            this.writeU256(value[i], be);
+            this.writeU256(value[i] as bigint, be);
         }
     }
 
@@ -429,7 +434,7 @@ export class BinaryWriter {
 
         this.writeU16(value.length, be);
         for (let i = 0; i < value.length; i++) {
-            this.writeU128(value[i], be);
+            this.writeU128(value[i] as bigint, be);
         }
     }
 
@@ -439,7 +444,7 @@ export class BinaryWriter {
         this.writeU16(value.length);
 
         for (let i = 0; i < value.length; i++) {
-            this.writeStringWithLength(value[i]);
+            this.writeStringWithLength(value[i] as string);
         }
     }
 
@@ -449,7 +454,7 @@ export class BinaryWriter {
         this.writeU16(value.length, be);
 
         for (let i = 0; i < value.length; i++) {
-            this.writeU16(value[i], be);
+            this.writeU16(value[i] as u16, be);
         }
     }
 
@@ -459,7 +464,7 @@ export class BinaryWriter {
         this.writeU16(value.length);
 
         for (let i = 0; i < value.length; i++) {
-            this.writeU8(value[i]);
+            this.writeU8(value[i] as u8);
         }
     }
 
@@ -469,7 +474,7 @@ export class BinaryWriter {
         this.writeU16(value.length, be);
 
         for (let i = 0; i < value.length; i++) {
-            this.writeU64(value[i], be);
+            this.writeU64(value[i] as bigint, be);
         }
     }
 
@@ -479,7 +484,7 @@ export class BinaryWriter {
         this.writeU16(value.length);
 
         for (let i = 0; i < value.length; i++) {
-            this.writeBytesWithLength(value[i]);
+            this.writeBytesWithLength(value[i] as Uint8Array);
         }
     }
 

package/src/bytecode/Compressor.ts

@@ -1,4 +1,4 @@
-import zlib, { ZlibOptions } from 'zlib';
+import zlib, { type ZlibOptions } from 'zlib';
 
 /** Compressor class for compressing and decompressing data. */
 export class Compressor {

package/src/chain/ChainData.ts

@@ -1,32 +1,43 @@
-import { Network, networks } from '@btc-vision/bitcoin';
+import { type Network, networks } from '@btc-vision/bitcoin';
 
-function objectEqual<T>(obj1: T, obj2: T): boolean {
-    return JSON.stringify(obj1) === JSON.stringify(obj2);
+function networkKey(network: Network): string {
+    return `${network.messagePrefix}|${network.bech32}`;
 }
 
-export function getChainIdHex(network: Network): string {
-    if (objectEqual(network, networks.bitcoin)) {
-        return '000000000019d6689c085ae165831e934ff763ae46a2a6c172b3f1b60a8ce26f';
-    }
-
-    if (objectEqual(network, networks.testnet)) {
-        return '000000000933ea01ad0ee984209779baaec3ced90fa3f408719526f8d77f4943';
-    }
-
-    if (objectEqual(network, networks.regtest)) {
-        return '0f9188f13cb7b2c71f2a335e3a4fc328bf5beb436012afca590b1a11466e2206';
-    }
-
-    throw new Error('Unsupported network for chain ID retrieval');
-}
+const CHAIN_IDS: ReadonlyMap<string, Uint8Array> = new Map([
+    [
+        networkKey(networks.bitcoin),
+        new Uint8Array([
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x19, 0xd6, 0x68, 0x9c, 0x08, 0x5a, 0xe1, 0x65, 0x83,
+            0x1e, 0x93, 0x4f, 0xf7, 0x63, 0xae, 0x46, 0xa2, 0xa6, 0xc1, 0x72, 0xb3, 0xf1, 0xb6,
+            0x0a, 0x8c, 0xe2, 0x6f,
+        ]),
+    ],
+    [
+        networkKey(networks.testnet),
+        new Uint8Array([
+            0x00, 0x00, 0x00, 0x00, 0x09, 0x33, 0xea, 0x01, 0xad, 0x0e, 0xe9, 0x84, 0x20, 0x97,
+            0x79, 0xba, 0xae, 0xc3, 0xce, 0xd9, 0x0f, 0xa3, 0xf4, 0x08, 0x71, 0x95, 0x26, 0xf8,
+            0xd7, 0x7f, 0x49, 0x43,
+        ]),
+    ],
+    [
+        networkKey(networks.regtest),
+        new Uint8Array([
+            0x0f, 0x91, 0x88, 0xf1, 0x3c, 0xb7, 0xb2, 0xc7, 0x1f, 0x2a, 0x33, 0x5e, 0x3a, 0x4f,
+            0xc3, 0x28, 0xbf, 0x5b, 0xeb, 0x43, 0x60, 0x12, 0xaf, 0xca, 0x59, 0x0b, 0x1a, 0x11,
+            0x46, 0x6e, 0x22, 0x06,
+        ]),
+    ],
+]);
 
 export function getChainId(network: Network): Uint8Array {
-    return Uint8Array.from(Buffer.from(getChainIdHex(network), 'hex'));
+    const chainId = CHAIN_IDS.get(networkKey(network));
+    if (!chainId) throw new Error('Unsupported network for chain ID retrieval');
+    return chainId.slice();
 }
 
-export const BITCOIN_PROTOCOL_ID = Uint8Array.from(
-    Buffer.from(
-        'e784995a412d773988c4b8e333d7b39dfb3cabf118d0d645411a916ca2407939', // sha256("OP_NET")
-        'hex',
-    ),
-);
+export const BITCOIN_PROTOCOL_ID = new Uint8Array([
+    0xe7, 0x84, 0x99, 0x5a, 0x41, 0x2d, 0x77, 0x39, 0x88, 0xc4, 0xb8, 0xe3, 0x33, 0xd7, 0xb3, 0x9d,
+    0xfb, 0x3c, 0xab, 0xf1, 0x18, 0xd0, 0xd6, 0x45, 0x41, 0x1a, 0x91, 0x6c, 0xa2, 0x40, 0x79, 0x39,
+]);

package/src/consensus/ConsensusConfig.ts

@@ -1,5 +1,5 @@
 import { Consensus } from './Consensus.js';
-import { ConsensusConfig } from './IConsensusConfig.js';
+import type { ConsensusConfig } from './IConsensusConfig.js';
 import { RoswellConsensus } from './metadata/RoswellConsensus.js';
 
 export const OPNetConsensusConfig: { [key in Consensus]?: ConsensusConfig<key> } = {

package/src/consensus/IConsensusConfig.ts

@@ -9,21 +9,4 @@ export interface ConsensusConfig<T extends Consensus> {
 
     // The block height at which this consensus was enabled.
     readonly ENABLED_AT_BLOCK: bigint;
-
-    /** WBTC vaults */
-    // Defines the minimum amount that can be consolidated in a single transaction.
-    //readonly VAULT_MINIMUM_AMOUNT: bigint;
-
-    // Defines the requested minimum acceptance for joining UTXOs when an unwrap is being done.
-    // If the consolidate output going back to the vault is lower than this amount, the transaction will be rejected.
-    // User must pay for the consolidation, this help the network by having fewer UTXOs.
-    //readonly VAULT_NETWORK_CONSOLIDATION_ACCEPTANCE: bigint;
-
-    // Everytime an user wrap bitcoin, he prepays the fees for the consolidation at a maximum fee rate of the following determined value.
-    // If the fees are lower, the user will be refunded the difference.
-    // If the fees are higher, the user must pay the difference.
-    //readonly UNWRAP_CONSOLIDATION_PREPAID_FEES: bigint;
-
-    // The maximum fee rate for the consolidation.
-    //readonly UNWRAP_CONSOLIDATION_PREPAID_FEES_SAT: bigint;
 }

package/src/consensus/metadata/RoswellConsensus.ts

@@ -1,4 +1,4 @@
-import { ConsensusConfig } from '../IConsensusConfig.js';
+import type { ConsensusConfig } from '../IConsensusConfig.js';
 import { Consensus } from '../Consensus.js';
 
 export const RoswellConsensus: ConsensusConfig<Consensus.Roswell> = {
@@ -7,20 +7,4 @@ export const RoswellConsensus: ConsensusConfig<Consensus.Roswell> = {
 
     // The block height at which this consensus was enabled.
     ENABLED_AT_BLOCK: 0n,
-
-    // Defines the minimum amount that can be consolidated in a single transaction.
-    //VAULT_MINIMUM_AMOUNT: 200000n,
-
-    // Defines the requested minimum acceptance for joining UTXOs when an unwrap is being done.
-    // If the consolidate output going back to the vault is lower than this amount, the transaction will be rejected.
-    // User must pay for the consolidation, this help the network by having fewer UTXOs.
-    //VAULT_NETWORK_CONSOLIDATION_ACCEPTANCE: 200000n * 2n,
-
-    // Everytime an user wrap bitcoin, he prepays the fees for the consolidation at a maximum fee rate of the following determined value.
-    // If the fees are lower, the user will be refunded the difference.
-    // If the fees are higher, the user must pay the difference.
-    //UNWRAP_CONSOLIDATION_PREPAID_FEES: 250n,
-
-    // Equivalent to 56500 satoshis, calculated from UNWRAP_CONSOLIDATION_PREPAID_FEES.
-    //UNWRAP_CONSOLIDATION_PREPAID_FEES_SAT: 56500n,
 };

package/src/crypto/crypto-browser.js

@@ -1,8 +1,7 @@
 /* Browser Crypto Shims */
-import { hmac } from '@noble/hashes/hmac';
-import { pbkdf2 } from '@noble/hashes/pbkdf2';
-import { sha256 } from '@noble/hashes/sha256';
-import { sha512 } from '@noble/hashes/sha512';
+import { hmac } from '@noble/hashes/hmac.js';
+import { pbkdf2 } from '@noble/hashes/pbkdf2.js';
+import { sha256, sha512 } from '@noble/hashes/sha2.js';
 
 function assertArgument(check, message, name, value) {
     if (!check) {

package/src/deterministic/AddressMap.ts

@@ -1,7 +1,7 @@
 import { Address } from '../keypair/Address.js';
 import { FastMap } from './FastMap.js';
 
-export class AddressMap<V> {
+export class AddressMap<V> implements Disposable {
     private items: FastMap<bigint, V>;
 
     constructor(iterable?: ReadonlyArray<readonly [Address, V]> | null) {
@@ -42,6 +42,10 @@ export class AddressMap<V> {
         this.items.clear();
     }
 
+    public [Symbol.dispose](): void {
+        this.clear();
+    }
+
     public indexOf(address: Address): number {
         return this.items.indexOf(address.toBigInt());
     }

package/src/deterministic/AddressSet.ts

@@ -1,6 +1,6 @@
 import { Address } from '../keypair/Address.js';
 
-export class AddressSet {
+export class AddressSet implements Disposable {
     private items: Set<bigint>;
     private keys: Address[];
 
@@ -45,6 +45,10 @@ export class AddressSet {
         this.keys = [];
     }
 
+    public [Symbol.dispose](): void {
+        this.clear();
+    }
+
     public combine(set: AddressSet): AddressSet {
         const clone = this.clone();
 

package/src/deterministic/CustomMap.ts

@@ -1,4 +1,4 @@
-export class CustomMap<K, V> {
+export class CustomMap<K, V> implements Disposable {
     private static readonly INITIAL_CAPACITY = 16;
     private static readonly LOAD_FACTOR = 0.75;
 
@@ -76,6 +76,10 @@ export class CustomMap<K, V> {
         this._size = 0;
     }
 
+    public [Symbol.dispose](): void {
+        this.clear();
+    }
+
     public *entries(): MapIterator<[K, V]> {
         for (let i = 0; i < this.capacity; i++) {
             if (this.#keys[i] !== undefined && !this.deleted[i]) {
@@ -223,7 +227,7 @@ export class CustomMap<K, V> {
         let hash = 2166136261;
         for (let i = 0; i < Math.min(bytes.length, 100); i++) {
             // Cap at 100 bytes for performance
-            hash ^= bytes[i];
+            hash ^= bytes[i] as number;
             hash = Math.imul(hash, 16777619);
         }
         return hash;

package/src/deterministic/DeterministicMap.ts

@@ -1,6 +1,6 @@
-import { FastMap, PropertyExtendedKey } from './FastMap.js';
+import { FastMap, type PropertyExtendedKey } from './FastMap.js';
 
-export class DeterministicMap<K extends PropertyExtendedKey, V> {
+export class DeterministicMap<K extends PropertyExtendedKey, V> implements Disposable {
     private map: FastMap<K, V>;
     #keys: K[];
 
@@ -32,7 +32,7 @@ export class DeterministicMap<K extends PropertyExtendedKey, V> {
 
             while (left < right) {
                 const mid = Math.floor((left + right) / 2);
-                if (this.compareFn(this.#keys[mid], key) < 0) {
+                if (this.compareFn(this.#keys[mid] as K, key) < 0) {
                     left = mid + 1;
                 } else {
                     right = mid;
@@ -83,7 +83,7 @@ export class DeterministicMap<K extends PropertyExtendedKey, V> {
 
             while (left <= right) {
                 const mid = Math.floor((left + right) / 2);
-                const cmp = this.compareFn(this.#keys[mid], key);
+                const cmp = this.compareFn(this.#keys[mid] as K, key);
 
                 if (cmp === 0) {
                     // Found it, remove at this index
@@ -104,6 +104,10 @@ export class DeterministicMap<K extends PropertyExtendedKey, V> {
         this.#keys = [];
     }
 
+    public [Symbol.dispose](): void {
+        this.clear();
+    }
+
     public forEach(callback: (value: V, key: K, map: DeterministicMap<K, V>) => void): void {
         for (const key of this.#keys) {
             const value = this.map.get(key) as V;

package/src/deterministic/DeterministicSet.ts

@@ -1,4 +1,4 @@
-export class DeterministicSet<T> {
+export class DeterministicSet<T> implements Disposable {
     private elements: T[];
 
     constructor(private compareFn: (a: T, b: T) => number) {
@@ -44,6 +44,10 @@ export class DeterministicSet<T> {
         this.elements = [];
     }
 
+    public [Symbol.dispose](): void {
+        this.clear();
+    }
+
     public forEach(callback: (value: T, set: DeterministicSet<T>) => void): void {
         for (const value of this.elements) {
             callback(value, this);
@@ -64,7 +68,7 @@ export class DeterministicSet<T> {
 
         while (left < right) {
             const mid = Math.floor((left + right) / 2);
-            const cmp = this.compareFn(this.elements[mid], value);
+            const cmp = this.compareFn(this.elements[mid] as T, value);
 
             if (cmp === 0) {
                 return { found: true, index: mid };

package/src/deterministic/ExtendedAddressMap.ts

@@ -5,9 +5,10 @@ import { FastMap } from './FastMap.js';
  * A map implementation using Address with both MLDSA and tweaked keys.
  * Uses the tweaked public key for lookup/indexing, but stores the full Address.
  */
-export class ExtendedAddressMap<V> {
+export class ExtendedAddressMap<V> implements Disposable {
     // Store tweaked bigint -> index mapping for fast lookup
     private indexMap: FastMap<bigint, number>;
+
     // Store actual addresses and values
     private _keys: Address[] = [];
     private _values: V[] = [];
@@ -72,7 +73,7 @@ export class ExtendedAddressMap<V> {
         // Rebuild index map (indices shifted after splice)
         this.indexMap.clear();
         for (let i = 0; i < this._keys.length; i++) {
-            this.indexMap.set(this._keys[i].tweakedToBigInt(), i);
+            this.indexMap.set((this._keys[i] as Address).tweakedToBigInt(), i);
         }
 
         return true;
@@ -84,6 +85,10 @@ export class ExtendedAddressMap<V> {
         this._values = [];
     }
 
+    public [Symbol.dispose](): void {
+        this.clear();
+    }
+
     public indexOf(address: Address): number {
         const index = this.indexMap.get(address.tweakedToBigInt());
         return index !== undefined ? index : -1;
@@ -91,7 +96,7 @@ export class ExtendedAddressMap<V> {
 
     *entries(): IterableIterator<[Address, V]> {
         for (let i = 0; i < this._keys.length; i++) {
-            yield [this._keys[i], this._values[i]];
+            yield [this._keys[i] as Address, this._values[i] as V];
         }
     }
 
@@ -112,7 +117,7 @@ export class ExtendedAddressMap<V> {
         thisArg?: unknown,
     ): void {
         for (let i = 0; i < this._keys.length; i++) {
-            callback.call(thisArg, this._values[i], this._keys[i], this);
+            callback.call(thisArg, this._values[i] as V, this._keys[i] as Address, this);
         }
     }
 

package/src/deterministic/FastMap.ts

@@ -10,7 +10,7 @@ export type FastRecord<V> = {
 
 export type IndexKey = string | number;
 
-export class FastMap<K extends PropertyExtendedKey, V> {
+export class FastMap<K extends PropertyExtendedKey, V> implements Disposable {
     protected _keys: K[] = [];
     protected _values: FastRecord<V> = {};
 
@@ -47,13 +47,13 @@ export class FastMap<K extends PropertyExtendedKey, V> {
 
     public *values(): IterableIterator<V> {
         for (const key of this._keys) {
-            yield this._values[key as IndexKey];
+            yield this._values[key as IndexKey] as V;
         }
     }
 
     public *entries(): IterableIterator<[K, V]> {
         for (const key of this._keys) {
-            yield [key, this._values[key as IndexKey]];
+            yield [key, this._values[key as IndexKey] as V];
         }
     }
 
@@ -107,18 +107,22 @@ export class FastMap<K extends PropertyExtendedKey, V> {
         this._values = {};
     }
 
+    public [Symbol.dispose](): void {
+        this.clear();
+    }
+
     public forEach(
         callback: (value: V, key: K, map: FastMap<K, V>) => void,
         thisArg?: unknown,
     ): void {
         for (const key of this._keys) {
-            callback.call(thisArg, this._values[key as IndexKey], key, this);
+            callback.call(thisArg, this._values[key as IndexKey] as V, key, this);
         }
     }
 
     *[Symbol.iterator](): IterableIterator<[K, V]> {
         for (const key of this._keys) {
-            yield [key, this._values[key as IndexKey]];
+            yield [key, this._values[key as IndexKey] as V];
         }
     }
 }

package/src/ecc/backend.ts

@@ -0,0 +1,17 @@
+import { createNobleBackend, type CryptoBackend } from '@btc-vision/ecpair';
+import { type EccLib, initEccLib } from '@btc-vision/bitcoin';
+
+/**
+ * Shared noble-curves backend for all EC operations.
+ * Instantiated once and reused across the entire library.
+ */
+export const backend: CryptoBackend = createNobleBackend();
+
+/**
+ * EccLib is now a type alias for CryptoBackend.
+ * The backend can be used directly.
+ */
+export const eccLib: EccLib = backend;
+
+// Initialize the ECC library once at module load
+initEccLib(eccLib);

package/src/epoch/ChallengeSolution.ts

@@ -1,5 +1,5 @@
 import { stringToBuffer } from '../utils/StringToBuffer.js';
-import {
+import type {
     IChallengeSolution,
     IChallengeSubmission,
     IChallengeVerification,
@@ -76,7 +76,7 @@ export class ChallengeSolution implements IChallengeSolution {
     public readonly difficulty: number;
     public readonly verification: ChallengeVerification;
 
-    private readonly submission?: ChallengeSubmission;
+    private readonly submission?: ChallengeSubmission | undefined;
 
     constructor(data: RawChallenge) {
         this.epochNumber = BigInt(data.epochNumber);
@@ -170,7 +170,7 @@ export class ChallengeSolution implements IChallengeSolution {
      * Calculate the expected solution hash for this challenge
      * @returns {Promise<Buffer>} The calculated solution hash
      */
-    public calculateSolution(): Buffer {
+    public calculateSolution(): Uint8Array {
         return EpochValidator.calculateSolution(
             this.verification.targetChecksum,
             this.publicKey.toBuffer(),

package/src/epoch/interfaces/IChallengeSolution.ts

@@ -1,21 +1,21 @@
 import { Address } from '../../keypair/Address.js';
 
 export interface IChallengeVerification {
-    readonly epochHash: Buffer;
-    readonly epochRoot: Buffer;
-    readonly targetHash: Buffer;
-    readonly targetChecksum: Buffer;
+    readonly epochHash: Uint8Array;
+    readonly epochRoot: Uint8Array;
+    readonly targetHash: Uint8Array;
+    readonly targetChecksum: Uint8Array;
     readonly startBlock: bigint;
     readonly endBlock: bigint;
-    readonly proofs: readonly Buffer[];
+    readonly proofs: readonly Uint8Array[];
 }
 
 export interface IChallengeSolution {
     readonly epochNumber: bigint;
     readonly publicKey: Address;
-    readonly solution: Buffer;
-    readonly salt: Buffer;
-    readonly graffiti: Buffer;
+    readonly solution: Uint8Array;
+    readonly salt: Uint8Array;
+    readonly graffiti: Uint8Array;
     readonly difficulty: number;
     readonly verification: IChallengeVerification;
 
@@ -23,9 +23,9 @@ export interface IChallengeSolution {
     getSubmission(): IChallengeSubmission | undefined;
     toRaw(): RawChallenge;
     verify(): boolean;
-    toBuffer(): Buffer;
+    toBuffer(): Uint8Array;
     toHex(): string;
-    calculateSolution(): Buffer;
+    calculateSolution(): Uint8Array;
     checkDifficulty(minDifficulty: number): { valid: boolean; difficulty: number };
     getMiningTargetBlock(): bigint | null;
 }
@@ -50,9 +50,9 @@ export interface RawChallengeSubmission {
 
 export interface IChallengeSubmission {
     readonly publicKey: Address;
-    readonly solution: Buffer;
-    readonly graffiti: Buffer | undefined;
-    readonly signature: Buffer;
+    readonly solution: Uint8Array;
+    readonly graffiti: Uint8Array | undefined;
+    readonly signature: Uint8Array;
     readonly epochNumber: bigint;
     verifySignature(): boolean;
 }