@btc-vision/transaction 1.2.14 → 1.3.0

package/build/buffer/BinaryWriter.js

@@ -12,34 +12,34 @@ export class BinaryWriter {
         this.allocSafe(U8_BYTE_LENGTH);
         this.buffer.setUint8(this.currentOffset++, value);
     }
-    writeU16(value) {
+    writeU16(value, be = true) {
         if (value > 65535)
             throw new Error('u16 value is too large.');
         this.allocSafe(U16_BYTE_LENGTH);
-        this.buffer.setUint16(this.currentOffset, value, true);
+        this.buffer.setUint16(this.currentOffset, value, !be);
         this.currentOffset += 2;
     }
-    writeU32(value, le = true) {
+    writeU32(value, be = true) {
         if (value > 4294967295)
             throw new Error('u32 value is too large.');
         this.allocSafe(U32_BYTE_LENGTH);
-        this.buffer.setUint32(this.currentOffset, value, le);
+        this.buffer.setUint32(this.currentOffset, value, !be);
         this.currentOffset += 4;
     }
-    writeU64(value) {
+    writeU64(value, be = true) {
         if (value > 18446744073709551615n)
             throw new Error('u64 value is too large.');
         this.allocSafe(U64_BYTE_LENGTH);
-        this.buffer.setBigUint64(this.currentOffset, value, true);
+        this.buffer.setBigUint64(this.currentOffset, value, !be);
         this.currentOffset += 8;
     }
     writeSelector(value) {
-        this.writeU32(value, false);
+        this.writeU32(value, true);
     }
     writeBoolean(value) {
         this.writeU8(value ? 1 : 0);
     }
-    writeI128(bigIntValue) {
+    writeI128(bigIntValue, be = true) {
         if (bigIntValue > 170141183460469231731687303715884105727n ||
             bigIntValue < -170141183460469231731687303715884105728n) {
             throw new Error('i128 value is too large.');
@@ -49,35 +49,57 @@ export class BinaryWriter {
         if (bytesToHex.byteLength !== I128_BYTE_LENGTH) {
             throw new Error(`Invalid i128 value: ${bigIntValue}`);
         }
-        for (let i = 0; i < bytesToHex.byteLength; i++) {
-            this.writeU8(bytesToHex[i]);
+        if (be) {
+            for (let i = 0; i < bytesToHex.byteLength; i++) {
+                this.writeU8(bytesToHex[i]);
+            }
+        }
+        else {
+            for (let i = bytesToHex.byteLength - 1; i >= 0; i--) {
+                this.writeU8(bytesToHex[i]);
+            }
         }
     }
-    writeU256(bigIntValue) {
+    writeU256(bigIntValue, be = true) {
         if (bigIntValue >
-            115792089237316195423570985008687907853269984665640564039457584007913129639935n) {
-            throw new Error('u256 value is too large.');
+            115792089237316195423570985008687907853269984665640564039457584007913129639935n &&
+            bigIntValue < 0n) {
+            throw new Error('u256 value is too large or negative.');
         }
         this.allocSafe(U256_BYTE_LENGTH);
         const bytesToHex = BufferHelper.valueToUint8Array(bigIntValue);
         if (bytesToHex.byteLength !== U256_BYTE_LENGTH) {
             throw new Error(`Invalid u256 value: ${bigIntValue}`);
         }
-        for (let i = 0; i < bytesToHex.byteLength; i++) {
-            this.writeU8(bytesToHex[i]);
+        if (be) {
+            for (let i = 0; i < bytesToHex.byteLength; i++) {
+                this.writeU8(bytesToHex[i]);
+            }
+        }
+        else {
+            for (let i = bytesToHex.byteLength - 1; i >= 0; i--) {
+                this.writeU8(bytesToHex[i]);
+            }
         }
     }
-    writeU128(bigIntValue) {
-        if (bigIntValue > 340282366920938463463374607431768211455n) {
-            throw new Error('u128 value is too large.');
+    writeU128(bigIntValue, be = true) {
+        if (bigIntValue > 340282366920938463463374607431768211455n && bigIntValue < 0n) {
+            throw new Error('u128 value is too large or negative.');
         }
         this.allocSafe(U128_BYTE_LENGTH);
         const bytesToHex = BufferHelper.valueToUint8Array(bigIntValue, U128_BYTE_LENGTH);
         if (bytesToHex.byteLength !== U128_BYTE_LENGTH) {
             throw new Error(`Invalid u128 value: ${bigIntValue}`);
         }
-        for (let i = 0; i < bytesToHex.byteLength; i++) {
-            this.writeU8(bytesToHex[i]);
+        if (be) {
+            for (let i = 0; i < bytesToHex.byteLength; i++) {
+                this.writeU8(bytesToHex[i]);
+            }
+        }
+        else {
+            for (let i = bytesToHex.byteLength - 1; i >= 0; i--) {
+                this.writeU8(bytesToHex[i]);
+            }
         }
     }
     writeBytes(value) {
@@ -114,13 +136,6 @@ export class BinaryWriter {
         this.currentOffset = 0;
         this.buffer = this.getDefaultBuffer(4);
     }
-    writeTuple(values) {
-        this.allocSafe(U32_BYTE_LENGTH + values.length * U256_BYTE_LENGTH);
-        this.writeU32(values.length);
-        for (let i = 0; i < values.length; i++) {
-            this.writeU256(values[i]);
-        }
-    }
     toBytesReader() {
         return new BinaryReader(this.getBuffer());
     }
@@ -139,14 +154,10 @@ export class BinaryWriter {
             this.resize(size);
         }
     }
-    writeABISelector(name, selector) {
-        this.writeStringWithLength(name);
-        this.writeSelector(selector);
-    }
-    writeAddressValueTupleMap(map) {
+    writeAddressValueTuple(map, be = true) {
         if (map.size > 65535)
             throw new Error('Map size is too large');
-        this.writeU16(map.size);
+        this.writeU16(map.size, be);
         const keys = Array.from(map.keys());
         for (let i = 0; i < keys.length; i++) {
             const key = keys[i];
@@ -154,26 +165,7 @@ export class BinaryWriter {
             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]);
-            }
+            this.writeU256(value, be);
         }
     }
     writeBytesWithLength(value) {
@@ -188,28 +180,28 @@ export class BinaryWriter {
             this.writeAddress(value[i]);
         }
     }
-    writeU32Array(value) {
+    writeU32Array(value, be = true) {
         if (value.length > 65535)
             throw new Error('Array size is too large');
-        this.writeU16(value.length);
+        this.writeU16(value.length, be);
         for (let i = 0; i < value.length; i++) {
-            this.writeU32(value[i]);
+            this.writeU32(value[i], be);
         }
     }
-    writeU256Array(value) {
+    writeU256Array(value, be = true) {
         if (value.length > 65535)
             throw new Error('Array size is too large');
-        this.writeU16(value.length);
+        this.writeU16(value.length, be);
         for (let i = 0; i < value.length; i++) {
-            this.writeU256(value[i]);
+            this.writeU256(value[i], be);
         }
     }
-    writeU128Array(value) {
+    writeU128Array(value, be = true) {
         if (value.length > 65535)
             throw new Error('Array size is too large');
-        this.writeU16(value.length);
+        this.writeU16(value.length, be);
         for (let i = 0; i < value.length; i++) {
-            this.writeU128(value[i]);
+            this.writeU128(value[i], be);
         }
     }
     writeStringArray(value) {
@@ -220,12 +212,12 @@ export class BinaryWriter {
             this.writeStringWithLength(value[i]);
         }
     }
-    writeU16Array(value) {
+    writeU16Array(value, be = true) {
         if (value.length > 65535)
             throw new Error('Array size is too large');
-        this.writeU16(value.length);
+        this.writeU16(value.length, be);
         for (let i = 0; i < value.length; i++) {
-            this.writeU16(value[i]);
+            this.writeU16(value[i], be);
         }
     }
     writeU8Array(value) {
@@ -236,12 +228,12 @@ export class BinaryWriter {
             this.writeU8(value[i]);
         }
     }
-    writeU64Array(value) {
+    writeU64Array(value, be = true) {
         if (value.length > 65535)
             throw new Error('Array size is too large');
-        this.writeU16(value.length);
+        this.writeU16(value.length, be);
         for (let i = 0; i < value.length; i++) {
-            this.writeU64(value[i]);
+            this.writeU64(value[i], be);
         }
     }
     writeBytesArray(value) {
@@ -252,27 +244,6 @@ export class BinaryWriter {
             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);
-        });
-    }
     verifyAddress(pubKey) {
         if (pubKey.byteLength > ADDRESS_BYTE_LENGTH) {
             throw new Error(`Address is too long ${pubKey.byteLength} > ${ADDRESS_BYTE_LENGTH} bytes`);

package/build/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/build/keypair/Address.js

@@ -42,6 +42,9 @@ export class Address extends Uint8Array {
     static dead() {
         return Address.fromString('0x04678afdb0fe5548271967f1a67130b7105cd6a828e03909a67962e0ea1f61deb649f6bc3f4cef38c4f35504e51ec112de5c384df7ba0b8d578a4c702b6bf11d5f');
     }
+    static zero() {
+        return new Address();
+    }
     static fromString(pubKey) {
         if (!pubKey) {
             throw new Error('Invalid public key');

package/build/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/transaction/browser/extensions/UnisatSigner.js

@@ -1,4 +1,4 @@
-import { crypto as bitCrypto, script as bitScript, networks, Psbt, toXOnly, } from '@btc-vision/bitcoin';
+import { crypto as bitCrypto, networks, Psbt, script as bitScript, toXOnly, } from '@btc-vision/bitcoin';
 import { EcKeyPair } from '../../../keypair/EcKeyPair.js';
 import { canSignNonTaprootInput, isTaprootInput } from '../../../signer/SignerUtils.js';
 import { CustomKeypair } from '../BrowserSignerBase.js';

package/package.json

@@ -1,7 +1,7 @@
 {
     "name": "@btc-vision/transaction",
     "type": "module",
-    "version": "1.2.14",
+    "version": "1.3.0",
     "author": "BlobMaster41",
     "description": "OPNet transaction library allows you to create and sign transactions for the OPNet network.",
     "engines": {

package/src/_version.ts

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

package/src/abi/ABICoder.ts

@@ -15,7 +15,6 @@ export enum ABIDataTypes {
     ADDRESS = 'ADDRESS',
     STRING = 'STRING',
     BYTES32 = 'BYTES32',
-    TUPLE = 'TUPLE',
     BYTES = 'BYTES',
     ADDRESS_UINT256_TUPLE = 'ADDRESS_UINT256_TUPLE',
     ARRAY_OF_ADDRESSES = 'ARRAY_OF_ADDRESSES',
@@ -67,9 +66,6 @@ export class ABICoder {
                 case ABIDataTypes.INT128:
                     result.push(byteReader.readI128());
                     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;