@btc-vision/transaction 1.0.113 → 1.0.114

package/build/abi/ABICoder.js

@@ -0,0 +1,137 @@
+import shajs from 'sha.js';
+import { BinaryReader } from '../buffer/BinaryReader.js';
+import { BufferHelper } from '../utils/BufferHelper.js';
+export var ABIDataTypes;
+(function (ABIDataTypes) {
+    ABIDataTypes["UINT8"] = "UINT8";
+    ABIDataTypes["UINT16"] = "UINT16";
+    ABIDataTypes["UINT32"] = "UINT32";
+    ABIDataTypes["UINT64"] = "UINT64";
+    ABIDataTypes["BOOL"] = "BOOL";
+    ABIDataTypes["ADDRESS"] = "ADDRESS";
+    ABIDataTypes["STRING"] = "STRING";
+    ABIDataTypes["BYTES32"] = "BYTES32";
+    ABIDataTypes["UINT256"] = "UINT256";
+    ABIDataTypes["TUPLE"] = "TUPLE";
+    ABIDataTypes["BYTES"] = "BYTES";
+    ABIDataTypes["ADDRESS_UINT256_TUPLE"] = "ADDRESS_UINT256_TUPLE";
+    ABIDataTypes["ARRAY_OF_ADDRESSES"] = "ARRAY_OF_ADDRESSES";
+    ABIDataTypes["ARRAY_OF_UINT256"] = "ARRAY_OF_UINT256";
+    ABIDataTypes["ARRAY_OF_UINT64"] = "ARRAY_OF_UINT64";
+    ABIDataTypes["ARRAY_OF_UINT32"] = "ARRAY_OF_UINT32";
+    ABIDataTypes["ARRAY_OF_UINT16"] = "ARRAY_OF_UINT16";
+    ABIDataTypes["ARRAY_OF_UINT8"] = "ARRAY_OF_UINT8";
+    ABIDataTypes["ARRAY_OF_STRING"] = "ARRAY_OF_STRING";
+    ABIDataTypes["ARRAY_OF_BYTES"] = "ARRAY_OF_BYTES";
+})(ABIDataTypes || (ABIDataTypes = {}));
+export class ABICoder {
+    decodeData(data, types) {
+        const byteReader = new BinaryReader(data);
+        const result = [];
+        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:
+                    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;
+    }
+    encodePointer(key) {
+        const hash = this.sha256(key);
+        const finalBuffer = Buffer.alloc(BufferHelper.EXPECTED_BUFFER_LENGTH);
+        const selector = hash.subarray(0, BufferHelper.EXPECTED_BUFFER_LENGTH);
+        for (let i = 0; i < BufferHelper.EXPECTED_BUFFER_LENGTH; i++) {
+            finalBuffer[i] = selector[i];
+        }
+        return BigInt('0x' + finalBuffer.toString('hex'));
+    }
+    encodePointerHash(pointer, sub) {
+        const finalBuffer = new Uint8Array(BufferHelper.EXPECTED_BUFFER_LENGTH + 2);
+        finalBuffer[0] = pointer & 0xff;
+        finalBuffer[1] = (pointer >> 8) & 0xff;
+        const subKey = this.bigIntToUint8Array(sub, BufferHelper.EXPECTED_BUFFER_LENGTH);
+        finalBuffer.set(subKey, 2);
+        const hashed = this.sha256(finalBuffer);
+        if (hashed.byteLength !== BufferHelper.EXPECTED_BUFFER_LENGTH) {
+            throw new Error('Invalid hash length');
+        }
+        return hashed;
+    }
+    encodeSelector(selectorIdentifier) {
+        const hash = this.sha256(selectorIdentifier);
+        const selector = hash.subarray(0, 4);
+        return selector.toString('hex');
+    }
+    numericSelectorToHex(selector) {
+        return selector.toString(16);
+    }
+    bigIntToUint8Array(bigIntValue, length) {
+        const byteArray = new Uint8Array(length);
+        const buf = BufferHelper.valueToUint8Array(bigIntValue);
+        for (let i = 0; i < length; i++) {
+            byteArray[i] = buf[i] || 0;
+        }
+        return byteArray;
+    }
+    sha256(buffer) {
+        return new shajs.sha256().update(buffer).digest();
+    }
+}

package/build/buffer/BinaryReader.d.ts

