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

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,9 @@
 import { bech32, bech32m } from 'bech32';
-import { initEccLib, Network, ripemd160 } from '@btc-vision/bitcoin';
-import * as ecc from '@bitcoinerlab/secp256k1';
-
-initEccLib(ecc);
+import { type Network, ripemd160 } from '@btc-vision/bitcoin';
 
 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 +11,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 +25,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,
 

package/src/generators/builders/CustomGenerator.ts

@@ -1,21 +1,21 @@
-import { Network, networks, script, Stack } from '@btc-vision/bitcoin';
+import { type Network, networks, script, type Stack, type XOnlyPublicKey } from '@btc-vision/bitcoin';
 import { Generator } from '../Generator.js';
 
 /**
  * Class to generate bitcoin script for interaction transactions
  */
 export class CustomGenerator extends Generator {
-    constructor(senderPubKey: Buffer, network: Network = networks.bitcoin) {
+    constructor(senderPubKey: XOnlyPublicKey, network: Network = networks.bitcoin) {
         super(senderPubKey, undefined, network);
     }
 
     /**
      * Compile an interaction bitcoin script
      * @param compiledData - The compiled data
-     * @returns {Buffer} - The compiled script
+     * @returns {Uint8Array} - The compiled script
      * @throws {Error} - If something goes wrong
      */
-    public compile(compiledData: (Buffer | Stack)[]): Buffer {
+    public compile(compiledData: (Uint8Array | Stack)[]): Uint8Array {
         const asm = compiledData.flat();
         const compiled = script.compile(asm);
 

package/src/generators/builders/DeploymentGenerator.ts

@@ -1,16 +1,16 @@
-import { crypto, Network, networks, opcodes, script } from '@btc-vision/bitcoin';
+import { crypto, type Network, networks, opcodes, type PublicKey, script } from '@btc-vision/bitcoin';
 import { Generator } from '../Generator.js';
-import { Feature, Features } from '../Features.js';
-import { IChallengeSolution } from '../../epoch/interfaces/IChallengeSolution.js';
+import { type Feature, Features } from '../Features.js';
+import type { IChallengeSolution } from '../../epoch/interfaces/IChallengeSolution.js';
 import { BinaryWriter } from '../../buffer/BinaryWriter.js';
 
 export const OPNET_DEPLOYMENT_VERSION = 0x00;
-export const versionBuffer = Buffer.from([OPNET_DEPLOYMENT_VERSION]);
+export const versionBuffer = Uint8Array.from([OPNET_DEPLOYMENT_VERSION]);
 
 export class DeploymentGenerator extends Generator {
     constructor(
-        senderPubKey: Buffer,
-        contractSaltPubKey: Buffer,
+        senderPubKey: PublicKey,
+        contractSaltPubKey: Uint8Array,
         network: Network = networks.bitcoin,
     ) {
         super(senderPubKey, contractSaltPubKey, network);
@@ -18,22 +18,22 @@ export class DeploymentGenerator extends Generator {
 
     /**
      * Compile a bitcoin script representing a contract deployment
-     * @param {Buffer} contractBytecode - The contract bytecode
-     * @param {Buffer} contractSalt - The contract salt
+     * @param {Uint8Array} contractBytecode - The contract bytecode
+     * @param {Uint8Array} contractSalt - The contract salt
      * @param {ChallengeSolution} challenge - The challenge for reward
      * @param {bigint} maxPriority - The maximum priority for the contract
-     * @param {Buffer} [calldata] - The calldata to be passed to the contract
+     * @param {Uint8Array} [calldata] - The calldata to be passed to the contract
      * @param {Feature<Features>[]} [features] - Optional features to include in the script
-     * @returns {Buffer} - The compiled script
+     * @returns {Uint8Array} - The compiled script
      */
     public compile(
-        contractBytecode: Buffer,
-        contractSalt: Buffer,
+        contractBytecode: Uint8Array,
+        contractSalt: Uint8Array,
         challenge: IChallengeSolution,
         maxPriority: bigint,
-        calldata?: Buffer,
+        calldata?: Uint8Array,
         features?: Feature<Features>[],
-    ): Buffer {
+    ): Uint8Array {
         const asm = this.getAsm(
             contractBytecode,
             contractSalt,
@@ -57,20 +57,20 @@ export class DeploymentGenerator extends Generator {
     }
 
     private getAsm(
-        contractBytecode: Buffer,
-        contractSalt: Buffer,
+        contractBytecode: Uint8Array,
+        contractSalt: Uint8Array,
         challenge: IChallengeSolution,
         maxPriority: bigint,
-        calldata?: Buffer,
+        calldata?: Uint8Array,
         featuresRaw?: Feature<Features>[],
-    ): (number | Buffer)[] {
+    ): (number | Uint8Array)[] {
         if (!this.contractSaltPubKey) throw new Error('Contract salt public key not set');
 
-        const dataChunks: Buffer[][] = this.splitBufferIntoChunks(contractBytecode);
-        const calldataChunks: Buffer[][] = calldata ? this.splitBufferIntoChunks(calldata) : [];
+        const dataChunks: Uint8Array[][] = this.splitBufferIntoChunks(contractBytecode);
+        const calldataChunks: Uint8Array[][] = calldata ? this.splitBufferIntoChunks(calldata) : [];
 
         const featuresList: Features[] = [];
-        const featureData: (number | Buffer | Buffer[])[] = [];
+        const featureData: (number | Uint8Array | Uint8Array[])[] = [];
 
         if (featuresRaw && featuresRaw.length) {
             const features: Feature<Features>[] = featuresRaw.sort(
@@ -79,13 +79,15 @@ export class DeploymentGenerator 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())),
+            );
         }
 
         const compiledData = [