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

package/src/generators/builders/HashCommitmentGenerator.ts

@@ -1,6 +1,6 @@
-import { crypto, Network, networks, opcodes, payments, script } from '@btc-vision/bitcoin';
-import { IHashCommittedP2WSH } from '../../transaction/interfaces/IConsolidatedTransactionParameters.js';
-import { IP2WSHAddress } from '../../transaction/mineable/IP2WSHAddress.js';
+import { crypto, equals, type Network, networks, opcodes, payments, type Script, script, } from '@btc-vision/bitcoin';
+import type { IHashCommittedP2WSH } from '../../transaction/interfaces/IConsolidatedTransactionParameters.js';
+import type { IP2WSHAddress } from '../../transaction/mineable/IP2WSHAddress.js';
 import { Logger } from '@btc-vision/logger';
 
 /**
@@ -42,11 +42,6 @@ export class HashCommitmentGenerator extends Logger {
      * OP_HASH160 (1) + push (1) + hash (20) + OP_EQUALVERIFY (1) = 23 bytes
      */
     private static readonly BYTES_PER_COMMITMENT: number = 23;
-    /**
-     * Signature check bytes in witness script.
-     * push (1) + pubkey (33) + OP_CHECKSIG (1) = 35 bytes
-     */
-    private static readonly SIG_CHECK_BYTES: number = 35;
     /**
      * Fixed overhead in witness serialization:
      * - Stack item count: 1 byte
@@ -87,11 +82,11 @@ export class HashCommitmentGenerator extends Logger {
     public static readonly WEIGHT_PER_INPUT: number =
         HashCommitmentGenerator.INPUT_BASE_WEIGHT +
         HashCommitmentGenerator.INPUT_WITNESS_WEIGHT_MAX;
-    public readonly logColor: string = '#4a90d9';
-    private readonly publicKey: Buffer;
+    public override readonly logColor: string = '#4a90d9';
+    private readonly publicKey: Uint8Array;
     private readonly network: Network;
 
-    constructor(publicKey: Buffer, network: Network = networks.bitcoin) {
+    constructor(publicKey: Uint8Array, network: Network = networks.bitcoin) {
         super();
 
         if (publicKey.length !== 33) {
@@ -164,7 +159,7 @@ export class HashCommitmentGenerator extends Logger {
      * @param witnessScript The witness script to validate
      * @returns true if valid hash-committed script
      */
