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

package/src/transaction/utils/WitnessUtils.ts

@@ -2,30 +2,39 @@ import { varuint } from '@btc-vision/bitcoin';
 
 /**
  * Convert witness stack to script witness buffer
- * @param {Buffer[]} witness - The witness stack
- * @returns {Buffer}
+ * @param {Uint8Array[]} witness - The witness stack
+ * @returns {Uint8Array}
  */
-export function witnessStackToScriptWitness(witness: Buffer[]): Buffer {
-    let buffer = Buffer.allocUnsafe(0);
+export function witnessStackToScriptWitness(witness: Uint8Array[]): Uint8Array {
+    let buffer = new Uint8Array(0);
+
+    function concatBuffers(a: Uint8Array, b: Uint8Array): Uint8Array<ArrayBuffer> {
+        const result = new Uint8Array(a.length + b.length);
+        result.set(a, 0);
+        result.set(b, a.length);
+        return result;
+    }
 
-    function writeSlice(slice: Buffer) {
-        buffer = Buffer.concat([buffer, Buffer.from(slice)]);
+    function writeSlice(slice: Uint8Array) {
+        buffer = concatBuffers(buffer, slice);
     }
 
     function writeVarInt(i: number) {
         const currentLen = buffer.length;
         const varintLen = varuint.encodingLength(i);
 
-        buffer = Buffer.concat([buffer, Buffer.allocUnsafe(varintLen)]);
+        const newBuffer = new Uint8Array(currentLen + varintLen);
+        newBuffer.set(buffer, 0);
+        buffer = newBuffer;
         varuint.encode(i, buffer, currentLen);
     }
 
-    function writeVarSlice(slice: Buffer) {
+    function writeVarSlice(slice: Uint8Array) {
         writeVarInt(slice.length);
         writeSlice(slice);
     }
 
-    function writeVector(vector: Buffer[]) {
+    function writeVector(vector: Uint8Array[]) {
         writeVarInt(vector.length);
         vector.forEach(writeVarSlice);
     }

package/src/utils/BufferHelper.ts

@@ -1,71 +1,73 @@
+import { fromHex, toHex } from '@btc-vision/bitcoin';
 import { U256_BYTE_LENGTH } from './lengths.js';
-import { MemorySlotPointer } from './types.js';
+import type { MemorySlotPointer } from './types.js';
 
 export class BufferHelper {
     public static readonly EXPECTED_BUFFER_LENGTH: number = 32;
 
     public static bufferToUint8Array(buffer: Buffer | Uint8Array): Uint8Array {
-        if (Buffer.isBuffer(buffer)) {
-            const length: number = buffer.byteLength;
-            const arrayBuffer: ArrayBuffer = new ArrayBuffer(length);
-
-            const view: Uint8Array = new Uint8Array(arrayBuffer);
-            for (let i = 0; i < length; ++i) {
-                view[i] = buffer[i];
-            }
-
-            return view;
-        }
-
-        return buffer;
+        const result = new Uint8Array(buffer.byteLength);
+        result.set(buffer);
+        return result;
     }
 
     public static uint8ArrayToHex(input: Uint8Array): string {
-        return Buffer.from(input.buffer, 0, input.byteLength).toString('hex');
+        return toHex(input);
     }
 
     public static hexToUint8Array(input: string): Uint8Array {
-        if (input.startsWith('0x')) {
-            input = input.substring(2); // Remove the '0x' prefix
+        let hex = input;
+        if (hex.length >= 2 && hex[0] === '0' && (hex[1] === 'x' || hex[1] === 'X')) {
+            hex = hex.slice(2);
         }
 
-        if (input.length % 2 !== 0) {
-            input = '0' + input; // Pad with a leading zero if the length is odd
+        // Pad with a leading zero if the length is odd
+        if (hex.length % 2 !== 0) {
+            hex = '0' + hex;
         }
 
-        const lengthS = input.length / 2;
-        const buffer = new Uint8Array(lengthS);
-
-        for (let i = 0; i < lengthS; i++) {
-            buffer[i] = parseInt(input.substring(i * 2, i * 2 + 2), 16);
-        }
-
-        return buffer;
+        return fromHex(hex);
     }
 
     public static pointerToUint8Array(pointer: MemorySlotPointer): Uint8Array {
-        const pointerHex = pointer.toString(16).padStart(64, '0');
+        if (pointer < 0n) {
+            throw new RangeError('Pointer cannot be negative');
+        }
 
-        return BufferHelper.hexToUint8Array(pointerHex);
+        const hex = pointer.toString(16).padStart(64, '0');
+        if (hex.length > 64) {
+            throw new RangeError('Pointer exceeds 256-bit range');
+        }
+
+        return fromHex(hex);
     }
 
     public static uint8ArrayToPointer(input: Uint8Array): MemorySlotPointer {
-        const hex = BufferHelper.uint8ArrayToHex(input);
+        if (input.length === 0) {
+            return 0n;
+        }
 
-        return BigInt('0x' + hex);
+        return BigInt('0x' + toHex(input));
     }
 
     public static valueToUint8Array(value: bigint, length: number = U256_BYTE_LENGTH): Uint8Array {
-        const valueHex = value.toString(16).padStart(length * 2, '0');
+        if (value < 0n) {
+            throw new RangeError('Value cannot be negative');
+        }
 
-        return BufferHelper.hexToUint8Array(valueHex);
+        const hex = value.toString(16).padStart(length * 2, '0');
+        if (hex.length > length * 2) {
+            throw new RangeError(`Value exceeds ${length}-byte range`);
+        }
+
+        return fromHex(hex);
     }
 
     public static uint8ArrayToValue(input: Uint8Array): bigint {
-        const hex = BufferHelper.uint8ArrayToHex(input);
-
-        if (!hex) return BigInt(0);
+        if (input.length === 0) {
+            return 0n;
+        }
 
-        return BigInt('0x' + hex);
+        return BigInt('0x' + toHex(input));
     }
 }

package/src/utxo/OPNetLimitedProvider.ts

@@ -1,9 +1,9 @@
-import { Network } from '@btc-vision/bitcoin';
-import { IFundingTransactionParameters } from '../transaction/interfaces/ITransactionParameters.js';
+import type { Network } from '@btc-vision/bitcoin';
+import type { IFundingTransactionParameters } from '../transaction/interfaces/ITransactionParameters.js';
 import { TransactionFactory } from '../transaction/TransactionFactory.js';
 import { Wallet } from '../keypair/Wallet.js';
-import { BroadcastResponse } from './interfaces/BroadcastResponse.js';
-import {
+import type { BroadcastResponse } from './interfaces/BroadcastResponse.js';
+import type {
     FetchUTXOParams,
     FetchUTXOParamsMultiAddress,
     RawUTXOResponse,
@@ -100,10 +100,10 @@ export class OPNetLimitedProvider {
                 continue;
             }
 
-            const rawIndex = utxo.raw as unknown as number;
-            if (rawIndex === undefined || rawIndex === null) {
+            const rawIndex = Number(utxo.raw);
+            if (!Number.isInteger(rawIndex) || rawIndex < 0 || rawIndex >= rawTransactions.length) {
                 throw new Error(
-                    `Missing raw index for UTXO ${utxo.transactionId}:${utxo.outputIndex}`,
+                    `Invalid raw index for UTXO ${utxo.transactionId}:${utxo.outputIndex}`,
                 );
             }
 
@@ -168,8 +168,8 @@ export class OPNetLimitedProvider {
                 break;
             }
 
-            currentAmount += utxo.value;
-            finalUTXOs.push(utxo);
+            currentAmount += (utxo as UTXO).value;
+            finalUTXOs.push(utxo as UTXO);
         }
 
         return finalUTXOs;

package/src/utxo/interfaces/IUTXO.ts

@@ -1,5 +1,5 @@
-import { ScriptPubKey } from '@btc-vision/bitcoin-rpc';
-import { RotationSignerBase } from '../../signer/IRotationSigner.js';
+import type { ScriptPubKey } from '@btc-vision/bitcoin-rpc';
+import type { RotationSignerBase } from '../../signer/IRotationSigner.js';
 
 export interface UTXO {
     readonly transactionId: string;
@@ -7,9 +7,9 @@ export interface UTXO {
     readonly value: bigint;
     readonly scriptPubKey: ScriptPubKey;
 
-    redeemScript?: string | Buffer;
-    witnessScript?: string | Buffer;
-    nonWitnessUtxo?: string | Buffer;
+    redeemScript?: string | Uint8Array;
+    witnessScript?: string | Uint8Array;
+    nonWitnessUtxo?: string | Uint8Array;
 
     /**
      * Optional signer for this specific UTXO.
@@ -23,8 +23,8 @@ export interface FetchUTXOParams {
     readonly address: string;
     readonly minAmount: bigint;
     readonly requestedAmount: bigint;
-    optimized?: boolean;
-    usePendingUTXO?: boolean;
+    optimized?: boolean | undefined;
+    usePendingUTXO?: boolean | undefined;
 }
 
 export interface FetchUTXOParamsMultiAddress {

package/src/verification/TapscriptVerificator.ts

@@ -1,113 +1,65 @@
 import {
+    concat,
     crypto as bitCrypto,
-    Network,
+    equals,
+    type Network,
     networks,
     opcodes,
-    Payment,
+    type P2TRPayment,
+    type Payment,
     payments,
+    type PublicKey,
     script,
-    Taptree,
+    type Script,
+    type Taptree,
     toXOnly,
 } from '@btc-vision/bitcoin';
 import { DeploymentGenerator } from '../generators/builders/DeploymentGenerator.js';
-import { IChallengeSolution } from '../epoch/interfaces/IChallengeSolution.js';
-import { Feature, Features } from '../generators/Features.js';
+import type { IChallengeSolution } from '../epoch/interfaces/IChallengeSolution.js';
+import { type Feature, Features } from '../generators/Features.js';
 
 export interface ContractAddressVerificationParams {
-    readonly deployerPubKey: Buffer;
-    readonly contractSaltPubKey: Buffer;
-    readonly originalSalt: Buffer;
-    readonly bytecode: Buffer;
+    readonly deployerPubKey: PublicKey;
+    readonly contractSaltPubKey: Uint8Array;
+    readonly originalSalt: Uint8Array;
+    readonly bytecode: Uint8Array;
     readonly challenge: IChallengeSolution;
     readonly priorityFee: bigint;
     readonly features: Feature<Features>[];
-    readonly calldata?: Buffer;
+    readonly calldata?: Uint8Array;
     readonly network?: Network;
 }
 
+interface ScriptTreeComponents {
+    readonly scriptTree: Taptree;
+    readonly compiledTargetScript: Uint8Array;
+    readonly network: Network;
+}
+
 export class TapscriptVerificator {
     private static readonly TAP_SCRIPT_VERSION: number = 192;
 
     public static getContractAddress(
         params: ContractAddressVerificationParams,
     ): string | undefined {
-        const network = params.network || networks.bitcoin;
-        const scriptBuilder: DeploymentGenerator = new DeploymentGenerator(
-            params.deployerPubKey,
-            toXOnly(params.contractSaltPubKey),
-            network,
-        );
-
-        const compiledTargetScript: Buffer = scriptBuilder.compile(
-            params.bytecode,
-            params.originalSalt,
-            params.challenge,
-            params.priorityFee,
-            params.calldata,
-            params.features,
-        );
-
-        const lockLeafScript = script.compile([
-            toXOnly(params.deployerPubKey),
-            opcodes.OP_CHECKSIG,
-        ]);
-
-        const scriptTree: Taptree = [
-            {
-                output: compiledTargetScript,
-                version: TapscriptVerificator.TAP_SCRIPT_VERSION,
-            },
-            {
-                output: lockLeafScript,
-                version: TapscriptVerificator.TAP_SCRIPT_VERSION,
-            },
-        ];
+        const { scriptTree } = TapscriptVerificator.buildScriptTree(params);
 
         return TapscriptVerificator.generateAddressFromScript(params, scriptTree);
     }
 
     public static verifyControlBlock(
         params: ContractAddressVerificationParams,
-        controlBlock: Buffer,
+        controlBlock: Uint8Array,
     ): boolean {
-        const network = params.network || networks.bitcoin;
-        const scriptBuilder: DeploymentGenerator = new DeploymentGenerator(
-            params.deployerPubKey,
-            toXOnly(params.contractSaltPubKey),
-            network,
-        );
-
-        const compiledTargetScript: Buffer = scriptBuilder.compile(
-            params.bytecode,
-            params.originalSalt,
-            params.challenge,
-            params.priorityFee,
-            params.calldata,
-            params.features,
-        );
-
-        const lockLeafScript = script.compile([
-            toXOnly(params.deployerPubKey),
-            opcodes.OP_CHECKSIG,
-        ]);
-
-        const scriptTree: Taptree = [
-            {
-                output: compiledTargetScript,
-                version: TapscriptVerificator.TAP_SCRIPT_VERSION,
-            },
-            {
-                output: lockLeafScript,
-                version: TapscriptVerificator.TAP_SCRIPT_VERSION,
-            },
-        ];
+        const { scriptTree, compiledTargetScript, network } =
+            TapscriptVerificator.buildScriptTree(params);
 
         const tapData = payments.p2tr({
             internalPubkey: toXOnly(params.deployerPubKey),
             network: network,
             scriptTree: scriptTree,
             redeem: {
-                output: compiledTargetScript,
+                output: compiledTargetScript as Script,
                 redeemVersion: TapscriptVerificator.TAP_SCRIPT_VERSION,
             },
         });
@@ -117,18 +69,17 @@ export class TapscriptVerificator {
             return false;
         }
 
-        const requiredControlBlock: Buffer = witness[witness.length - 1];
-        return requiredControlBlock.equals(controlBlock);
+        const requiredControlBlock: Uint8Array = witness[witness.length - 1] as Uint8Array;
+        return equals(requiredControlBlock, controlBlock);
     }
 
     public static getContractSeed(
-        deployerPubKey: Buffer,
-        bytecode: Buffer,
-        saltHash: Buffer,
-    ): Buffer {
-        const sha256OfBytecode: Buffer = bitCrypto.hash256(bytecode);
-        const buf: Buffer = Buffer.concat([deployerPubKey, saltHash, sha256OfBytecode]);
-
+        deployerPubKey: Uint8Array,
+        bytecode: Uint8Array,
+        saltHash: Uint8Array,
+    ): Uint8Array {
+        const sha256OfBytecode: Uint8Array = bitCrypto.hash256(bytecode);
+        const buf: Uint8Array = concat([deployerPubKey, saltHash, sha256OfBytecode]);
         return bitCrypto.hash256(buf);
     }
 
@@ -137,14 +88,50 @@ export class TapscriptVerificator {
         scriptTree: Taptree,
     ): string | undefined {
         const network = params.network || networks.bitcoin;
-
-        const transactionData: Payment = {
+        const transactionData: Omit<P2TRPayment, 'name'> = {
             internalPubkey: toXOnly(params.deployerPubKey),
             network: network,
             scriptTree: scriptTree,
         };
-
         const tx: Payment = payments.p2tr(transactionData);
         return tx.address;
     }
+
+    private static buildScriptTree(
+        params: ContractAddressVerificationParams,
+    ): ScriptTreeComponents {
+        const network = params.network || networks.bitcoin;
+        const scriptBuilder: DeploymentGenerator = new DeploymentGenerator(
+            params.deployerPubKey,
+            toXOnly(params.contractSaltPubKey as PublicKey),
+            network,
+        );
+
+        const compiledTargetScript: Uint8Array = scriptBuilder.compile(
+            params.bytecode,
+            params.originalSalt,
+            params.challenge,
+            params.priorityFee,
+            params.calldata,
+            params.features,
+        );
+
+        const lockLeafScript: Script = script.compile([
+            toXOnly(params.deployerPubKey),
+            opcodes.OP_CHECKSIG,
+        ]);
+
+        const scriptTree: Taptree = [
+            {
+                output: compiledTargetScript,
+                version: TapscriptVerificator.TAP_SCRIPT_VERSION,
+            },
+            {
+                output: lockLeafScript,
+                version: TapscriptVerificator.TAP_SCRIPT_VERSION,
+            },
+        ];
+
+        return { scriptTree, compiledTargetScript, network };
+    }
 }