@btc-vision/transaction 1.0.113 → 1.0.114

package/build/utils/BufferHelper.js

@@ -0,0 +1,50 @@
+export class BufferHelper {
+    static bufferToUint8Array(buffer) {
+        if (Buffer.isBuffer(buffer)) {
+            const length = buffer.byteLength;
+            const arrayBuffer = new ArrayBuffer(length);
+            const view = new Uint8Array(arrayBuffer);
+            for (let i = 0; i < length; ++i) {
+                view[i] = buffer[i];
+            }
+            return view;
+        }
+        return buffer;
+    }
+    static uint8ArrayToHex(input) {
+        return Buffer.from(input, 0, input.byteLength).toString('hex');
+    }
+    static hexToUint8Array(input) {
+        if (input.startsWith('0x')) {
+            input = input.substring(2);
+        }
+        if (input.length % 2 !== 0) {
+            input = '0' + input;
+        }
+        const length = input.length / 2;
+        const buffer = new Uint8Array(length);
+        for (let i = 0; i < length; i++) {
+            buffer[i] = parseInt(input.substring(i * 2, i * 2 + 2), 16);
+        }
+        return buffer;
+    }
+    static pointerToUint8Array(pointer) {
+        const pointerHex = pointer.toString(16).padStart(64, '0');
+        return BufferHelper.hexToUint8Array(pointerHex);
+    }
+    static uint8ArrayToPointer(input) {
+        const hex = BufferHelper.uint8ArrayToHex(input);
+        return BigInt('0x' + hex);
+    }
+    static valueToUint8Array(value) {
+        const valueHex = value.toString(16).padStart(64, '0');
+        return BufferHelper.hexToUint8Array(valueHex);
+    }
+    static uint8ArrayToValue(input) {
+        const hex = BufferHelper.uint8ArrayToHex(input);
+        if (!hex)
+            return BigInt(0);
+        return BigInt('0x' + hex);
+    }
+}
+BufferHelper.EXPECTED_BUFFER_LENGTH = 32;

package/build/utils/types.d.ts

@@ -0,0 +1,12 @@
+import { DeterministicMap } from '../deterministic/DeterministicMap.js';
+export declare const ADDRESS_BYTE_LENGTH: number;
+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/build/utils/types.js

@@ -0,0 +1 @@
+export const ADDRESS_BYTE_LENGTH = 32;

package/build/utxo/OPNetLimitedProvider.d.ts

@@ -1,6 +1,5 @@
-import { Address } from '@btc-vision/bsi-binary';
 import { Network } from 'bitcoinjs-lib';
-import { Wallet } from '../opnet.js';
+import { Address, Wallet } from '../opnet.js';
 import { UnwrapGeneration } from '../wbtc/UnwrapGeneration.js';
 import { WrappedGeneration } from '../wbtc/WrappedGenerationParameters.js';
 import { BroadcastResponse } from './interfaces/BroadcastResponse.js';

package/build/utxo/OPNetLimitedProvider.js