-    public static validateHashCommittedScript(witnessScript: Buffer): boolean {
+    public static validateHashCommittedScript(witnessScript: Uint8Array): boolean {
         try {
             const decompiled = script.decompile(witnessScript);
             if (!decompiled || decompiled.length < 5) {
@@ -177,7 +172,7 @@ export class HashCommitmentGenerator extends Logger {
                 return false;
             }
             const pubkey = decompiled[lastIdx - 1];
-            if (!Buffer.isBuffer(pubkey) || pubkey.length !== 33) {
+            if (!(pubkey instanceof Uint8Array) || pubkey.length !== 33) {
                 return false;
             }
 
@@ -191,7 +186,7 @@ export class HashCommitmentGenerator extends Logger {
                 const hash = hashParts[i + 1];
                 if (
                     hashParts[i] !== opcodes.OP_HASH160 ||
-                    !Buffer.isBuffer(hash) ||
+                    !(hash instanceof Uint8Array) ||
                     hash.length !== 20 ||
                     hashParts[i + 2] !== opcodes.OP_EQUALVERIFY
                 ) {
@@ -211,7 +206,7 @@ export class HashCommitmentGenerator extends Logger {
      * @param witnessScript The witness script
      * @returns Array of 20-byte data hashes (in data order), or null if invalid
      */
-    public static extractDataHashes(witnessScript: Buffer): Buffer[] | null {
+    public static extractDataHashes(witnessScript: Uint8Array): Uint8Array[] | null {
         try {
             const decompiled = script.decompile(witnessScript);
             if (
@@ -223,10 +218,10 @@ export class HashCommitmentGenerator extends Logger {
 
             // Extract hashes from triplets (they're in reverse order in script)
             const hashParts = decompiled.slice(0, -2);
-            const hashes: Buffer[] = [];
+            const hashes: Uint8Array[] = [];
 
             for (let i = 0; i < hashParts.length; i += 3) {
-                hashes.push(hashParts[i + 1] as Buffer);
+                hashes.push(hashParts[i + 1] as Uint8Array);
             }
 
             // Reverse to get data order (script has them reversed)
@@ -242,7 +237,7 @@ export class HashCommitmentGenerator extends Logger {
      * @param witnessScript The witness script
      * @returns The 33-byte public key, or null if invalid script
      */
-    public static extractPublicKey(witnessScript: Buffer): Buffer | null {
+    public static extractPublicKey(witnessScript: Uint8Array): Uint8Array | null {
         try {
             const decompiled = script.decompile(witnessScript);
             if (
@@ -251,7 +246,7 @@ export class HashCommitmentGenerator extends Logger {
             ) {
                 return null;
             }
-            return decompiled[decompiled.length - 2] as Buffer;
+            return decompiled[decompiled.length - 2] as Uint8Array;
         } catch {
             return null;
         }
@@ -264,15 +259,18 @@ export class HashCommitmentGenerator extends Logger {
      * @param witnessScript The witness script containing the hash commitments
      * @returns true if all chunks match their commitments
      */
-    public static verifyChunkCommitments(dataChunks: Buffer[], witnessScript: Buffer): boolean {
+    public static verifyChunkCommitments(
+        dataChunks: Uint8Array[],
+        witnessScript: Uint8Array,
+    ): boolean {
         const committedHashes = HashCommitmentGenerator.extractDataHashes(witnessScript);
         if (!committedHashes || committedHashes.length !== dataChunks.length) {
             return false;
         }
 
         for (let i = 0; i < dataChunks.length; i++) {
-            const actualHash = crypto.hash160(dataChunks[i]);
-            if (!committedHashes[i].equals(actualHash)) {
+            const actualHash = crypto.hash160(dataChunks[i] as Uint8Array);
+            if (!equals(committedHashes[i] as Uint8Array, actualHash)) {
                 return false;
             }
         }
@@ -344,7 +342,7 @@ export class HashCommitmentGenerator extends Logger {
      * Calculate the HASH160 of a data chunk.
      * HASH160 = RIPEMD160(SHA256(data))
      */
-    public hashChunk(data: Buffer): Buffer {
+    public hashChunk(data: Uint8Array): Uint8Array {
         return crypto.hash160(data);
     }
 
@@ -365,7 +363,7 @@ export class HashCommitmentGenerator extends Logger {
      * @param dataHashes Array of HASH160 values (in data order, will be reversed in script)
      * @returns The compiled witness script
      */
-    public generateWitnessScript(dataHashes: Buffer[]): Buffer {
+    public generateWitnessScript(dataHashes: Uint8Array[]): Uint8Array {
         if (dataHashes.length === 0) {
             throw new Error('At least one data hash is required');
         }
@@ -383,12 +381,12 @@ export class HashCommitmentGenerator extends Logger {
         }
 
         // Build script parts - hashes in reverse order (last data chunk verified first)
-        const scriptParts: (number | Buffer)[] = [];
+        const scriptParts: (number | Uint8Array)[] = [];
 
         // Add hash commitments in reverse order
         for (let i = dataHashes.length - 1; i >= 0; i--) {
             scriptParts.push(opcodes.OP_HASH160);
-            scriptParts.push(dataHashes[i]);
+            scriptParts.push(dataHashes[i] as Uint8Array);
             scriptParts.push(opcodes.OP_EQUALVERIFY);
         }
 
@@ -405,9 +403,11 @@ export class HashCommitmentGenerator extends Logger {
      * @param witnessScript The witness script
      * @returns P2WSH address info
      */
-    public generateP2WSHAddress(witnessScript: Buffer): IP2WSHAddress & { scriptPubKey: Buffer } {
+    public generateP2WSHAddress(
+        witnessScript: Uint8Array | Script,
+    ): IP2WSHAddress & { scriptPubKey: Uint8Array } {
         const p2wsh = payments.p2wsh({
-            redeem: { output: witnessScript },
+            redeem: { output: witnessScript as Script },
             network: this.network,
         });
 
@@ -433,7 +433,7 @@ export class HashCommitmentGenerator extends Logger {
      * @returns Array of hash-committed P2WSH outputs
      */
     public prepareChunks(
-        data: Buffer,
+        data: Uint8Array,
         maxChunkSize: number = HashCommitmentGenerator.MAX_CHUNK_SIZE,
     ): IHashCommittedP2WSH[] {
         if (maxChunkSize > HashCommitmentGenerator.MAX_CHUNK_SIZE) {
@@ -447,12 +447,12 @@ export class HashCommitmentGenerator extends Logger {
         }
 
         // First, split data into 80-byte chunks
-        const allChunks: Buffer[] = [];
+        const allChunks: Uint8Array[] = [];
         let offset = 0;
 
         while (offset < data.length) {
             const chunkSize = Math.min(maxChunkSize, data.length - offset);
-            allChunks.push(Buffer.from(data.subarray(offset, offset + chunkSize)));
+            allChunks.push(new Uint8Array(data.subarray(offset, offset + chunkSize)));
             offset += chunkSize;
         }
 

package/src/generators/builders/LegacyCalldataGenerator.ts

@@ -1,9 +1,9 @@
-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 { Generator } from '../Generator.js';
-import { Feature, Features } from '../Features.js';
+import { type Feature, Features } from '../Features.js';
 import { BinaryWriter } from '../../buffer/BinaryWriter.js';
 
 /**
@@ -11,22 +11,22 @@ import { BinaryWriter } from '../../buffer/BinaryWriter.js';
  * @deprecated
  */
 export class LegacyCalldataGenerator extends Generator {
-    constructor(senderPubKey: Buffer, network: Network = networks.bitcoin) {
-        super(senderPubKey, Buffer.alloc(0), network);
+    constructor(senderPubKey: PublicKey, network: Network = networks.bitcoin) {
+        super(senderPubKey, new Uint8Array(0), network);
     }
 
     /**
      * 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');
@@ -36,11 +36,11 @@ export class LegacyCalldataGenerator 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;
@@ -52,26 +52,26 @@ export class LegacyCalldataGenerator extends Generator {
 
     /**
      * Compile an interaction bitcoin script
-     * @param {Buffer} calldata - The calldata to use
-     * @param {Buffer} contractSecret - The contract secret
-     * @param {Buffer} challenge - The challenge to use
+     * @param {Uint8Array} calldata - The calldata to use
+     * @param {Uint8Array} contractSecret - The contract secret
+     * @param {Uint8Array} challenge - The challenge to use
      * @param {bigint} maxPriority - The maximum priority
      * @param {number[]} [featuresRaw=[]] - The features to use (optional)
-     * @returns {Buffer} - The compiled script
+     * @returns {Uint8Array} - The compiled script
      * @throws {Error} - If something goes wrong
      */
     public compile(
-        calldata: Buffer,
-        contractSecret: Buffer,
-        challenge: Buffer,
+        calldata: Uint8Array,
+        contractSecret: Uint8Array,
+        challenge: Uint8Array,
         maxPriority: bigint,
         featuresRaw: Feature<Features>[] = [],
-    ): Buffer {
-        const dataChunks: Buffer[][] = this.splitBufferIntoChunks(calldata);
+    ): Uint8Array {
+        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(
@@ -80,13 +80,15 @@ export class LegacyCalldataGenerator 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 = [

package/src/generators/builders/MultiSignGenerator.ts

@@ -1,4 +1,4 @@
-import { opcodes, script, toXOnly } from '@btc-vision/bitcoin';
+import { alloc, compare, equals, opcodes, type PublicKey, script, toXOnly, type XOnlyPublicKey, } from '@btc-vision/bitcoin';
 
 /**
  * Generate a bitcoin script for a multisign interaction
@@ -7,10 +7,10 @@ export class MultiSignGenerator {
     public static readonly MAXIMUM_SUPPORTED_SIGNATURE = 255;
 
     public static compile(
-        vaultPublicKeys: Buffer[],
+        vaultPublicKeys: Uint8Array[] | PublicKey[],
         minimumSignatures: number = 0,
-        internal?: Buffer,
-    ): Buffer {
+        internal?: Uint8Array | XOnlyPublicKey,
+    ): Uint8Array {
         if (minimumSignatures < 2) {
             throw new Error('Minimum signatures must be greater than 1');
         }
@@ -25,27 +25,27 @@ export class MultiSignGenerator {
             );
         }
 
-        const minimumRequired = Buffer.alloc(1);
-        minimumRequired.writeUInt8(minimumSignatures);
+        const minimumRequired = alloc(1);
+        minimumRequired[0] = minimumSignatures;
 
         /** Remove duplicates **/
         vaultPublicKeys = vaultPublicKeys.filter(
-            (buf, index, self) => index === self.findIndex((otherBuf) => buf.equals(otherBuf)),
+            (buf, index, self) => index === self.findIndex((otherBuf) => equals(buf, otherBuf)),
         );
 
         /** We must order the pub keys. */
-        vaultPublicKeys = vaultPublicKeys.sort((a, b) => a.compare(b));
+        vaultPublicKeys = vaultPublicKeys.sort((a, b) => compare(a, b));
 
         let included = false;
         const data = vaultPublicKeys.map((key) => {
-            const newKey = toXOnly(key);
-            if (internal && !included) included = internal.equals(newKey);
+            const newKey = toXOnly(key as PublicKey);
+            if (internal && !included) included = equals(internal, newKey);
 
             return newKey;
         });
 
-        if (internal && !included) data.push(internal);
-        const compiledData: (number | Buffer)[] = [
+        if (internal && !included) data.push(internal as XOnlyPublicKey);
+        const compiledData: (number | Uint8Array)[] = [
             // Push the initial 0 (for OP_CHECKSIGADD)
             opcodes.OP_0,
 

package/src/generators/builders/P2WDAGenerator.ts

@@ -1,8 +1,8 @@
-import { Network, networks } from '@btc-vision/bitcoin';
+import { type Network, networks, type PublicKey } from '@btc-vision/bitcoin';
 import { BinaryWriter } from '../../buffer/BinaryWriter.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';
 
 /**
  * @category Generators
@@ -12,8 +12,8 @@ export class P2WDAGenerator extends Generator {
     private static readonly P2WDA_VERSION = 0x01;
 
     constructor(
-        senderPubKey: Buffer,
-        contractSaltPubKey: Buffer,
+        senderPubKey: PublicKey,
+        contractSaltPubKey: Uint8Array,
         network: Network = networks.bitcoin,
     ) {
         super(senderPubKey, contractSaltPubKey, network);
@@ -60,12 +60,12 @@ export class P2WDAGenerator extends Generator {
      * @returns Raw operation data ready for signing and compression
      */
     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');
         }
@@ -97,10 +97,10 @@ export class P2WDAGenerator extends Generator {
 
         this.writeFeatures(writer, features);
 
-        return Buffer.from(writer.getBuffer());
+        return new Uint8Array(writer.getBuffer());
     }
 
-    public override getHeader(maxPriority: bigint, features: Features[] = []): Buffer {
+    public override getHeader(maxPriority: bigint, features: Features[] = []): Uint8Array {
         return super.getHeader(maxPriority, features);
     }