@btc-vision/transaction 1.6.8 → 1.6.10

package/build/_version.d.ts

@@ -1 +1 @@
-export declare const version = "1.6.8";
+export declare const version = "1.6.9";

package/build/_version.js

@@ -1 +1 @@
-export const version = '1.6.8';
+export const version = '1.6.9';

package/build/abi/ABICoder.d.ts

@@ -21,7 +21,8 @@ export declare enum ABIDataTypes {
     ARRAY_OF_UINT16 = "ARRAY_OF_UINT16",
     ARRAY_OF_UINT8 = "ARRAY_OF_UINT8",
     ARRAY_OF_STRING = "ARRAY_OF_STRING",
-    ARRAY_OF_BYTES = "ARRAY_OF_BYTES"
+    ARRAY_OF_BYTES = "ARRAY_OF_BYTES",
+    ARRAY_OF_BUFFERS = "ARRAY_OF_BUFFERS"
 }
 export declare class ABICoder {
     decodeData(data: Uint8Array, types: ABIDataTypes[]): unknown[];

package/build/abi/ABICoder.js

@@ -26,6 +26,7 @@ export var ABIDataTypes;
     ABIDataTypes["ARRAY_OF_UINT8"] = "ARRAY_OF_UINT8";
     ABIDataTypes["ARRAY_OF_STRING"] = "ARRAY_OF_STRING";
     ABIDataTypes["ARRAY_OF_BYTES"] = "ARRAY_OF_BYTES";
+    ABIDataTypes["ARRAY_OF_BUFFERS"] = "ARRAY_OF_BUFFERS";
 })(ABIDataTypes || (ABIDataTypes = {}));
 export class ABICoder {
     decodeData(data, types) {
@@ -102,6 +103,10 @@ export class ABICoder {
                     break;
                 case ABIDataTypes.ARRAY_OF_BYTES:
                     result.push(byteReader.readBytesArray());
+                    break;
+                case ABIDataTypes.ARRAY_OF_BUFFERS:
+                    result.push(byteReader.readArrayOfBuffer());
+                    break;
             }
         }
         return result;

package/build/buffer/BinaryReader.d.ts

@@ -25,6 +25,7 @@ export declare class BinaryReader {
     readStringWithLength(be?: boolean): string;
     readAddress(): Address;
     readBytesWithLength(maxLength?: number, be?: boolean): Uint8Array;
+    readArrayOfBuffer(be?: boolean): Uint8Array[];
     readAddressArray(be?: boolean): Address[];
     readU256Array(be?: boolean): bigint[];
     readU128Array(be?: boolean): bigint[];

package/build/buffer/BinaryReader.js

@@ -126,6 +126,14 @@ export class BinaryReader {
         }
         return this.readBytes(length);
     }
+    readArrayOfBuffer(be = true) {
+        const length = this.readU16(be);
+        const result = new Array(length);
+        for (let i = 0; i < length; i++) {
+            result[i] = this.readBytesWithLength();
+        }
+        return result;
+    }
     readAddressArray(be = true) {
         const length = this.readU16(be);
         const result = new Array(length);

package/build/buffer/BinaryWriter.d.ts

@@ -6,6 +6,7 @@ export declare class BinaryWriter {
     private currentOffset;
     private buffer;
     constructor(length?: number);
+    static estimateArrayOfBufferLength(values: Uint8Array[]): u32;
     writeU8(value: u8): void;
     writeU16(value: u16, be?: boolean): void;
     writeU32(value: u32, be?: boolean): void;
@@ -28,6 +29,7 @@ export declare class BinaryWriter {
     allocSafe(size: u32): void;
     writeAddressValueTuple(map: AddressMap<bigint>, be?: boolean): void;
     writeBytesWithLength(value: Uint8Array): void;
+    writeArrayOfBuffer(values: Uint8Array[], be?: boolean): void;
     writeAddressArray(value: Address[]): void;
     writeU32Array(value: u32[], be?: boolean): void;
     writeU256Array(value: bigint[], be?: boolean): void;

package/build/buffer/BinaryWriter.js

@@ -6,6 +6,15 @@ export class BinaryWriter {
         this.currentOffset = 0;
         this.buffer = this.getDefaultBuffer(length);
     }
+    static estimateArrayOfBufferLength(values) {
+        if (values.length > 65535)
+            throw new Error('Array size is too large');
+        let totalLength = U16_BYTE_LENGTH;
+        for (let i = 0; i < values.length; i++) {
+            totalLength += U32_BYTE_LENGTH + values[i].length;
+        }
+        return totalLength;
+    }
     writeU8(value) {
         if (value > 255)
             throw new Error('u8 value is too large.');
@@ -174,6 +183,15 @@ export class BinaryWriter {
         this.writeU32(value.length);
         this.writeBytes(value);
     }
+    writeArrayOfBuffer(values, be = true) {
+        const totalLength = BinaryWriter.estimateArrayOfBufferLength(values);
+        this.allocSafe(totalLength);
+        this.writeU16(values.length, be);
+        for (let i = 0; i < values.length; i++) {
+            this.writeU32(values[i].length, be);
+            this.writeBytes(values[i]);
+        }
+    }
     writeAddressArray(value) {
         if (value.length > 65535)
             throw new Error('Array size is too large');

package/build/transaction/TransactionFactory.js

@@ -7,7 +7,6 @@ import { InteractionTransaction } from './builders/InteractionTransaction.js';
 import { TransactionBuilder } from './builders/TransactionBuilder.js';
 import { P2WDADetector } from '../p2wda/P2WDADetector.js';
 import { InteractionTransactionP2WDA } from './builders/InteractionTransactionP2WDA.js';
-import { ChallengeSolution } from '../epoch/ChallengeSolution.js';
 import { Address } from '../keypair/Address.js';
 import { BitcoinUtils } from '../utils/BitcoinUtils.js';
 export class TransactionFactory {
@@ -423,10 +422,7 @@ export class TransactionFactory {
             finalPreTransaction = preTransaction;
             if ('getChallenge' in preTransaction &&
                 typeof preTransaction.getChallenge === 'function') {
-                const result = preTransaction.getChallenge();
-                if (result instanceof ChallengeSolution) {
-                    challenge = result;
-                }
+                challenge = preTransaction.getChallenge();
             }
             iterations++;
             if (this.debug) {

package/package.json

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

package/src/abi/ABICoder.ts

@@ -27,6 +27,7 @@ export enum ABIDataTypes {
     ARRAY_OF_UINT8 = 'ARRAY_OF_UINT8',
     ARRAY_OF_STRING = 'ARRAY_OF_STRING',
     ARRAY_OF_BYTES = 'ARRAY_OF_BYTES',
+    ARRAY_OF_BUFFERS = 'ARRAY_OF_BUFFERS',
 }
 
 export class ABICoder {
@@ -105,6 +106,10 @@ export class ABICoder {
                     break;
                 case ABIDataTypes.ARRAY_OF_BYTES:
                     result.push(byteReader.readBytesArray());
+                    break;
+                case ABIDataTypes.ARRAY_OF_BUFFERS:
+                    result.push(byteReader.readArrayOfBuffer());
+                    break;
             }
         }
 

package/src/buffer/BinaryReader.ts

@@ -220,6 +220,15 @@ export class BinaryReader {
 
     // ------------------ Array readers ------------------ //
 
+    public readArrayOfBuffer(be: boolean = true): Uint8Array[] {
+        const length = this.readU16(be);
+        const result: Uint8Array[] = new Array<Uint8Array>(length);
+        for (let i: number = 0; i < length; i++) {
+            result[i] = this.readBytesWithLength();
+        }
+        return result;
+    }
+
     public readAddressArray(be: boolean = true): Address[] {
         const length = this.readU16(be);
         const result: Address[] = new Array<Address>(length);

package/src/buffer/BinaryWriter.ts

@@ -22,6 +22,17 @@ export class BinaryWriter {
         this.buffer = this.getDefaultBuffer(length);
     }
 
+    public static estimateArrayOfBufferLength(values: Uint8Array[]): u32 {
+        if (values.length > 65535) throw new Error('Array size is too large');
+        let totalLength: u32 = U16_BYTE_LENGTH;
+
+        for (let i = 0; i < values.length; i++) {
+            totalLength += U32_BYTE_LENGTH + values[i].length; // each entry has a u32 length prefix
+        }
+
+        return totalLength;
+    }
+
     public writeU8(value: u8): void {
         if (value > 255) throw new Error('u8 value is too large.');
 
@@ -229,6 +240,18 @@ export class BinaryWriter {
         this.writeBytes(value);
     }
 
+    public writeArrayOfBuffer(values: Uint8Array[], be: boolean = true): void {
+        const totalLength = BinaryWriter.estimateArrayOfBufferLength(values);
+
+        this.allocSafe(totalLength);
+        this.writeU16(values.length, be);
+
+        for (let i = 0; i < values.length; i++) {
+            this.writeU32(values[i].length, be);
+            this.writeBytes(values[i]);
+        }
+    }
+
     public writeAddressArray(value: Address[]): void {
         if (value.length > 65535) throw new Error('Array size is too large');
 

package/src/transaction/TransactionFactory.ts

@@ -703,10 +703,7 @@ export class TransactionFactory {
                 'getChallenge' in preTransaction &&
                 typeof preTransaction.getChallenge === 'function'
             ) {
-                const result = preTransaction.getChallenge();
-                if (result instanceof ChallengeSolution) {
-                    challenge = result;
-                }
+                challenge = preTransaction.getChallenge();
             }
 
             iterations++;