@@ -0,0 +1,37 @@
+import { BufferLike, i32, Selector, u16, u32, u8 } from '../utils/types.js';
+import { Address } from '../keypair/Address.js';
+import { AddressMap } from '../deterministic/AddressMap.js';
+export declare class BinaryReader {
+    private buffer;
+    private currentOffset;
+    constructor(bytes: BufferLike);
+    static stringCompare(a: string, b: string): number;
+    static bigintCompare(a: bigint, b: bigint): number;
+    static numberCompare(a: number, b: number): number;
+    setBuffer(bytes: BufferLike): void;
+    readAddressArray(): Address[];
+    readU256Array(): bigint[];
+    readU64Array(): bigint[];
+    readU32Array(): u32[];
+    readU16Array(): u16[];
+    readU8Array(): u8[];
+    readStringArray(): string[];
+    readBytesArray(): Uint8Array[];
+    readBytesWithLength(maxLength?: number): Uint8Array;
+    readTuple(): bigint[];
+    readU8(): u8;
+    readU16(): u16;
+    readU32(le?: boolean): u32;
+    readU64(): bigint;
+    readAddressValueTuple(): AddressMap<bigint>;
+    readU256(): bigint;
+    readBytes(length: u32, zeroStop?: boolean): Uint8Array;
+    readString(length: u16): string;
+    readSelector(): Selector;
+    readStringWithLength(): string;
+    readBoolean(): boolean;
+    readAddress(): Address;
+    getOffset(): u16;
+    setOffset(offset: u16): void;
+    verifyEnd(size: i32): void;
+}

package/build/buffer/BinaryReader.js

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

package/build/buffer/BinaryWriter.d.ts

@@ -0,0 +1,46 @@
+import { Selector, u16, u32, u64, u8 } from '../utils/types.js';
+import { Address } from '../keypair/Address.js';
+import { BinaryReader } from './BinaryReader.js';
+import { AddressMap } from '../deterministic/AddressMap.js';
+export declare class BinaryWriter {
+    private currentOffset;
+    private buffer;
+    constructor(length?: number);
+    writeU8(value: u8): void;
+    writeU16(value: u16): void;
+    writeU32(value: u32, le?: boolean): void;
+    writeU64(value: u64): void;
+    writeSelector(value: Selector): void;
+    writeBoolean(value: boolean): void;
+    writeU256(bigIntValue: bigint): void;
+    writeBytes(value: Uint8Array | Buffer): void;
+    writeString(value: string): void;
+    writeAddress(value: Address): void;
+    writeStringWithLength(value: string): void;
+    getBuffer(clear?: boolean): Uint8Array;
+    reset(): void;
+    writeTuple(values: bigint[]): void;
+    toBytesReader(): BinaryReader;
+    getOffset(): u32;
+    setOffset(offset: u32): void;
+    clear(): void;
+    allocSafe(size: u32): void;
+    writeABISelector(name: string, selector: Selector): void;
+    writeAddressValueTupleMap(map: AddressMap<bigint>): void;
+    writeLimitedAddressBytesMap(map: AddressMap<Uint8Array[]>): void;
+    writeBytesWithLength(value: Uint8Array): void;
+    writeAddressArray(value: Address[]): void;
+    writeU32Array(value: u32[]): void;
+    writeU256Array(value: bigint[]): void;
+    writeStringArray(value: string[]): void;
+    writeU16Array(value: u16[]): void;
+    writeU8Array(value: u8[]): void;
+    writeU64Array(value: bigint[]): void;
+    writeBytesArray(value: Uint8Array[]): void;
+    writeSelectorArray(value: Selector[]): void;
+    private getChecksum;
+    private writeMethodSelectorMap;
+    private fromAddress;
+    private resize;
+    private getDefaultBuffer;
+}

package/build/buffer/BinaryWriter.js