@@ -182,7 +182,7 @@ export class OPNetLimitedProvider {
         if (receiver.length < 50) {
             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) {
             return;

package/build/verification/TapscriptVerificator.js

@@ -2,7 +2,7 @@ import { crypto as bitCrypto, networks, payments } from 'bitcoinjs-lib';
 import { toXOnly } from 'bitcoinjs-lib/src/psbt/bip371.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 class TapscriptVerificator {
     static getContractAddress(params) {
         const network = params.network || networks.bitcoin;
@@ -27,7 +27,8 @@ export class TapscriptVerificator {
     }
     static generateContractVirtualAddress(deployerPubKey, bytecode, saltHash, network = networks.bitcoin) {
         const virtualAddress = TapscriptVerificator.getContractSeed(deployerPubKey, bytecode, saltHash);
-        return AddressGenerator.generatePKSH(virtualAddress, network);
+        const address = new Address(virtualAddress);
+        return address.p2tr(network);
     }
     static generateAddressFromScript(params, scriptTree) {
         const network = params.network || networks.bitcoin;

package/package.json

@@ -1,7 +1,7 @@
 {
     "name": "@btc-vision/transaction",
     "type": "module",
-    "version": "1.0.113",
+    "version": "1.0.114",
     "author": "BlobMaster41",
     "description": "OPNet transaction library allows you to create and sign transactions for the OPNet network.",
     "engines": {
@@ -72,6 +72,7 @@
         "@babel/preset-react": "^7.24.1",
         "@babel/preset-typescript": "^7.24.1",
         "@types/node": "^22.5.5",
+        "@types/sha.js": "^2.4.4",
         "eslint": "^9.10.0",
         "gulp": "^5.0.0",
         "gulp-cached": "^1.1.1",
@@ -91,7 +92,6 @@
     "dependencies": {
         "@babel/plugin-proposal-object-rest-spread": "^7.20.7",
         "@bitcoinerlab/secp256k1": "^1.1.1",
-        "@btc-vision/bsi-binary": "^1.0.42",
         "@btc-vision/bsi-bitcoin-rpc": "^1.0.29",
         "@btc-vision/logger": "^1.0.6",
         "@eslint/js": "^9.10.0",
@@ -111,6 +111,7 @@
         "gulp-clean": "^0.4.0",
         "gulp-eslint-new": "^2.3.0",
         "process": "^0.11.10",
+        "sha.js": "^2.4.11",
         "ts-loader": "^9.5.1",
         "ts-node": "^10.9.2",
         "typescript": "^5.6.2"

package/src/_version.ts

@@ -1 +1 @@
-export const version = '1.0.113';
+export const version = '1.0.114';

package/src/abi/ABICoder.ts

@@ -0,0 +1,158 @@
+import shajs from 'sha.js';
+
+import { BinaryReader } from '../buffer/BinaryReader.js';
+import { BufferHelper } from '../utils/BufferHelper.js';
+
+export enum ABIDataTypes {
+    UINT8 = 'UINT8',
+    UINT16 = 'UINT16',
+    UINT32 = 'UINT32',
+    UINT64 = 'UINT64',
+    BOOL = 'BOOL',
+    ADDRESS = 'ADDRESS',
+    STRING = 'STRING',
+    BYTES32 = 'BYTES32',
+    UINT256 = 'UINT256',
+    TUPLE = 'TUPLE',
+    BYTES = 'BYTES',
+    ADDRESS_UINT256_TUPLE = 'ADDRESS_UINT256_TUPLE',
+    ARRAY_OF_ADDRESSES = 'ARRAY_OF_ADDRESSES',
+    ARRAY_OF_UINT256 = 'ARRAY_OF_UINT256',
+    ARRAY_OF_UINT64 = 'ARRAY_OF_UINT64',
+    ARRAY_OF_UINT32 = 'ARRAY_OF_UINT32',
+    ARRAY_OF_UINT16 = 'ARRAY_OF_UINT16',
+    ARRAY_OF_UINT8 = 'ARRAY_OF_UINT8',
+    ARRAY_OF_STRING = 'ARRAY_OF_STRING',
+    ARRAY_OF_BYTES = 'ARRAY_OF_BYTES',
+}
+
+export class ABICoder {
+    public decodeData(data: Uint8Array, types: ABIDataTypes[]): unknown[] {
+        const byteReader = new BinaryReader(data);
+        const result: unknown[] = [];
+
+        for (let i = 0; i < types.length; i++) {
+            const type = types[i];
+            switch (type) {
+                case ABIDataTypes.UINT8:
+                    result.push(byteReader.readU8());
+                    break;
+                case ABIDataTypes.UINT16:
+                    result.push(byteReader.readU16());
+                    break;
+                case ABIDataTypes.UINT32:
+                    result.push(byteReader.readU32());
+                    break;
+                case ABIDataTypes.BYTES32:
+                    result.push(byteReader.readBytes(32));
+                    break;
+                case ABIDataTypes.BOOL:
+                    result.push(byteReader.readBoolean());
+                    break;
+                case ABIDataTypes.ADDRESS:
+                    result.push(byteReader.readAddress());
+                    break;
+                case ABIDataTypes.STRING:
+                    result.push(byteReader.readStringWithLength());
+                    break;
+                case ABIDataTypes.UINT256:
+                    result.push(byteReader.readU256());
+                    break;
+                case ABIDataTypes.TUPLE: // very basic for now, only contains uint256
+                    result.push(byteReader.readTuple());
+                    break;
+                case ABIDataTypes.ADDRESS_UINT256_TUPLE:
+                    result.push(byteReader.readAddressValueTuple());
+                    break;
+                case ABIDataTypes.BYTES:
+                    result.push(byteReader.readBytesWithLength());
+                    break;
+                case ABIDataTypes.UINT64:
+                    result.push(byteReader.readU64());
+                    break;
+                case ABIDataTypes.ARRAY_OF_ADDRESSES:
+                    result.push(byteReader.readAddressArray());
+                    break;
+                case ABIDataTypes.ARRAY_OF_UINT256:
+                    result.push(byteReader.readU256Array());
+                    break;
+                case ABIDataTypes.ARRAY_OF_UINT64:
+                    result.push(byteReader.readU64Array());
+                    break;
+                case ABIDataTypes.ARRAY_OF_UINT32:
+                    result.push(byteReader.readU32Array());
+                    break;
+                case ABIDataTypes.ARRAY_OF_UINT16:
+                    result.push(byteReader.readU16Array());
+                    break;
+                case ABIDataTypes.ARRAY_OF_UINT8:
+                    result.push(byteReader.readU8Array());
+                    break;
+                case ABIDataTypes.ARRAY_OF_STRING:
+                    result.push(byteReader.readStringArray());
+                    break;
+                case ABIDataTypes.ARRAY_OF_BYTES:
+                    result.push(byteReader.readBytesArray());
+            }
+        }
+
+        return result;
+    }
+
+    public encodePointer(key: string): bigint {
+        const hash = this.sha256(key);
+        const finalBuffer = Buffer.alloc(BufferHelper.EXPECTED_BUFFER_LENGTH);
+        const selector = hash.subarray(0, BufferHelper.EXPECTED_BUFFER_LENGTH); // 32 bytes
+
+        for (let i = 0; i < BufferHelper.EXPECTED_BUFFER_LENGTH; i++) {
+            finalBuffer[i] = selector[i];
+        }
+
+        return BigInt('0x' + finalBuffer.toString('hex'));
+    }
+
+    public encodePointerHash(pointer: number, sub: bigint): Uint8Array {
+        const finalBuffer = new Uint8Array(BufferHelper.EXPECTED_BUFFER_LENGTH + 2); // 32 bytes for `sub` + 2 bytes for `pointer`
+        // Encode pointer
+        finalBuffer[0] = pointer & 0xff;
+        finalBuffer[1] = (pointer >> 8) & 0xff;
+
+        // Convert `sub` to Uint8Array and append it
+        const subKey = this.bigIntToUint8Array(sub, BufferHelper.EXPECTED_BUFFER_LENGTH); // Assuming a function to convert BigInt to Uint8Array of fixed size
+        finalBuffer.set(subKey, 2);
+
+        const hashed = this.sha256(finalBuffer);
+        if (hashed.byteLength !== BufferHelper.EXPECTED_BUFFER_LENGTH) {
+            throw new Error('Invalid hash length');
+        }
+
+        return hashed;
+    }
+
+    public encodeSelector(selectorIdentifier: string): string {
+        // first 4 bytes of sha256 hash of the function signature
+        const hash = this.sha256(selectorIdentifier);
+        const selector = hash.subarray(0, 4); // 4 bytes
+
+        return selector.toString('hex');
+    }
+
+    public numericSelectorToHex(selector: number): string {
+        return selector.toString(16);
+    }
+
+    private bigIntToUint8Array(bigIntValue: bigint, length: number): Uint8Array {
+        const byteArray = new Uint8Array(length);
+        const buf = BufferHelper.valueToUint8Array(bigIntValue);
+
+        for (let i = 0; i < length; i++) {
+            byteArray[i] = buf[i] || 0;
+        }
+
+        return byteArray;
+    }
+
+    private sha256(buffer: Buffer | string | Uint8Array): Buffer {
+        return new shajs.sha256().update(buffer).digest();
+    }
+}

package/src/buffer/BinaryReader.ts

@@ -0,0 +1,260 @@
+import { ADDRESS_BYTE_LENGTH, BufferLike, i32, Selector, u16, u32, u8 } from '../utils/types.js';
+import { Address } from '../keypair/Address.js';
+import { AddressMap } from '../deterministic/AddressMap.js';
+
+export class BinaryReader {
+    private buffer: DataView;
+
+    private currentOffset: i32 = 0;
+
+    constructor(bytes: BufferLike) {
+        this.buffer = new DataView(bytes.buffer);
+    }
+
+    public static stringCompare(a: string, b: string): number {
+        return a.localeCompare(b);
+    }
+
+    public static bigintCompare(a: bigint, b: bigint): number {
+        if (a < b) return -1;
+        if (a > b) return 1;
+        return 0;
+    }
+
+    public static numberCompare(a: number, b: number): number {
+        if (a < b) return -1;
+        if (a > b) return 1;
+        return 0;
+    }
+
+    public setBuffer(bytes: BufferLike): void {
+        this.buffer = new DataView(bytes.buffer);
+
+        this.currentOffset = 0;
+    }
+
+    public readAddressArray(): Address[] {
+        const length = this.readU16();
+        const result: Address[] = new Array<Address>(length);
+
+        for (let i = 0; i < length; i++) {
+            result[i] = this.readAddress();
+        }
+
+        return result;
+    }
+
+    public readU256Array(): bigint[] {
+        const length = this.readU16();
+        const result: bigint[] = new Array<bigint>(length);
+
+        for (let i = 0; i < length; i++) {
+            result[i] = this.readU256();
+        }
+
+        return result;
+    }
+
+    public readU64Array(): bigint[] {
+        const length = this.readU16();
+        const result: bigint[] = new Array<bigint>(length);
+
+        for (let i = 0; i < length; i++) {
+            result[i] = this.readU64();
+        }
+
+        return result;
+    }
+
+    public readU32Array(): u32[] {
+        const length = this.readU16();
+        const result: u32[] = new Array<u32>(length);
+
+        for (let i = 0; i < length; i++) {
+            result[i] = this.readU32();
+        }
+
+        return result;
+    }
+
+    public readU16Array(): u16[] {
+        const length = this.readU16();
+        const result: u16[] = new Array<u16>(length);
+
+        for (let i = 0; i < length; i++) {
+            result[i] = this.readU16();
+        }
+
+        return result;
+    }
+
+    public readU8Array(): u8[] {
+        const length = this.readU16();
+        const result: u8[] = new Array<u8>(length);
+
+        for (let i = 0; i < length; i++) {
+            result[i] = this.readU8();
+        }
+
+        return result;
+    }
+
+    public readStringArray(): string[] {
+        const length = this.readU16();
+        const result: string[] = new Array<string>(length);
+
+        for (let i = 0; i < length; i++) {
+            result[i] = this.readStringWithLength();
+        }
+
+        return result;
+    }
+
+    public readBytesArray(): Uint8Array[] {
+        const length = this.readU16();
+        const result: Uint8Array[] = new Array<Uint8Array>(length);
+
+        for (let i = 0; i < length; i++) {
+            result[i] = this.readBytesWithLength();
+        }
+
+        return result;
+    }
+
+    public readBytesWithLength(maxLength: number = 0): Uint8Array {
+        const length = this.readU32();
+
+        if (maxLength > 0 && length > maxLength) {
+            throw new Error('Data length exceeds maximum length.');
+        }
+
+        return this.readBytes(length);
+    }
+
+    public readTuple(): bigint[] {
+        const length = this.readU32();
+        const result: bigint[] = new Array<bigint>(length);
+
+        for (let i = 0; i < length; i++) {
+            result[i] = this.readU256();
+        }
+
+        return result;
+    }
+
+    public readU8(): u8 {
+        this.verifyEnd(this.currentOffset + 1);
+
+        return this.buffer.getUint8(this.currentOffset++);
+    }
+
+    public readU16(): u16 {
+        this.verifyEnd(this.currentOffset + 2);
+
+        const value = this.buffer.getUint16(this.currentOffset, true);
+        this.currentOffset += 2;
+
+        return value;
+    }
+
+    public readU32(le: boolean = true): u32 {
+        this.verifyEnd(this.currentOffset + 4);
+
+        const value = this.buffer.getUint32(this.currentOffset, le);
+        this.currentOffset += 4;
+
+        return value;
+    }
+
+    public readU64(): bigint {
+        this.verifyEnd(this.currentOffset + 8);
+
+        const value: bigint = this.buffer.getBigUint64(this.currentOffset, true);
+        this.currentOffset += 8;
+
+        return value;
+    }
+
+    public readAddressValueTuple(): AddressMap<bigint> {
+        const length = this.readU16();
+        const result = new AddressMap<bigint>();
+
+        for (let i = 0; i < length; i++) {
+            const address = this.readAddress();
+            const value = this.readU256();
+
+            if (result.has(address)) throw new Error('Duplicate address found in map');
+
+            result.set(address, value);
+        }
+
+        return result;
+    }
+
+    public readU256(): bigint {
+        const next32Bytes = this.readBytes(32);
+
+        return BigInt(
+            '0x' + next32Bytes.reduce((acc, byte) => acc + byte.toString(16).padStart(2, '0'), ''),
+        );
+    }
+
+    public readBytes(length: u32, zeroStop: boolean = false): Uint8Array {
+        let bytes: Uint8Array = new Uint8Array(length);
+        for (let i: u32 = 0; i < length; i++) {
+            const byte: u8 = this.readU8();
+            if (zeroStop && byte === 0) {
+                bytes = bytes.slice(0, i);
+                break;
+            }
+
+            bytes[i] = byte;
+        }
+
+        return bytes;
+    }
+
+    public readString(length: u16): string {
+        const textDecoder = new TextDecoder();
+        const bytes = this.readBytes(length, true);
+
+        return textDecoder.decode(bytes);
+    }
+
+    public readSelector(): Selector {
+        return this.readU32(false);
+    }
+
+    public readStringWithLength(): string {
+        const length = this.readU16();
+
+        return this.readString(length);
+    }
+
+    public readBoolean(): boolean {
+        return this.readU8() !== 0;
+    }
+
+    public readAddress(): Address {
+        const bytes: u8[] = new Array<u8>(ADDRESS_BYTE_LENGTH);
+        for (let i: u32 = 0; i < ADDRESS_BYTE_LENGTH; i++) {
+            bytes[i] = this.readU8();
+        }
+
+        return new Address(bytes);
+    }
+
+    public getOffset(): u16 {
+        return this.currentOffset;
+    }
+
+    public setOffset(offset: u16): void {
+        this.currentOffset = offset;
+    }
+
+    public verifyEnd(size: i32): void {
+        if (this.currentOffset > this.buffer.byteLength) {
+            throw new Error(`Expected to read ${size} bytes but read ${this.currentOffset} bytes`);
+        }
+    }
+}