@btc-vision/transaction 1.8.0-beta.1 → 1.8.0-beta.4

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;
 }

package/src/epoch/validator/EpochValidator.ts

@@ -1,44 +1,34 @@
-import { IChallengeSolution, RawChallenge } from '../interfaces/IChallengeSolution.js';
-import { crypto } from '@btc-vision/bitcoin';
+import type { IChallengeSolution, RawChallenge } from '../interfaces/IChallengeSolution.js';
+import { crypto, equals } from '@btc-vision/bitcoin';
 import { Address } from '../../keypair/Address.js';
 import { stringToBuffer } from '../../utils/StringToBuffer.js';
 
 export class EpochValidator {
     private static readonly BLOCKS_PER_EPOCH: bigint = 5n;
 
-    /**
-     * Convert Buffer to Uint8Array
-     */
-    public static bufferToUint8Array(buffer: Buffer): Uint8Array {
-        return new Uint8Array(buffer);
-    }
-
-    /**
-     * Convert Uint8Array to Buffer
-     */
-    public static uint8ArrayToBuffer(array: Uint8Array): Buffer {
-        return Buffer.from(array);
-    }
-
     /**
      * Calculate SHA-1 hash
      */
-    public static sha1(data: Uint8Array | Buffer): Buffer {
-        return crypto.sha1(Buffer.isBuffer(data) ? data : Buffer.from(data));
+    public static sha1(data: Uint8Array): Uint8Array {
+        return crypto.sha1(data);
     }
 
     /**
      * Calculate mining preimage
      */
-    public static calculatePreimage(checksumRoot: Buffer, publicKey: Buffer, salt: Buffer): Buffer {
+    public static calculatePreimage(
+        checksumRoot: Uint8Array,
+        publicKey: Uint8Array,
+        salt: Uint8Array,
+    ): Uint8Array {
         // Ensure all are 32 bytes
         if (checksumRoot.length !== 32 || publicKey.length !== 32 || salt.length !== 32) {
             throw new Error('All inputs must be 32 bytes');
         }
 
-        const preimage = Buffer.alloc(32);
+        const preimage = new Uint8Array(32);
         for (let i = 0; i < 32; i++) {
-            preimage[i] = checksumRoot[i] ^ publicKey[i] ^ salt[i];
+            preimage[i] = (checksumRoot[i] as number) ^ (publicKey[i] as number) ^ (salt[i] as number);
         }
 
         return preimage;
@@ -47,7 +37,7 @@ export class EpochValidator {
     /**
      * Count matching bits between two hashes
      */
-    public static countMatchingBits(hash1: Buffer, hash2: Buffer): number {
+    public static countMatchingBits(hash1: Uint8Array, hash2: Uint8Array): number {
         let matchingBits = 0;
         if (hash1.length !== hash2.length) {
             throw new Error('Hashes must be of the same length');
@@ -63,7 +53,7 @@ export class EpochValidator {
             } else {
                 // Check individual bits
                 for (let bit = 7; bit >= 0; bit--) {
-                    if (((byte1 >> bit) & 1) === ((byte2 >> bit) & 1)) {
+                    if ((((byte1 as number) >> bit) & 1) === (((byte2 as number) >> bit) & 1)) {
                         matchingBits++;
                     } else {
                         return matchingBits;
@@ -88,16 +78,12 @@ export class EpochValidator {
             );
 
             const computedSolution = this.sha1(calculatedPreimage);
-            const computedSolutionBuffer = this.uint8ArrayToBuffer(computedSolution);
 
-            if (!computedSolutionBuffer.equals(challenge.solution)) {
+            if (!equals(computedSolution, challenge.solution)) {
                 return false;
             }
 
-            const matchingBits = this.countMatchingBits(
-                computedSolutionBuffer,
-                verification.targetHash,
-            );
+            const matchingBits = this.countMatchingBits(computedSolution, verification.targetHash);
 
             if (matchingBits !== challenge.difficulty) {
                 return false;
@@ -159,16 +145,12 @@ export class EpochValidator {
             );
 
             const computedSolution = this.sha1(calculatedPreimage);
-            const computedSolutionBuffer = this.uint8ArrayToBuffer(computedSolution);
 
-            if (!computedSolutionBuffer.equals(solution)) {
+            if (!equals(computedSolution, solution)) {
                 return false;
             }
 
-            const matchingBits = this.countMatchingBits(
-                computedSolutionBuffer,
-                verification.targetHash,
-            );
+            const matchingBits = this.countMatchingBits(computedSolution, verification.targetHash);
 
             if (matchingBits !== difficulty) {
                 return false;
@@ -201,21 +183,20 @@ export class EpochValidator {
      * @returns The SHA-1 hash of the preimage
      */
     public static calculateSolution(
-        targetChecksum: Buffer,
-        publicKey: Buffer,
-        salt: Buffer,
-    ): Buffer {
+        targetChecksum: Uint8Array,
+        publicKey: Uint8Array,
+        salt: Uint8Array,
+    ): Uint8Array {
         const preimage = this.calculatePreimage(targetChecksum, publicKey, salt);
-        const hash = this.sha1(this.bufferToUint8Array(preimage));
-        return this.uint8ArrayToBuffer(hash);
+        return this.sha1(preimage);
     }
 
     /**
      * Check if a solution meets the minimum difficulty requirement
      */
     public static checkDifficulty(
-        solution: Buffer,
-        targetHash: Buffer,
+        solution: Uint8Array,
+        targetHash: Uint8Array,
         minDifficulty: number,
     ): { valid: boolean; difficulty: number } {
         const difficulty = this.countMatchingBits(solution, targetHash);

package/src/generators/AddressGenerator.ts

@@ -1,12 +1,12 @@
 import { bech32, bech32m } from 'bech32';
-import { initEccLib, Network, ripemd160 } from '@btc-vision/bitcoin';
-import * as ecc from '@bitcoinerlab/secp256k1';
+import { initEccLib, type Network, ripemd160 } from '@btc-vision/bitcoin';
+import { eccLib } from '../ecc/backend.js';
 
-initEccLib(ecc);
+initEccLib(eccLib);
 
 export class AddressGenerator {
     // Generate a valid SegWit address from random bytes
-    public static generatePKSH(sha256Hash: Buffer, network: Network): string {
+    public static generatePKSH(sha256Hash: Uint8Array, network: Network): string {
         if (sha256Hash.length !== 32) throw new Error('Invalid hash length');
 
         const pkh = ripemd160(sha256Hash);
@@ -14,7 +14,7 @@ export class AddressGenerator {
     }
 
     // Generate a valid Taproot address from a public key
-    public static generateTaprootAddress(pubKey: Buffer, network: { bech32: string }): string {
+    public static generateTaprootAddress(pubKey: Uint8Array, network: { bech32: string }): string {
         if (pubKey.length !== 32) throw new Error('Invalid public key length');
 
         // Convert the public key to words
@@ -28,7 +28,7 @@ export class AddressGenerator {
     }
 
     // Convert a hash to a SegWit address
-    private static toSegwitAddress(pkh: Buffer, network: Network): string {
+    private static toSegwitAddress(pkh: Uint8Array, network: Network): string {
         const words = bech32.toWords(pkh);
         words.unshift(0x00); // Add the witness version byte (0x00 for P2WPKH)
 

package/src/generators/Features.ts

@@ -1,6 +1,6 @@
-import { LoadedStorage } from '../transaction/interfaces/ITransactionParameters.js';
-import { ChallengeSubmission } from '../epoch/ChallengeSolution.js';
-import { MLDSARequestData } from './MLDSAData.js';
+import type { LoadedStorage } from '../transaction/interfaces/ITransactionParameters.js';
+import type { ChallengeSubmission } from '../epoch/ChallengeSolution.js';
+import type { MLDSARequestData } from './MLDSAData.js';
 
 export enum Features {
     ACCESS_LIST = 0b1,

package/src/generators/Generator.ts

@@ -1,6 +1,20 @@
-import { Network, networks, toXOnly } from '@btc-vision/bitcoin';
+import {
+    alloc,
+    fromUtf8,
+    type Network,
+    networks,
+    type PublicKey,
+    toXOnly,
+    type XOnlyPublicKey,
+} from '@btc-vision/bitcoin';
 import { BinaryWriter } from '../buffer/BinaryWriter.js';
-import { AccessListFeature, EpochSubmissionFeature, Feature, Features, MLDSALinkRequest, } from './Features.js';
+import {
+    type AccessListFeature,
+    type EpochSubmissionFeature,
+    type Feature,
+    Features,
+    type MLDSALinkRequest,
+} from './Features.js';
 import { Address } from '../keypair/Address.js';
 import { Compressor } from '../bytecode/Compressor.js';
 
@@ -14,25 +28,25 @@ export abstract class Generator {
     /**
      * The magic number of OPNet
      */
-    public static readonly MAGIC: Buffer = Buffer.from('op', 'utf-8');
+    public static readonly MAGIC: Uint8Array = fromUtf8('op');
 
     /**
      * The public key of the sender
      * @protected
      */
-    protected readonly senderPubKey: Buffer;
+    protected readonly senderPubKey: Uint8Array;
 
     /**
      * The public key of the sender
      * @protected
      */
-    protected readonly xSenderPubKey: Buffer;
+    protected readonly xSenderPubKey: Uint8Array;
 
     /**
      * The public key of the contract salt
      * @protected
      */
-    protected readonly contractSaltPubKey?: Buffer;
+    protected readonly contractSaltPubKey?: Uint8Array | undefined;
 
     /**
      * The network to use
@@ -41,8 +55,8 @@ export abstract class Generator {
     protected readonly network: Network = networks.bitcoin;
 
     protected constructor(
-        senderPubKey: Buffer,
-        contractSaltPubKey?: Buffer,
+        senderPubKey: PublicKey | XOnlyPublicKey,
+        contractSaltPubKey?: Uint8Array,
         network: Network = networks.bitcoin,
     ) {
         this.senderPubKey = senderPubKey;
@@ -51,52 +65,54 @@ export abstract class Generator {
         this.xSenderPubKey = toXOnly(senderPubKey);
     }
 
-    public buildHeader(features: Features[]): Buffer {
+    public buildHeader(features: Features[]): Uint8Array {
         let flags: number = 0;
 
         for (const feature of features) {
             flags |= feature;
         }
 
-        const bytesU24 = Buffer.alloc(3);
-        bytesU24.writeUIntBE(flags, 0, 3);
+        const bytesU24 = alloc(3);
+        bytesU24[0] = (flags >> 16) & 0xff;
+        bytesU24[1] = (flags >> 8) & 0xff;
+        bytesU24[2] = flags & 0xff;
 
-        return Buffer.from([this.senderPubKey[0], ...bytesU24]);
+        return Uint8Array.from([this.senderPubKey[0], ...bytesU24]);
     }
 
-    public getHeader(maxPriority: bigint, features: Features[] = []): Buffer {
+    public getHeader(maxPriority: bigint, features: Features[] = []): Uint8Array {
         const writer = new BinaryWriter(12);
         writer.writeBytes(this.buildHeader(features));
         writer.writeU64(maxPriority);
 
-        return Buffer.from(writer.getBuffer());
+        return new Uint8Array(writer.getBuffer());
     }
 
     /**
      * Compile the script
      * @param args - The arguments to use when compiling the script
-     * @returns {Buffer} - The compiled script
+     * @returns {Uint8Array} - The compiled script
      */
-    public abstract compile(...args: unknown[]): Buffer;
+    public abstract compile(...args: unknown[]): Uint8Array;
 
     /**
      * Split a buffer into chunks
-     * @param {Buffer} buffer - The buffer to split
+     * @param {Uint8Array} buffer - The buffer to split
      * @param {number} chunkSize - The size of each chunk
      * @protected
-     * @returns {Array<Buffer[]>} - The chunks
+     * @returns {Array<Uint8Array[]>} - The chunks
      */
     protected splitBufferIntoChunks(
-        buffer: Buffer,
+        buffer: Uint8Array,
         chunkSize: number = Generator.DATA_CHUNK_SIZE,
-    ): Array<Buffer[]> {
-        const chunks: Array<Buffer[]> = [];
+    ): Array<Uint8Array[]> {
+        const chunks: Array<Uint8Array[]> = [];
         for (let i = 0; i < buffer.length; i += chunkSize) {
             const dataLength = Math.min(chunkSize, buffer.length - i);
 
-            const buf2 = Buffer.alloc(dataLength);
+            const buf2 = alloc(dataLength);
             for (let j = 0; j < dataLength; j++) {
-                buf2.writeUInt8(buffer[i + j], j);
+                buf2[j] = buffer[i + j] as number;
             }
 
             chunks.push([buf2]);
@@ -131,13 +147,13 @@ export abstract class Generator {
 
         for (const contract in feature.data) {
             const parsedContract = Address.fromString(contract);
-            const data = feature.data[contract];
+            const data = feature.data[contract] as string[];
 
             writer.writeAddress(parsedContract);
             writer.writeU32(data.length);
 
             for (const pointer of data) {
-                const pointerBuffer = Buffer.from(pointer, 'base64');
+                const pointerBuffer = Uint8Array.from(atob(pointer), (c) => c.charCodeAt(0));
 
                 if (pointerBuffer.length !== 32) {
                     throw new Error(`Invalid pointer length: ${pointerBuffer.length}`);
@@ -147,7 +163,7 @@ export abstract class Generator {
             }
         }
 
-        finalBuffer.writeBytesWithLength(Compressor.compress(Buffer.from(writer.getBuffer())));
+        finalBuffer.writeBytesWithLength(Compressor.compress(new Uint8Array(writer.getBuffer())));
     }
 
     private encodeChallengeSubmission(

package/src/generators/builders/CalldataGenerator.ts

@@ -1,10 +1,10 @@
-import { crypto, Network, networks, opcodes, script } from '@btc-vision/bitcoin';
-import { ECPairInterface } from 'ecpair';
+import { concat, crypto, type Network, networks, opcodes, type PublicKey, script } from '@btc-vision/bitcoin';
+import { type UniversalSigner } from '@btc-vision/ecpair';
 import { Compressor } from '../../bytecode/Compressor.js';
 import { EcKeyPair } from '../../keypair/EcKeyPair.js';
-import { Feature, Features } from '../Features.js';
+import { type Feature, Features } from '../Features.js';
 import { Generator } from '../Generator.js';
-import { IChallengeSolution } from '../../epoch/interfaces/IChallengeSolution.js';
+import type { IChallengeSolution } from '../../epoch/interfaces/IChallengeSolution.js';
 import { BinaryWriter } from '../../buffer/BinaryWriter.js';
 
 /**
@@ -12,8 +12,8 @@ import { BinaryWriter } from '../../buffer/BinaryWriter.js';
  */
 export class CalldataGenerator extends Generator {
     constructor(
-        senderPubKey: Buffer,
-        contractSaltPubKey: Buffer,
+        senderPubKey: PublicKey,
+        contractSaltPubKey: Uint8Array,
         network: Network = networks.bitcoin,
     ) {
         super(senderPubKey, contractSaltPubKey, network);
@@ -21,16 +21,16 @@ export class CalldataGenerator extends Generator {
 
     /**
      * Get the public key as a buffer
-     * @param {Buffer[]} witnessKeys - The public keys
+     * @param {Uint8Array[]} witnessKeys - The public keys
      * @param {Network} network - The network to use
      * @private
-     * @returns {Buffer} - The public key as a buffer
+     * @returns {Uint8Array} - The public key as a buffer
      */
-    public static getPubKeyAsBuffer(witnessKeys: Buffer[], network: Network): Buffer {
-        let finalBuffer: Buffer = Buffer.alloc(0);
+    public static getPubKeyAsBuffer(witnessKeys: Uint8Array[], network: Network): Uint8Array {
+        let finalBuffer: Uint8Array = new Uint8Array(0);
 
         for (const pubKey of witnessKeys) {
-            const key: ECPairInterface = EcKeyPair.fromPublicKey(pubKey, network);
+            const key: UniversalSigner = EcKeyPair.fromPublicKey(pubKey, network);
 
             if (!key.compressed) {
                 throw new Error('Public key must be compressed');
@@ -40,11 +40,11 @@ export class CalldataGenerator extends Generator {
                 throw new Error(`Public key must be 33 bytes, got ${pubKey.byteLength} bytes.`);
             }
 
-            finalBuffer = Buffer.concat([finalBuffer, pubKey]);
+            finalBuffer = concat([finalBuffer, pubKey]);
         }
 
         // compress the public keys
-        const compressed: Buffer = Compressor.compress(finalBuffer);
+        const compressed: Uint8Array = Compressor.compress(finalBuffer);
         if (compressed.byteLength >= finalBuffer.byteLength) {
             // we ensure that the user pays the smallest amount of fees. [micro-optimization]
             return finalBuffer;
@@ -56,28 +56,28 @@ export class CalldataGenerator extends Generator {
 
     /**
      * Compile an interaction bitcoin script
-     * @param {Buffer} calldata - The calldata to use
-     * @param {Buffer} contractSecret - The contract secret
+     * @param {Uint8Array} calldata - The calldata to use
+     * @param {Uint8Array} contractSecret - The contract secret
      * @param {IChallengeSolution} challenge
      * @param maxPriority - Amount of satoshis to spend max on priority fee
      * @param {Feature<Features>[]} featuresRaw - The features to use
-     * @returns {Buffer} - The compiled script
+     * @returns {Uint8Array} - The compiled script
      * @throws {Error} - If something goes wrong
      */
     public compile(
-        calldata: Buffer,
-        contractSecret: Buffer,
+        calldata: Uint8Array,
+        contractSecret: Uint8Array,
         challenge: IChallengeSolution,
         maxPriority: bigint,
         featuresRaw: Feature<Features>[] = [],
-    ): Buffer {
+    ): Uint8Array {
         if (!this.contractSaltPubKey) throw new Error('Contract salt public key not set');
 
-        const dataChunks: Buffer[][] = this.splitBufferIntoChunks(calldata);
+        const dataChunks: Uint8Array[][] = this.splitBufferIntoChunks(calldata);
         if (!dataChunks.length) throw new Error('No data chunks found');
 
         const featuresList: Features[] = [];
-        const featureData: (number | Buffer | Buffer[])[] = [];
+        const featureData: (number | Uint8Array | Uint8Array[])[] = [];
 
         if (featuresRaw && featuresRaw.length) {
             const features: Feature<Features>[] = featuresRaw.sort(
@@ -86,16 +86,18 @@ export class CalldataGenerator extends Generator {
 
             const finalBuffer = new BinaryWriter();
             for (let i = 0; i < features.length; i++) {
-                const feature = features[i];
+                const feature = features[i] as Feature<Features>;
                 featuresList.push(feature.opcode);
 
                 this.encodeFeature(feature, finalBuffer);
             }
 
-            featureData.push(...this.splitBufferIntoChunks(Buffer.from(finalBuffer.getBuffer())));
+            featureData.push(
+                ...this.splitBufferIntoChunks(new Uint8Array(finalBuffer.getBuffer())),
+            );
         }
 
-        let compiledData: (number | Buffer | Buffer[])[] = [
+        let compiledData: (number | Uint8Array | Uint8Array[])[] = [
             this.getHeader(maxPriority, featuresList),
             opcodes.OP_TOALTSTACK,