@@ -0,0 +1,258 @@
+import { BufferHelper } from '../utils/BufferHelper.js';
+import { ADDRESS_BYTE_LENGTH } from '../utils/types.js';
+import { BinaryReader } from './BinaryReader.js';
+export class BinaryWriter {
+    constructor(length = 0) {
+        this.currentOffset = 0;
+        this.buffer = this.getDefaultBuffer(length);
+    }
+    writeU8(value) {
+        if (value > 255)
+            throw new Error('Value is too large.');
+        this.allocSafe(1);
+        this.buffer.setUint8(this.currentOffset++, value);
+    }
+    writeU16(value) {
+        if (value > 65535)
+            throw new Error('Value is too large.');
+        this.allocSafe(2);
+        this.buffer.setUint16(this.currentOffset, value, true);
+        this.currentOffset += 2;
+    }
+    writeU32(value, le = true) {
+        if (value > 4294967295)
+            throw new Error('Value is too large.');
+        this.allocSafe(4);
+        this.buffer.setUint32(this.currentOffset, value, le);
+        this.currentOffset += 4;
+    }
+    writeU64(value) {
+        if (value > 18446744073709551615n)
+            throw new Error('Value is too large.');
+        this.allocSafe(8);
+        this.buffer.setBigUint64(this.currentOffset, value, true);
+        this.currentOffset += 8;
+    }
+    writeSelector(value) {
+        this.writeU32(value, false);
+    }
+    writeBoolean(value) {
+        this.writeU8(value ? 1 : 0);
+    }
+    writeU256(bigIntValue) {
+        if (bigIntValue >
+            115792089237316195423570985008687907853269984665640564039457584007913129639935n) {
+            throw new Error('Value is too large.');
+        }
+        this.allocSafe(32);
+        const bytesToHex = BufferHelper.valueToUint8Array(bigIntValue);
+        if (bytesToHex.byteLength !== 32) {
+            console.log('Invalid u256 value:', bytesToHex);
+            throw new Error(`Invalid u256 value: ${bigIntValue}`);
+        }
+        for (let i = 0; i < bytesToHex.byteLength; i++) {
+            this.writeU8(bytesToHex[i]);
+        }
+    }
+    writeBytes(value) {
+        this.allocSafe(value.byteLength);
+        for (let i = 0; i < value.byteLength; i++) {
+            this.writeU8(value[i]);
+        }
+    }
+    writeString(value) {
+        this.allocSafe(value.length);
+        for (let i = 0; i < value.length; i++) {
+            this.writeU8(value.charCodeAt(i));
+        }
+    }
+    writeAddress(value) {
+        const bytes = this.fromAddress(value);
+        this.writeBytes(bytes);
+    }
+    writeStringWithLength(value) {
+        this.allocSafe(value.length + 2);
+        this.writeU16(value.length);
+        this.writeString(value);
+    }
+    getBuffer(clear = true) {
+        const buf = new Uint8Array(this.buffer.byteLength);
+        for (let i = 0; i < this.buffer.byteLength; i++) {
+            buf[i] = this.buffer.getUint8(i);
+        }
+        if (clear)
+            this.clear();
+        return buf;
+    }
+    reset() {
+        this.currentOffset = 0;
+        this.buffer = this.getDefaultBuffer(4);
+    }
+    writeTuple(values) {
+        this.allocSafe(4 + values.length * 32);
+        this.writeU32(values.length);
+        for (let i = 0; i < values.length; i++) {
+            this.writeU256(values[i]);
+        }
+    }
+    toBytesReader() {
+        return new BinaryReader(this.getBuffer());
+    }
+    getOffset() {
+        return this.currentOffset;
+    }
+    setOffset(offset) {
+        this.currentOffset = offset;
+    }
+    clear() {
+        this.currentOffset = 0;
+        this.buffer = this.getDefaultBuffer();
+    }
+    allocSafe(size) {
+        if (this.currentOffset + size > this.buffer.byteLength) {
+            this.resize(size);
+        }
+    }
+    writeABISelector(name, selector) {
+        this.writeStringWithLength(name);
+        this.writeSelector(selector);
+    }
+    writeAddressValueTupleMap(map) {
+        if (map.size > 65535)
+            throw new Error('Map size is too large');
+        this.writeU16(map.size);
+        const keys = Array.from(map.keys());
+        for (let i = 0; i < keys.length; i++) {
+            const key = keys[i];
+            const value = map.get(key);
+            if (value === null || value === undefined)
+                throw new Error('Value not found');
+            this.writeAddress(key);
+            this.writeU256(value);
+        }
+    }
+    writeLimitedAddressBytesMap(map) {
+        if (map.size > 8)
+            throw new Error('Too many contract calls');
+        this.writeU8(map.size);
+        const keys = Array.from(map.keys());
+        for (let i = 0; i < keys.length; i++) {
+            const address = keys[i];
+            const calls = map.get(address);
+            if (!calls)
+                throw new Error('Calls not found');
+            if (calls.length > 10)
+                throw new Error('Too many calls.');
+            this.writeAddress(address);
+            this.writeU8(calls.length);
+            for (let j = 0; j < calls.length; j++) {
+                this.writeBytesWithLength(calls[j]);
+            }
+        }
+    }
+    writeBytesWithLength(value) {
+        this.writeU32(value.length);
+        this.writeBytes(value);
+    }
+    writeAddressArray(value) {
+        if (value.length > 65535)
+            throw new Error('Array size is too large');
+        this.writeU16(value.length);
+        for (let i = 0; i < value.length; i++) {
+            this.writeAddress(value[i]);
+        }
+    }
+    writeU32Array(value) {
+        if (value.length > 65535)
+            throw new Error('Array size is too large');
+        this.writeU16(value.length);
+        for (let i = 0; i < value.length; i++) {
+            this.writeU32(value[i]);
+        }
+    }
+    writeU256Array(value) {
+        if (value.length > 65535)
+            throw new Error('Array size is too large');
+        this.writeU16(value.length);
+        for (let i = 0; i < value.length; i++) {
+            this.writeU256(value[i]);
+        }
+    }
+    writeStringArray(value) {
+        if (value.length > 65535)
+            throw new Error('Array size is too large');
+        this.writeU16(value.length);
+        for (let i = 0; i < value.length; i++) {
+            this.writeStringWithLength(value[i]);
+        }
+    }
+    writeU16Array(value) {
+        if (value.length > 65535)
+            throw new Error('Array size is too large');
+        this.writeU16(value.length);
+        for (let i = 0; i < value.length; i++) {
+            this.writeU16(value[i]);
+        }
+    }
+    writeU8Array(value) {
+        if (value.length > 65535)
+            throw new Error('Array size is too large');
+        this.writeU16(value.length);
+        for (let i = 0; i < value.length; i++) {
+            this.writeU8(value[i]);
+        }
+    }
+    writeU64Array(value) {
+        if (value.length > 65535)
+            throw new Error('Array size is too large');
+        this.writeU16(value.length);
+        for (let i = 0; i < value.length; i++) {
+            this.writeU64(value[i]);
+        }
+    }
+    writeBytesArray(value) {
+        if (value.length > 65535)
+            throw new Error('Array size is too large');
+        this.writeU16(value.length);
+        for (let i = 0; i < value.length; i++) {
+            this.writeBytesWithLength(value[i]);
+        }
+    }
+    writeSelectorArray(value) {
+        if (value.length > 65535)
+            throw new Error('Array size is too large');
+        this.writeU16(value.length);
+        for (let i = 0; i < value.length; i++) {
+            this.writeSelector(value[i]);
+        }
+    }
+    getChecksum() {
+        let checksum = 0;
+        for (let i = 0; i < this.buffer.byteLength; i++) {
+            checksum += this.buffer.getUint8(i);
+        }
+        return checksum % 2 ** 32;
+    }
+    writeMethodSelectorMap(value) {
+        this.writeU16(value.size);
+        value.forEach((selector, _value, _set) => {
+            this.writeSelector(selector);
+        });
+    }
+    fromAddress(pubKey) {
+        if (pubKey.byteLength > ADDRESS_BYTE_LENGTH) {
+            throw new Error(`Address is too long ${pubKey.byteLength} > ${ADDRESS_BYTE_LENGTH} bytes`);
+        }
+        return pubKey;
+    }
+    resize(size) {
+        const buf = new Uint8Array(this.buffer.byteLength + size);
+        for (let i = 0; i < this.buffer.byteLength; i++) {
+            buf[i] = this.buffer.getUint8(i);
+        }
+        this.buffer = new DataView(buf.buffer);
+    }
+    getDefaultBuffer(length = 0) {
+        return new DataView(new ArrayBuffer(length));
+    }
+}

package/build/deterministic/AddressMap.d.ts

@@ -0,0 +1,10 @@
+import { i32 } from '../utils/types.js';
+import { Address } from '../keypair/Address.js';
+import { Map } from './Map.js';
+export declare class AddressMap<V> extends Map<Address, V> {
+    set(key: Address, value: V): void;
+    indexOf(address: Address): i32;
+    has(key: Address): boolean;
+    get(key: Address): V;
+    delete(key: Address): boolean;
+}