@btc-vision/transaction 1.0.113 → 1.0.114

package/src/utils/BufferHelper.ts

@@ -0,0 +1,71 @@
+import { 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;
+    }
+
+    public static uint8ArrayToHex(input: Uint8Array): string {
+        return Buffer.from(input, 0, input.byteLength).toString('hex');
+    }
+
+    public static hexToUint8Array(input: string): Uint8Array {
+        if (input.startsWith('0x')) {
+            input = input.substring(2); // Remove the '0x' prefix
+        }
+
+        if (input.length % 2 !== 0) {
+            input = '0' + input; // Pad with a leading zero if the length is odd
+        }
+
+        const length = input.length / 2;
+        const buffer = new Uint8Array(length);
+
+        for (let i = 0; i < length; i++) {
+            // Use substring(i * 2, i * 2 + 2) to replace substr(i * 2, 2)
+            buffer[i] = parseInt(input.substring(i * 2, i * 2 + 2), 16);
+        }
+
+        return buffer;
+    }
+
+    public static pointerToUint8Array(pointer: MemorySlotPointer): Uint8Array {
+        const pointerHex = pointer.toString(16).padStart(64, '0');
+
+        return BufferHelper.hexToUint8Array(pointerHex);
+    }
+
+    public static uint8ArrayToPointer(input: Uint8Array): MemorySlotPointer {
+        const hex = BufferHelper.uint8ArrayToHex(input);
+
+        return BigInt('0x' + hex);
+    }
+
+    public static valueToUint8Array(value: bigint): Uint8Array {
+        const valueHex = value.toString(16).padStart(64, '0');
+
+        return BufferHelper.hexToUint8Array(valueHex);
+    }
+
+    public static uint8ArrayToValue(input: Uint8Array): bigint {
+        const hex = BufferHelper.uint8ArrayToHex(input);
+
+        if (!hex) return BigInt(0);
+
+        return BigInt('0x' + hex);
+    }
+}

package/src/utils/types.ts

@@ -0,0 +1,19 @@
+import { DeterministicMap } from '../deterministic/DeterministicMap.js';
+
+export const ADDRESS_BYTE_LENGTH: number = 32;
+
+export type MemorySlotPointer = bigint;
+
+export type BufferLike = Uint8Array | Buffer;
+
+export type MemorySlotData<T> = T;
+export type PointerStorage = DeterministicMap<MemorySlotPointer, MemorySlotData<bigint>>;
+
+export type i32 = number;
+export type u8 = number;
+export type u16 = number;
+export type u32 = number;
+
+export type u64 = bigint;
+
+export type Selector = number;

package/src/utxo/OPNetLimitedProvider.ts

@@ -1,7 +1,6 @@
-import { Address } from '@btc-vision/bsi-binary';
 import { Network } from 'bitcoinjs-lib';
 import { currentConsensusConfig } from '../consensus/ConsensusConfig.js';
-import { IFundingTransactionParameters, TransactionFactory, Wallet } from '../opnet.js';
+import { Address, IFundingTransactionParameters, TransactionFactory, Wallet } from '../opnet.js';
 import { UnwrappedGenerationParameters, WrappedGenerationParameters } from '../wbtc/Generate.js';
 import { UnwrapGeneration } from '../wbtc/UnwrapGeneration.js';
 import { WrappedGeneration } from '../wbtc/WrappedGenerationParameters.js';
@@ -249,7 +248,6 @@ export class OPNetLimitedProvider {
 
         const url: string = `${this.opnetAPIUrl}/api/v1/${this.rpc}`;
 
-        //try {
         const resp: Response = await fetch(url, params);
         if (!resp.ok) {
             throw new Error(`Failed to fetch to rpc: ${resp.statusText}`);
@@ -274,9 +272,6 @@ export class OPNetLimitedProvider {
         }
 
         return result;
-        //} catch (e) {
-        //    throw e;
-        //}
     }
 
     /**
@@ -305,7 +300,7 @@ export class OPNetLimitedProvider {
     /**
      * Fetches the wrap parameters from the OPNET node
      * @param {bigint} amount - The amount to wrap
-     * @param {Address} receiver - The receiver address
+     * @param {string} receiver - The receiver address
      * @returns {Promise<UnwrapGeneration | undefined>} - The wrap parameters fetched
      * @throws {Error} - If wrap parameters could not be fetched
      */
@@ -323,7 +318,7 @@ export class OPNetLimitedProvider {
             throw new Error('Invalid receiver address');
         }
 
-        const params = [1, amount.toString(), receiver];
+        const params = [1, amount.toString(), receiver.toHex()];
         const result = await this.rpcMethod('btc_generate', params);
 
         if (!result) {

package/src/verification/TapscriptVerificator.ts

@@ -3,7 +3,7 @@ import { toXOnly } from 'bitcoinjs-lib/src/psbt/bip371.js';
 import { Taptree } from 'bitcoinjs-lib/src/types.js';
 import { DeploymentGenerator } from '../generators/builders/DeploymentGenerator.js';
 import { TransactionBuilder } from '../transaction/builders/TransactionBuilder.js';
-import { AddressGenerator } from '../generators/AddressGenerator.js';
+import { Address } from '../keypair/Address.js';
 
 export interface ContractAddressVerificationParams {
     readonly deployerPubKey: Buffer;
@@ -70,7 +70,9 @@ export class TapscriptVerificator {
             saltHash,
         );
 
-        return AddressGenerator.generatePKSH(virtualAddress, network);
+        const address = new Address(virtualAddress);
+
+        return address.p2tr(network);
     }
 
     public static generateAddressFromScript(