@btc-vision/transaction 1.8.0-beta.3 → 1.8.0-beta.5

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

package/test/address-rotation.test.ts

@@ -5,22 +5,19 @@ import {
     disabledAddressRotation,
     EcKeyPair,
     FundingTransaction,
-    SignerMap,
-    RotationSigner,
-    AddressRotationConfig,
 } from '../build/opnet.js';
-import { networks, payments, toXOnly } from '@btc-vision/bitcoin';
-import { ECPairInterface } from 'ecpair';
-import { UTXO } from '../build/opnet.js';
+import type { SignerMap, RotationSigner, AddressRotationConfig, UTXO } from '../build/opnet.js';
+import { networks, payments, toXOnly, toHex, equals } from '@btc-vision/bitcoin';
+import type { UniversalSigner } from '@btc-vision/ecpair';
 
 describe('Address Rotation', () => {
     const network = networks.regtest;
 
     // Generate test keypairs
-    let signer1: ECPairInterface;
-    let signer2: ECPairInterface;
-    let signer3: ECPairInterface;
-    let defaultSigner: ECPairInterface;
+    let signer1: UniversalSigner;
+    let signer2: UniversalSigner;
+    let signer3: UniversalSigner;
+    let defaultSigner: UniversalSigner;
 
     let address1: string;
     let address2: string;
@@ -56,7 +53,7 @@ describe('Address Rotation', () => {
             outputIndex: index,
             value,
             scriptPubKey: {
-                hex: p2tr.output!.toString('hex'),
+                hex: toHex(p2tr.output as Uint8Array),
                 address,
             },
         };
@@ -400,7 +397,7 @@ describe('Address Rotation', () => {
         });
 
         it('should handle many UTXOs from different addresses', async () => {
-            const signers: ECPairInterface[] = [];
+            const signers: UniversalSigner[] = [];
             const addresses: string[] = [];
             const utxos: UTXO[] = [];
 
@@ -413,9 +410,9 @@ describe('Address Rotation', () => {
                 utxos.push(createTaprootUtxo(addr, 20000n, i.toString().repeat(64), 0));
             }
 
-            const pairs: [string, ECPairInterface][] = addresses.map((addr, i) => [
+            const pairs: [string, UniversalSigner][] = addresses.map((addr, i) => [
                 addr,
-                signers[i],
+                signers[i] as UniversalSigner,
             ]);
 
             const tx = new FundingTransaction({
@@ -515,13 +512,15 @@ describe('Address Rotation', () => {
             const inputs = tx.getInputs();
 
             // Verify each input has the correct tapInternalKey
-            const expectedKey1 = toXOnly(Buffer.from(signer1.publicKey));
-            const expectedKey2 = toXOnly(Buffer.from(signer2.publicKey));
-
-            expect(inputs[0].tapInternalKey).toBeDefined();
-            expect(inputs[1].tapInternalKey).toBeDefined();
-            expect(inputs[0].tapInternalKey!.equals(expectedKey1)).toBe(true);
-            expect(inputs[1].tapInternalKey!.equals(expectedKey2)).toBe(true);
+            const expectedKey1 = toXOnly(signer1.publicKey);
+            const expectedKey2 = toXOnly(signer2.publicKey);
+
+            const input0 = inputs[0] as (typeof inputs)[0];
+            const input1 = inputs[1] as (typeof inputs)[0];
+            expect(input0.tapInternalKey).toBeDefined();
+            expect(input1.tapInternalKey).toBeDefined();
+            expect(equals(input0.tapInternalKey as Uint8Array, expectedKey1)).toBe(true);
+            expect(equals(input1.tapInternalKey as Uint8Array, expectedKey2)).toBe(true);
         });
 
         it('should use default signer tapInternalKey when rotation disabled', async () => {
@@ -544,10 +543,11 @@ describe('Address Rotation', () => {
             await tx.generateTransactionMinimalSignatures();
 
             const inputs = tx.getInputs();
-            const expectedKey = toXOnly(Buffer.from(defaultSigner.publicKey));
+            const expectedKey = toXOnly(defaultSigner.publicKey);
 
-            expect(inputs[0].tapInternalKey).toBeDefined();
-            expect(inputs[0].tapInternalKey!.equals(expectedKey)).toBe(true);
+            const input0 = inputs[0] as (typeof inputs)[0];
+            expect(input0.tapInternalKey).toBeDefined();
+            expect(equals(input0.tapInternalKey as Uint8Array, expectedKey)).toBe(true);
         });
     });
 });

package/test/address.test.ts

@@ -1,6 +1,6 @@
 import { describe, expect, it } from 'vitest';
 import { Address, MLDSASecurityLevel, Mnemonic } from '../build/opnet.js';
-import { networks } from '@btc-vision/bitcoin';
+import { networks, toHex } from '@btc-vision/bitcoin';
 
 describe('Address - Comprehensive Tests', () => {
     const testMnemonic =
@@ -283,9 +283,9 @@ describe('Address - Comprehensive Tests', () => {
             const address = new Address(bytes);
 
             const buffer = address.toBuffer();
-            expect(buffer).toBeInstanceOf(Buffer);
+            expect(buffer).toBeInstanceOf(Uint8Array);
             expect(buffer.length).toBe(32);
-            expect(buffer.toString('hex')).toContain('aaaa');
+            expect(toHex(buffer)).toContain('aaaa');
         });
 
         it('should toString return same as toHex', () => {
@@ -318,7 +318,7 @@ describe('Address - Comprehensive Tests', () => {
             const addr = getValidAddress();
             const buffer = addr.tweakedPublicKeyToBuffer();
 
-            expect(buffer).toBeInstanceOf(Buffer);
+            expect(buffer).toBeInstanceOf(Uint8Array);
             expect(buffer.length).toBe(32);
         });
 
@@ -349,7 +349,7 @@ describe('Address - Comprehensive Tests', () => {
             const addr = getValidAddress();
             const buffer = addr.toTweakedHybridPublicKeyBuffer();
 
-            expect(buffer).toBeInstanceOf(Buffer);
+            expect(buffer).toBeInstanceOf(Uint8Array);
         });
 
         it('should throw error for toTweakedHybridPublicKeyBuffer without key', () => {
@@ -381,7 +381,7 @@ describe('Address - Comprehensive Tests', () => {
             const addr = getValidAddress();
             const buffer = addr.toUncompressedBuffer();
 
-            expect(buffer).toBeInstanceOf(Buffer);
+            expect(buffer).toBeInstanceOf(Uint8Array);
             expect(buffer.length).toBe(65);
         });
 
@@ -410,7 +410,7 @@ describe('Address - Comprehensive Tests', () => {
             const addr = getValidAddress();
             const buffer = addr.toHybridPublicKeyBuffer();
 
-            expect(buffer).toBeInstanceOf(Buffer);
+            expect(buffer).toBeInstanceOf(Uint8Array);
         });
 
         it('should throw error for toHybridPublicKeyBuffer without key', () => {
@@ -424,7 +424,7 @@ describe('Address - Comprehensive Tests', () => {
             const addr = getValidAddress();
             const buffer = addr.originalPublicKeyBuffer();
 
-            expect(buffer).toBeInstanceOf(Buffer);
+            expect(buffer).toBeInstanceOf(Uint8Array);
             expect(buffer.length).toBe(33);
         });
 
@@ -813,7 +813,7 @@ describe('Address - Comprehensive Tests', () => {
             const p2wda = addr.p2wda(networks.bitcoin);
 
             expect(p2wda.address).toMatch(/^bc1q/);
-            expect(p2wda.witnessScript).toBeInstanceOf(Buffer);
+            expect(p2wda.witnessScript).toBeInstanceOf(Uint8Array);
         });
 
         it('should cache p2wda for same network', () => {
@@ -851,7 +851,7 @@ describe('Address - Comprehensive Tests', () => {
             const csv = addr.toCSV(100, networks.bitcoin);
 
             expect(csv.address).toMatch(/^bc1q/);
-            expect(csv.witnessScript).toBeInstanceOf(Buffer);
+            expect(csv.witnessScript).toBeInstanceOf(Uint8Array);
         });
 
         it('should generate CSV address with valid duration (bigint)', () => {
@@ -1029,8 +1029,8 @@ describe('Address - Comprehensive Tests', () => {
             }
 
             for (let i = 0; i < addresses.length - 1; i++) {
-                expect(addresses[i].lessThan(addresses[i + 1])).toBe(true);
-                expect(addresses[i + 1].greaterThan(addresses[i])).toBe(true);
+                expect((addresses[i] as Address).lessThan(addresses[i + 1] as Address)).toBe(true);
+                expect((addresses[i + 1] as Address).greaterThan(addresses[i] as Address)).toBe(true);
             }
         });
     });