@btc-vision/transaction 1.2.14 → 1.3.0

package/browser/keypair/Address.d.ts

@@ -5,6 +5,7 @@ export declare class Address extends Uint8Array {
     get originalPublicKey(): Uint8Array | undefined;
     private get keyPair();
     static dead(): Address;
+    static zero(): Address;
     static fromString(pubKey: string): Address;
     static wrap(bytes: ArrayLike<number>): Address;
     static uncompressedToCompressed(publicKey: ArrayLike<number>): Buffer;

package/browser/transaction/browser/BrowserSignerBase.d.ts

@@ -11,6 +11,6 @@ export declare abstract class CustomKeypair implements Signer {
     abstract getPublicKey(): Buffer;
     abstract sign(hash: Buffer, lowR?: boolean): Buffer;
     abstract signSchnorr(hash: Buffer): Buffer;
-    abstract verify(hash: Buffer, signature: Buffer): boolean;
+    abstract verify(hash: Buffer, signature: Buffer): boolean | Buffer;
     abstract init(): Promise<void>;
 }

package/build/_version.d.ts

@@ -1 +1 @@
-export declare const version = "1.2.14";
+export declare const version = "1.3.0";

package/build/_version.js

@@ -1 +1 @@
-export const version = '1.2.14';
+export const version = '1.3.0';

package/build/abi/ABICoder.d.ts

@@ -10,7 +10,6 @@ export declare enum ABIDataTypes {
     ADDRESS = "ADDRESS",
     STRING = "STRING",
     BYTES32 = "BYTES32",
-    TUPLE = "TUPLE",
     BYTES = "BYTES",
     ADDRESS_UINT256_TUPLE = "ADDRESS_UINT256_TUPLE",
     ARRAY_OF_ADDRESSES = "ARRAY_OF_ADDRESSES",

package/build/abi/ABICoder.js

@@ -14,7 +14,6 @@ export var ABIDataTypes;
     ABIDataTypes["ADDRESS"] = "ADDRESS";
     ABIDataTypes["STRING"] = "STRING";
     ABIDataTypes["BYTES32"] = "BYTES32";
-    ABIDataTypes["TUPLE"] = "TUPLE";
     ABIDataTypes["BYTES"] = "BYTES";
     ABIDataTypes["ADDRESS_UINT256_TUPLE"] = "ADDRESS_UINT256_TUPLE";
     ABIDataTypes["ARRAY_OF_ADDRESSES"] = "ARRAY_OF_ADDRESSES";
@@ -64,9 +63,6 @@ export class ABICoder {
                 case ABIDataTypes.INT128:
                     result.push(byteReader.readI128());
                     break;
-                case ABIDataTypes.TUPLE:
-                    result.push(byteReader.readTuple());
-                    break;
                 case ABIDataTypes.ADDRESS_UINT256_TUPLE:
                     result.push(byteReader.readAddressValueTuple());
                     break;

package/build/buffer/BinaryReader.d.ts

@@ -9,32 +9,33 @@ export declare class BinaryReader {
     static bigintCompare(a: bigint, b: bigint): number;
     static numberCompare(a: number, b: number): number;
     setBuffer(bytes: BufferLike): void;
-    readAddressArray(): Address[];
-    readU256Array(): bigint[];
-    readU128Array(): 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>;
-    readU128(): bigint;
-    readU256(): bigint;
-    readI128(): bigint;
+    readU16(be?: boolean): u16;
+    readU32(be?: boolean): u32;
+    readU64(be?: boolean): bigint;
+    readU128(be?: boolean): bigint;
+    readU256(be?: boolean): bigint;
+    readI128(be?: boolean): bigint;
+    readBoolean(): boolean;
+    readSelector(): Selector;
     readBytes(length: u32, zeroStop?: boolean): Uint8Array;
     readString(length: u16): string;
-    readSelector(): Selector;
-    readStringWithLength(): string;
-    readBoolean(): boolean;
+    readStringWithLength(be?: boolean): string;
     readAddress(): Address;
+    readBytesWithLength(maxLength?: number, be?: boolean): Uint8Array;
+    readAddressArray(be?: boolean): Address[];
+    readU256Array(be?: boolean): bigint[];
+    readU128Array(be?: boolean): bigint[];
+    readU64Array(be?: boolean): bigint[];
+    readU32Array(be?: boolean): u32[];
+    readU16Array(be?: boolean): u16[];
+    readU8Array(): u8[];
+    readStringArray(be?: boolean): string[];
+    readBytesArray(be?: boolean): Uint8Array[];
+    readAddressValueTuple(be?: boolean): AddressMap<bigint>;
     getOffset(): u16;
     setOffset(offset: u16): void;
     verifyEnd(size: i32): void;
+    private reverseBytes;
+    private toHexString;
 }

package/build/buffer/BinaryReader.js

@@ -27,181 +27,184 @@ export class BinaryReader {
         this.buffer = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
         this.currentOffset = 0;
     }
-    readAddressArray() {
-        const length = this.readU16();
-        const result = new Array(length);
+    readU8() {
+        this.verifyEnd(this.currentOffset + U8_BYTE_LENGTH);
+        const value = this.buffer.getUint8(this.currentOffset);
+        this.currentOffset += U8_BYTE_LENGTH;
+        return value;
+    }
+    readU16(be = true) {
+        this.verifyEnd(this.currentOffset + U16_BYTE_LENGTH);
+        const value = this.buffer.getUint16(this.currentOffset, !be);
+        this.currentOffset += U16_BYTE_LENGTH;
+        return value;
+    }
+    readU32(be = true) {
+        this.verifyEnd(this.currentOffset + U32_BYTE_LENGTH);
+        const value = this.buffer.getUint32(this.currentOffset, !be);
+        this.currentOffset += U32_BYTE_LENGTH;
+        return value;
+    }
+    readU64(be = true) {
+        this.verifyEnd(this.currentOffset + U64_BYTE_LENGTH);
+        const value = this.buffer.getBigUint64(this.currentOffset, !be);
+        this.currentOffset += U64_BYTE_LENGTH;
+        return value;
+    }
+    readU128(be = true) {
+        const raw = this.readBytes(U128_BYTE_LENGTH);
+        let bytes = raw;
+        if (!be) {
+            bytes = this.reverseBytes(raw);
+        }
+        return BigInt('0x' + this.toHexString(bytes));
+    }
+    readU256(be = true) {
+        const raw = this.readBytes(U256_BYTE_LENGTH);
+        let bytes = raw;
+        if (!be) {
+            bytes = this.reverseBytes(raw);
+        }
+        return BigInt('0x' + this.toHexString(bytes));
+    }
+    readI128(be = true) {
+        const raw = this.readBytes(I128_BYTE_LENGTH);
+        let bytes = raw;
+        if (!be) {
+            bytes = this.reverseBytes(raw);
+        }
+        let value = BigInt('0x' + this.toHexString(bytes));
+        const signBitMask = 0x80;
+        if (bytes[0] & signBitMask) {
+            const twoTo128 = BigInt(1) << BigInt(128);
+            value = value - twoTo128;
+        }
+        return value;
+    }
+    readBoolean() {
+        return this.readU8() !== 0;
+    }
+    readSelector() {
+        return this.readU32(true);
+    }
+    readBytes(length, zeroStop = false) {
+        this.verifyEnd(this.currentOffset + length);
+        let bytes = new Uint8Array(length);
         for (let i = 0; i < length; i++) {
-            result[i] = this.readAddress();
+            const b = this.buffer.getUint8(this.currentOffset++);
+            if (zeroStop && b === 0) {
+                bytes = bytes.subarray(0, i);
+                break;
+            }
+            bytes[i] = b;
         }
-        return result;
+        return bytes;
+    }
+    readString(length) {
+        const textDecoder = new TextDecoder();
+        const bytes = this.readBytes(length, false);
+        return textDecoder.decode(bytes);
     }
-    readU256Array() {
-        const length = this.readU16();
+    readStringWithLength(be = true) {
+        const length = this.readU16(be);
+        return this.readString(length);
+    }
+    readAddress() {
+        const bytes = Array.from(this.readBytes(ADDRESS_BYTE_LENGTH));
+        return new Address(bytes);
+    }
+    readBytesWithLength(maxLength = 0, be = true) {
+        const length = this.readU32(be);
+        if (maxLength > 0 && length > maxLength) {
+            throw new Error('Data length exceeds maximum length.');
+        }
+        return this.readBytes(length);
+    }
+    readAddressArray(be = true) {
+        const length = this.readU16(be);
         const result = new Array(length);
         for (let i = 0; i < length; i++) {
-            result[i] = this.readU256();
+            result[i] = this.readAddress();
         }
         return result;
     }
-    readU128Array() {
-        const length = this.readU16();
+    readU256Array(be = true) {
+        const length = this.readU16(be);
         const result = new Array(length);
         for (let i = 0; i < length; i++) {
-            result[i] = this.readU128();
+            result[i] = this.readU256(be);
         }
         return result;
     }
-    readU64Array() {
-        const length = this.readU16();
+    readU128Array(be = true) {
+        const length = this.readU16(be);
         const result = new Array(length);
         for (let i = 0; i < length; i++) {
-            result[i] = this.readU64();
+            result[i] = this.readU128(be);
         }
         return result;
     }
-    readU32Array() {
-        const length = this.readU16();
+    readU64Array(be = true) {
+        const length = this.readU16(be);
         const result = new Array(length);
         for (let i = 0; i < length; i++) {
-            result[i] = this.readU32();
+            result[i] = this.readU64(be);
         }
         return result;
     }
-    readU16Array() {
-        const length = this.readU16();
+    readU32Array(be = true) {
+        const length = this.readU16(be);
         const result = new Array(length);
         for (let i = 0; i < length; i++) {
-            result[i] = this.readU16();
+            result[i] = this.readU32(be);
         }
         return result;
     }
-    readU8Array() {
-        const length = this.readU16();
+    readU16Array(be = true) {
+        const length = this.readU16(be);
         const result = new Array(length);
         for (let i = 0; i < length; i++) {
-            result[i] = this.readU8();
+            result[i] = this.readU16(be);
         }
         return result;
     }
-    readStringArray() {
-        const length = this.readU16();
+    readU8Array() {
+        const length = this.readU16(true);
         const result = new Array(length);
         for (let i = 0; i < length; i++) {
-            result[i] = this.readStringWithLength();
+            result[i] = this.readU8();
         }
         return result;
     }
-    readBytesArray() {
-        const length = this.readU16();
+    readStringArray(be = true) {
+        const length = this.readU16(be);
         const result = new Array(length);
         for (let i = 0; i < length; i++) {
-            result[i] = this.readBytesWithLength();
+            result[i] = this.readStringWithLength(be);
         }
         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();
+    readBytesArray(be = true) {
+        const length = this.readU16(be);
         const result = new Array(length);
         for (let i = 0; i < length; i++) {
-            result[i] = this.readU256();
+            result[i] = this.readBytesWithLength(0, be);
         }
         return result;
     }
-    readU8() {
-        this.verifyEnd(this.currentOffset + U8_BYTE_LENGTH);
-        const value = this.buffer.getUint8(this.currentOffset);
-        this.currentOffset += U8_BYTE_LENGTH;
-        return value;
-    }
-    readU16() {
-        this.verifyEnd(this.currentOffset + U16_BYTE_LENGTH);
-        const value = this.buffer.getUint16(this.currentOffset, true);
-        this.currentOffset += U16_BYTE_LENGTH;
-        return value;
-    }
-    readU32(le = true) {
-        this.verifyEnd(this.currentOffset + U32_BYTE_LENGTH);
-        const value = this.buffer.getUint32(this.currentOffset, le);
-        this.currentOffset += U32_BYTE_LENGTH;
-        return value;
-    }
-    readU64() {
-        this.verifyEnd(this.currentOffset + U64_BYTE_LENGTH);
-        const value = this.buffer.getBigUint64(this.currentOffset, true);
-        this.currentOffset += U64_BYTE_LENGTH;
-        return value;
-    }
-    readAddressValueTuple() {
-        const length = this.readU16();
+    readAddressValueTuple(be = true) {
+        const length = this.readU16(be);
         const result = new AddressMap();
         for (let i = 0; i < length; i++) {
             const address = this.readAddress();
-            const value = this.readU256();
-            if (result.has(address))
+            const value = this.readU256(be);
+            if (result.has(address)) {
                 throw new Error('Duplicate address found in map');
+            }
             result.set(address, value);
         }
         return result;
     }
-    readU128() {
-        const next16Bytes = this.readBytes(U128_BYTE_LENGTH);
-        return BigInt('0x' + next16Bytes.reduce((acc, byte) => acc + byte.toString(16).padStart(2, '0'), ''));
-    }
-    readU256() {
-        const next32Bytes = this.readBytes(U256_BYTE_LENGTH);
-        return BigInt('0x' + next32Bytes.reduce((acc, byte) => acc + byte.toString(16).padStart(2, '0'), ''));
-    }
-    readI128() {
-        const next16Bytes = this.readBytes(I128_BYTE_LENGTH);
-        let value = BigInt('0x' + next16Bytes.reduce((acc, byte) => acc + byte.toString(16).padStart(2, '0'), ''));
-        if (next16Bytes[0] & 0x80) {
-            const mask = (BigInt(1) << BigInt(128)) - BigInt(1);
-            value = (value ^ mask) + BigInt(1);
-            value = -value;
-        }
-        return value;
-    }
-    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;
     }
@@ -209,8 +212,18 @@ export class BinaryReader {
         this.currentOffset = offset;
     }
     verifyEnd(size) {
-        if (this.currentOffset > this.buffer.byteLength) {
-            throw new Error(`Expected to read ${size} bytes but read ${this.currentOffset} bytes`);
+        if (size > this.buffer.byteLength) {
+            throw new Error(`Attempt to read beyond buffer length: requested up to byte offset ${size}, but buffer is only ${this.buffer.byteLength} bytes.`);
         }
     }
+    reverseBytes(bytes) {
+        const out = new Uint8Array(bytes.length);
+        for (let i = 0; i < bytes.length; i++) {
+            out[i] = bytes[bytes.length - 1 - i];
+        }
+        return out;
+    }
+    toHexString(bytes) {
+        return Array.from(bytes, (b) => b.toString(16).padStart(2, '0')).join('');
+    }
 }

package/build/buffer/BinaryWriter.d.ts

@@ -7,42 +7,36 @@ export declare class BinaryWriter {
     private buffer;
     constructor(length?: number);
     writeU8(value: u8): void;
-    writeU16(value: u16): void;
-    writeU32(value: u32, le?: boolean): void;
-    writeU64(value: u64): void;
+    writeU16(value: u16, be?: boolean): void;
+    writeU32(value: u32, be?: boolean): void;
+    writeU64(value: u64, be?: boolean): void;
     writeSelector(value: Selector): void;
     writeBoolean(value: boolean): void;
-    writeI128(bigIntValue: bigint): void;
-    writeU256(bigIntValue: bigint): void;
-    writeU128(bigIntValue: bigint): void;
+    writeI128(bigIntValue: bigint, be?: boolean): void;
+    writeU256(bigIntValue: bigint, be?: boolean): void;
+    writeU128(bigIntValue: bigint, be?: boolean): 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;
+    writeAddressValueTuple(map: AddressMap<bigint>, be?: boolean): void;
     writeBytesWithLength(value: Uint8Array): void;
     writeAddressArray(value: Address[]): void;
-    writeU32Array(value: u32[]): void;
-    writeU256Array(value: bigint[]): void;
-    writeU128Array(value: bigint[]): void;
+    writeU32Array(value: u32[], be?: boolean): void;
+    writeU256Array(value: bigint[], be?: boolean): void;
+    writeU128Array(value: bigint[], be?: boolean): void;
     writeStringArray(value: string[]): void;
-    writeU16Array(value: u16[]): void;
+    writeU16Array(value: u16[], be?: boolean): void;
     writeU8Array(value: u8[]): void;
-    writeU64Array(value: bigint[]): void;
+    writeU64Array(value: bigint[], be?: boolean): void;
     writeBytesArray(value: Uint8Array[]): void;
-    writeSelectorArray(value: Selector[]): void;
-    private getChecksum;
-    private writeMethodSelectorMap;
     private verifyAddress;
     private resize;
     private getDefaultBuffer;