@btc-vision/transaction 1.1.5 → 1.1.7

package/build/_version.d.ts

@@ -1 +1 @@
-export declare const version = "1.1.5";
+export declare const version = "1.1.7";

package/build/_version.js

@@ -1 +1 @@
-export const version = '1.1.5';
+export const version = '1.1.7';

package/build/abi/ABICoder.d.ts

@@ -3,16 +3,18 @@ export declare enum ABIDataTypes {
     UINT16 = "UINT16",
     UINT32 = "UINT32",
     UINT64 = "UINT64",
+    UINT128 = "UINT128",
+    UINT256 = "UINT256",
     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_UINT128 = "ARRAY_OF_UINT128",
     ARRAY_OF_UINT64 = "ARRAY_OF_UINT64",
     ARRAY_OF_UINT32 = "ARRAY_OF_UINT32",
     ARRAY_OF_UINT16 = "ARRAY_OF_UINT16",
@@ -22,8 +24,6 @@ export declare enum ABIDataTypes {
 }
 export declare class ABICoder {
     decodeData(data: Uint8Array, types: ABIDataTypes[]): unknown[];
-    encodePointer(key: string): bigint;
-    encodePointerHash(pointer: number, sub: bigint): Uint8Array;
     encodeSelector(selectorIdentifier: string): string;
     numericSelectorToHex(selector: number): string;
     private bigIntToUint8Array;

package/build/abi/ABICoder.js

@@ -7,16 +7,18 @@ export var ABIDataTypes;
     ABIDataTypes["UINT16"] = "UINT16";
     ABIDataTypes["UINT32"] = "UINT32";
     ABIDataTypes["UINT64"] = "UINT64";
+    ABIDataTypes["UINT128"] = "UINT128";
+    ABIDataTypes["UINT256"] = "UINT256";
     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_UINT128"] = "ARRAY_OF_UINT128";
     ABIDataTypes["ARRAY_OF_UINT64"] = "ARRAY_OF_UINT64";
     ABIDataTypes["ARRAY_OF_UINT32"] = "ARRAY_OF_UINT32";
     ABIDataTypes["ARRAY_OF_UINT16"] = "ARRAY_OF_UINT16";
@@ -52,6 +54,9 @@ export class ABICoder {
                 case ABIDataTypes.STRING:
                     result.push(byteReader.readStringWithLength());
                     break;
+                case ABIDataTypes.UINT128:
+                    result.push(byteReader.readU128());
+                    break;
                 case ABIDataTypes.UINT256:
                     result.push(byteReader.readU256());
                     break;
@@ -73,6 +78,9 @@ export class ABICoder {
                 case ABIDataTypes.ARRAY_OF_UINT256:
                     result.push(byteReader.readU256Array());
                     break;
+                case ABIDataTypes.ARRAY_OF_UINT128:
+                    result.push(byteReader.readU128Array());
+                    break;
                 case ABIDataTypes.ARRAY_OF_UINT64:
                     result.push(byteReader.readU64Array());
                     break;
@@ -94,27 +102,6 @@ export class ABICoder {
         }
         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);

package/build/buffer/BinaryReader.d.ts

@@ -11,6 +11,7 @@ export declare class BinaryReader {
     setBuffer(bytes: BufferLike): void;
     readAddressArray(): Address[];
     readU256Array(): bigint[];
+    readU128Array(): bigint[];
     readU64Array(): bigint[];
     readU32Array(): u32[];
     readU16Array(): u16[];
@@ -24,6 +25,7 @@ export declare class BinaryReader {
     readU32(le?: boolean): u32;
     readU64(): bigint;
     readAddressValueTuple(): AddressMap<bigint>;
+    readU128(): bigint;
     readU256(): bigint;
     readBytes(length: u32, zeroStop?: boolean): Uint8Array;
     readString(length: u16): string;

package/build/buffer/BinaryReader.js

@@ -43,6 +43,14 @@ export class BinaryReader {
         }
         return result;
     }
+    readU128Array() {
+        const length = this.readU16();
+        const result = new Array(length);
+        for (let i = 0; i < length; i++) {
+            result[i] = this.readU128();
+        }
+        return result;
+    }
     readU64Array() {
         const length = this.readU16();
         const result = new Array(length);
@@ -140,6 +148,10 @@ export class BinaryReader {
         }
         return result;
     }
+    readU128() {
+        const next16Bytes = this.readBytes(16);
+        return BigInt('0x' + next16Bytes.reduce((acc, byte) => acc + byte.toString(16).padStart(2, '0'), ''));
+    }
     readU256() {
         const next32Bytes = this.readBytes(32);
         return BigInt('0x' + next32Bytes.reduce((acc, byte) => acc + byte.toString(16).padStart(2, '0'), ''));

package/build/buffer/BinaryWriter.d.ts

@@ -13,6 +13,7 @@ export declare class BinaryWriter {
     writeSelector(value: Selector): void;
     writeBoolean(value: boolean): void;
     writeU256(bigIntValue: bigint): void;
+    writeU128(bigIntValue: bigint): void;
     writeBytes(value: Uint8Array | Buffer): void;
     writeString(value: string): void;
     writeAddress(value: Address): void;
@@ -32,6 +33,7 @@ export declare class BinaryWriter {
     writeAddressArray(value: Address[]): void;
     writeU32Array(value: u32[]): void;
     writeU256Array(value: bigint[]): void;
+    writeU128Array(value: bigint[]): void;
     writeStringArray(value: string[]): void;
     writeU16Array(value: u16[]): void;
     writeU8Array(value: u8[]): void;

package/build/buffer/BinaryWriter.js

@@ -53,6 +53,19 @@ export class BinaryWriter {
             this.writeU8(bytesToHex[i]);
         }
     }
+    writeU128(bigIntValue) {
+        if (bigIntValue > 340282366920938463463374607431768211455n) {
+            throw new Error('Value is too large.');
+        }
+        this.allocSafe(16);
+        const bytesToHex = BufferHelper.valueToUint8Array(bigIntValue);
+        if (bytesToHex.byteLength !== 16) {
+            throw new Error(`Invalid u128 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++) {
@@ -177,6 +190,14 @@ export class BinaryWriter {
             this.writeU256(value[i]);
         }
     }
+    writeU128Array(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.writeU128(value[i]);
+        }
+    }
     writeStringArray(value) {
         if (value.length > 65535)
             throw new Error('Array size is too large');

package/package.json

@@ -1,7 +1,7 @@
 {
     "name": "@btc-vision/transaction",
     "type": "module",
-    "version": "1.1.5",
+    "version": "1.1.7",
     "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.1.5';
+export const version = '1.1.7';

package/src/abi/ABICoder.ts

@@ -8,16 +8,18 @@ export enum ABIDataTypes {
     UINT16 = 'UINT16',
     UINT32 = 'UINT32',
     UINT64 = 'UINT64',
+    UINT128 = 'UINT128',
+    UINT256 = 'UINT256',
     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_UINT128 = 'ARRAY_OF_UINT128',
     ARRAY_OF_UINT64 = 'ARRAY_OF_UINT64',
     ARRAY_OF_UINT32 = 'ARRAY_OF_UINT32',
     ARRAY_OF_UINT16 = 'ARRAY_OF_UINT16',
@@ -55,6 +57,9 @@ export class ABICoder {
                 case ABIDataTypes.STRING:
                     result.push(byteReader.readStringWithLength());
                     break;
+                case ABIDataTypes.UINT128:
+                    result.push(byteReader.readU128());
+                    break;
                 case ABIDataTypes.UINT256:
                     result.push(byteReader.readU256());
                     break;
@@ -76,6 +81,9 @@ export class ABICoder {
                 case ABIDataTypes.ARRAY_OF_UINT256:
                     result.push(byteReader.readU256Array());
                     break;
+                case ABIDataTypes.ARRAY_OF_UINT128:
+                    result.push(byteReader.readU128Array());
+                    break;
                 case ABIDataTypes.ARRAY_OF_UINT64:
                     result.push(byteReader.readU64Array());
                     break;
@@ -99,36 +107,6 @@ export class ABICoder {
         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);

package/src/buffer/BinaryReader.ts

@@ -55,6 +55,17 @@ export class BinaryReader {
         return result;
     }
 
+    public readU128Array(): bigint[] {
+        const length = this.readU16();
+        const result: bigint[] = new Array<bigint>(length);
+
+        for (let i = 0; i < length; i++) {
+            result[i] = this.readU128();
+        }
+
+        return result;
+    }
+
     public readU64Array(): bigint[] {
         const length = this.readU16();
         const result: bigint[] = new Array<bigint>(length);
@@ -191,6 +202,14 @@ export class BinaryReader {
         return result;
     }
 
+    public readU128(): bigint {
+        const next16Bytes = this.readBytes(16);
+
+        return BigInt(
+            '0x' + next16Bytes.reduce((acc, byte) => acc + byte.toString(16).padStart(2, '0'), ''),
+        );
+    }
+
     public readU256(): bigint {
         const next32Bytes = this.readBytes(32);
 

package/src/buffer/BinaryWriter.ts

@@ -71,6 +71,23 @@ export class BinaryWriter {
         }
     }
 
+    public writeU128(bigIntValue: bigint): void {
+        if (bigIntValue > 340282366920938463463374607431768211455n) {
+            throw new Error('Value is too large.');
+        }
+
+        this.allocSafe(16);
+
+        const bytesToHex = BufferHelper.valueToUint8Array(bigIntValue);
+        if (bytesToHex.byteLength !== 16) {
+            throw new Error(`Invalid u128 value: ${bigIntValue}`);
+        }
+
+        for (let i = 0; i < bytesToHex.byteLength; i++) {
+            this.writeU8(bytesToHex[i]);
+        }
+    }
+
     public writeBytes(value: Uint8Array | Buffer): void {
         this.allocSafe(value.byteLength);
 
@@ -227,6 +244,16 @@ export class BinaryWriter {
         }
     }
 
+    public writeU128Array(value: bigint[]): void {
+        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.writeU128(value[i]);
+        }
+    }
+
     public writeStringArray(value: string[]): void {
         if (value.length > 65535) throw new Error('Array size is too large');
 

package/wbtc_disabled/Generate.ts.disabled

@@ -1,40 +0,0 @@
-import { VaultUTXOs } from '../src/transaction/processor/PsbtTransaction.js';
-
-export interface GenerationConstraints {
-    /** Timestamp of the generation */
-    readonly timestamp: number;
-
-    /** Protocol version used for generation */
-    readonly version: string;
-
-    /** Minimum different trusted validators */
-    readonly minimum: number;
-
-    /** Minimum different trusted validator in a new generated transaction */
-    readonly transactionMinimum: number;
-}
-
-export interface WrappedGenerationParameters {
-    /** Public trusted keys */
-    readonly keys: string[];
-
-    /** Vault address (p2ms) */
-    readonly vault: string;
-
-    /** Public trusted entities */
-    readonly entities: string[];
-
-    /** OPNet Signature that verify the trusted keys and entities */
-    readonly signature: string;
-
-    /** Generation constraints */
-    readonly constraints: GenerationConstraints;
-}
-
-export interface UnwrappedGenerationParameters {
-    /** UTXOs to unwrap from */
-    readonly vaultUTXOs: VaultUTXOs[];
-
-    /** WBTC balance */
-    readonly balance: string;
-}

package/wbtc_disabled/UnwrapGeneration.ts.disabled

@@ -1,13 +0,0 @@
-import { UnwrappedGenerationParameters } from './Generate.js';
-import { VaultUTXOs } from '../src/transaction/processor/PsbtTransaction.js';
-
-export class UnwrapGeneration implements Omit<UnwrappedGenerationParameters, 'balance'> {
-    public readonly vaultUTXOs: VaultUTXOs[];
-
-    public readonly balance: bigint;
-
-    constructor(params: UnwrappedGenerationParameters) {
-        this.vaultUTXOs = params.vaultUTXOs;
-        this.balance = BigInt(params.balance);
-    }
-}

package/wbtc_disabled/WrappedGenerationParameters.ts.disabled

@@ -1,33 +0,0 @@
-import { GenerationConstraints, WrappedGenerationParameters } from './Generate.js';
-
-export class WrappedGeneration implements WrappedGenerationParameters {
-    /** Generation constraints */
-    public readonly constraints: GenerationConstraints;
-
-    /** Public trusted entities */
-    public readonly entities: string[];
-
-    /** Public trusted keys */
-    public readonly keys: string[];
-
-    /** OPNet Signature that verify the trusted keys and entities */
-    public readonly signature: string;
-
-    /** Vault address (p2ms) */
-    public readonly vault: string;
-
-    /**
-     * Public keys of the trusted entities
-     */
-    public readonly pubKeys: Buffer[];
-
-    constructor(params: WrappedGenerationParameters) {
-        this.constraints = params.constraints;
-        this.entities = params.entities;
-        this.keys = params.keys;
-        this.signature = params.signature;
-        this.vault = params.vault;
-
-        this.pubKeys = this.keys.map((key: string) => Buffer.from(key, 'base64'));
-    }
-}