@btc-vision/transaction 1.8.0-beta.0 → 1.8.0-beta.10

package/src/abi/ABICoder.ts

@@ -1,159 +1,17 @@
 import shajs from 'sha.js';
 
 import { BinaryReader } from '../buffer/BinaryReader.js';
-import { BufferHelper } from '../utils/BufferHelper.js';
-
-export enum ABIDataTypes {
-    // Unsigned integers
-    UINT8 = 'UINT8',
-    UINT16 = 'UINT16',
-    UINT32 = 'UINT32',
-    UINT64 = 'UINT64',
-    UINT128 = 'UINT128',
-    UINT256 = 'UINT256',
-
-    // Signed integers
-    INT8 = 'INT8',
-    INT16 = 'INT16',
-    INT32 = 'INT32',
-    INT64 = 'INT64',
-    INT128 = 'INT128',
-
-    // Basic types
-    BOOL = 'BOOL',
-    ADDRESS = 'ADDRESS',
-    EXTENDED_ADDRESS = 'EXTENDED_ADDRESS',
-    STRING = 'STRING',
-    BYTES4 = 'BYTES4',
-    BYTES32 = 'BYTES32',
-    BYTES = 'BYTES',
-
-    // Tuples/Maps
-    ADDRESS_UINT256_TUPLE = 'ADDRESS_UINT256_TUPLE',
-    EXTENDED_ADDRESS_UINT256_TUPLE = 'EXTENDED_ADDRESS_UINT256_TUPLE',
-
-    // Signatures
-    SCHNORR_SIGNATURE = 'SCHNORR_SIGNATURE',
-
-    // Arrays
-    ARRAY_OF_ADDRESSES = 'ARRAY_OF_ADDRESSES',
-    ARRAY_OF_EXTENDED_ADDRESSES = 'ARRAY_OF_EXTENDED_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',
-    ARRAY_OF_UINT8 = 'ARRAY_OF_UINT8',
-    ARRAY_OF_STRING = 'ARRAY_OF_STRING',
-    ARRAY_OF_BYTES = 'ARRAY_OF_BYTES',
-    ARRAY_OF_BUFFERS = 'ARRAY_OF_BUFFERS',
-}
+import { ABIDataTypes } from './ABIDataTypes.js';
+import type { AbiType } from './AbiTypes.js';
+import { isAbiStruct, isAbiTuple } from './TupleUtils.js';
 
 export class ABICoder {
-    public decodeData(data: Uint8Array, types: ABIDataTypes[]): unknown[] {
+    public decodeData(data: Uint8Array, types: AbiType[]): unknown[] {
         const byteReader = new BinaryReader(data);
         const result: unknown[] = [];
 
-        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.BYTES4:
-                    result.push(byteReader.readBytes(4));
-                    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.UINT128:
-                    result.push(byteReader.readU128());
-                    break;
-                case ABIDataTypes.UINT256:
-                    result.push(byteReader.readU256());
-                    break;
-                case ABIDataTypes.INT8:
-                    result.push(byteReader.readI8());
-                    break;
-                case ABIDataTypes.INT16:
-                    result.push(byteReader.readI16());
-                    break;
-                case ABIDataTypes.INT32:
-                    result.push(byteReader.readI32());
-                    break;
-                case ABIDataTypes.INT64:
-                    result.push(byteReader.readI64());
-                    break;
-                case ABIDataTypes.INT128:
-                    result.push(byteReader.readI128());
-                    break;
-                case ABIDataTypes.EXTENDED_ADDRESS:
-                    result.push(byteReader.readExtendedAddress());
-                    break;
-                case ABIDataTypes.ADDRESS_UINT256_TUPLE:
-                    result.push(byteReader.readAddressValueTuple());
-                    break;
-                case ABIDataTypes.EXTENDED_ADDRESS_UINT256_TUPLE:
-                    result.push(byteReader.readExtendedAddressMapU256());
-                    break;
-                case ABIDataTypes.SCHNORR_SIGNATURE:
-                    result.push(byteReader.readSchnorrSignature());
-                    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_EXTENDED_ADDRESSES:
-                    result.push(byteReader.readExtendedAddressArray());
-                    break;
-                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;
-                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());
-                    break;
-                case ABIDataTypes.ARRAY_OF_BUFFERS:
-                    result.push(byteReader.readArrayOfBuffer());
-                    break;
-            }
+        for (const type of types) {
+            result.push(this.decodeSingleValue(byteReader, type));
         }
 
         return result;
@@ -171,15 +29,134 @@ export class ABICoder {
         return selector.toString(16);
     }
 
-    private bigIntToUint8Array(bigIntValue: bigint, length: number): Uint8Array {
-        const byteArray = new Uint8Array(length);
-        const buf = BufferHelper.valueToUint8Array(bigIntValue);
+    /**
+     * Decodes a single value from the reader based on the ABI type.
+     * Supports ABIDataTypes enum values, tuple arrays, and struct objects.
+     */
+    public decodeSingleValue(reader: BinaryReader, type: AbiType): unknown {
+        if (isAbiTuple(type)) {
+            // Single-element tuple: unwrap to flat array
+            const firstType = type[0];
+            if (type.length === 1 && firstType !== undefined) {
+                return this.decodeArray(reader, firstType);
+            }
+            return this.decodeTuple(reader, type);
+        }
+
+        if (isAbiStruct(type)) {
+            return this.decodeStruct(reader, type);
+        }
+
+        switch (type) {
+            case ABIDataTypes.UINT8:
+                return reader.readU8();
+            case ABIDataTypes.UINT16:
+                return reader.readU16();
+            case ABIDataTypes.UINT32:
+                return reader.readU32();
+            case ABIDataTypes.BYTES4:
+                return reader.readBytes(4);
+            case ABIDataTypes.BYTES32:
+                return reader.readBytes(32);
+            case ABIDataTypes.BOOL:
+                return reader.readBoolean();
+            case ABIDataTypes.ADDRESS:
+                return reader.readAddress();
+            case ABIDataTypes.STRING:
+                return reader.readStringWithLength();
+            case ABIDataTypes.UINT128:
+                return reader.readU128();
+            case ABIDataTypes.UINT256:
+                return reader.readU256();
+            case ABIDataTypes.INT8:
+                return reader.readI8();
+            case ABIDataTypes.INT16:
+                return reader.readI16();
+            case ABIDataTypes.INT32:
+                return reader.readI32();
+            case ABIDataTypes.INT64:
+                return reader.readI64();
+            case ABIDataTypes.INT128:
+                return reader.readI128();
+            case ABIDataTypes.EXTENDED_ADDRESS:
+                return reader.readExtendedAddress();
+            case ABIDataTypes.ADDRESS_UINT256_TUPLE:
+                return reader.readAddressValueTuple();
+            case ABIDataTypes.EXTENDED_ADDRESS_UINT256_TUPLE:
+                return reader.readExtendedAddressMapU256();
+            case ABIDataTypes.SCHNORR_SIGNATURE:
+                return reader.readSchnorrSignature();
+            case ABIDataTypes.BYTES:
+                return reader.readBytesWithLength();
+            case ABIDataTypes.UINT64:
+                return reader.readU64();
+            case ABIDataTypes.ARRAY_OF_ADDRESSES:
+                return reader.readAddressArray();
+            case ABIDataTypes.ARRAY_OF_EXTENDED_ADDRESSES:
+                return reader.readExtendedAddressArray();
+            case ABIDataTypes.ARRAY_OF_UINT256:
+                return reader.readU256Array();
+            case ABIDataTypes.ARRAY_OF_UINT128:
+                return reader.readU128Array();
+            case ABIDataTypes.ARRAY_OF_UINT64:
+                return reader.readU64Array();
+            case ABIDataTypes.ARRAY_OF_UINT32:
+                return reader.readU32Array();
+            case ABIDataTypes.ARRAY_OF_UINT16:
+                return reader.readU16Array();
+            case ABIDataTypes.ARRAY_OF_UINT8:
+                return reader.readU8Array();
+            case ABIDataTypes.ARRAY_OF_STRING:
+                return reader.readStringArray();
+            case ABIDataTypes.ARRAY_OF_BYTES:
+                return reader.readBytesArray();
+            case ABIDataTypes.ARRAY_OF_BUFFERS:
+                return reader.readArrayOfBuffer();
+            default:
+                throw new Error(`Unsupported ABI type: ${type}`);
+        }
+    }
+
+    /** Decodes a single-element tuple as a flat typed array (u16 count + values). */
+    private decodeArray(reader: BinaryReader, elementType: AbiType): unknown[] {
+        const count = reader.readU16();
+        const result: unknown[] = [];
+
+        for (let i = 0; i < count; i++) {
+            result.push(this.decodeSingleValue(reader, elementType));
+        }
+
+        return result;
+    }
+
+    /** Decodes a multi-element tuple as array of tuple entries (u16 count + entries). */
+    private decodeTuple(reader: BinaryReader, types: AbiType[]): unknown[][] {
+        const count = reader.readU16();
+        const result: unknown[][] = [];
+
+        for (let i = 0; i < count; i++) {
+            const entry: unknown[] = [];
+            for (const fieldType of types) {
+                entry.push(this.decodeSingleValue(reader, fieldType));
+            }
+            result.push(entry);
+        }
+
+        return result;
+    }
+
+    /** Decodes a struct as a single object with named fields (inline, no count prefix). */
+    private decodeStruct(
+        reader: BinaryReader,
+        struct: { [field: string]: AbiType },
+    ): Record<string, unknown> {
+        const entry: Record<string, unknown> = {};
 
-        for (let i = 0; i < length; i++) {
-            byteArray[i] = buf[i] || 0;
+        for (const [name, fieldType] of Object.entries(struct)) {
+            entry[name] = this.decodeSingleValue(reader, fieldType);
         }
 
-        return byteArray;
+        return entry;
     }
 
     private sha256(buffer: Buffer | string | Uint8Array): Buffer {

package/src/abi/ABIDataTypes.ts

@@ -0,0 +1,45 @@
+export enum ABIDataTypes {
+    // Unsigned integers
+    UINT8 = 'UINT8',
+    UINT16 = 'UINT16',
+    UINT32 = 'UINT32',
+    UINT64 = 'UINT64',
+    UINT128 = 'UINT128',
+    UINT256 = 'UINT256',
+
+    // Signed integers
+    INT8 = 'INT8',
+    INT16 = 'INT16',
+    INT32 = 'INT32',
+    INT64 = 'INT64',
+    INT128 = 'INT128',
+
+    // Basic types
+    BOOL = 'BOOL',
+    ADDRESS = 'ADDRESS',
+    EXTENDED_ADDRESS = 'EXTENDED_ADDRESS',
+    STRING = 'STRING',
+    BYTES4 = 'BYTES4',
+    BYTES32 = 'BYTES32',
+    BYTES = 'BYTES',
+
+    // Tuples/Maps
+    ADDRESS_UINT256_TUPLE = 'ADDRESS_UINT256_TUPLE',
+    EXTENDED_ADDRESS_UINT256_TUPLE = 'EXTENDED_ADDRESS_UINT256_TUPLE',
+
+    // Signatures
+    SCHNORR_SIGNATURE = 'SCHNORR_SIGNATURE',
+
+    // Arrays
+    ARRAY_OF_ADDRESSES = 'ARRAY_OF_ADDRESSES',
+    ARRAY_OF_EXTENDED_ADDRESSES = 'ARRAY_OF_EXTENDED_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',
+    ARRAY_OF_UINT8 = 'ARRAY_OF_UINT8',
+    ARRAY_OF_STRING = 'ARRAY_OF_STRING',
+    ARRAY_OF_BYTES = 'ARRAY_OF_BYTES',
+    ARRAY_OF_BUFFERS = 'ARRAY_OF_BUFFERS',
+}

package/src/abi/AbiTypes.ts

@@ -0,0 +1,183 @@
+import type { Address } from '../keypair/Address.js';
+import type { AddressMap } from '../deterministic/AddressMap.js';
+import type { ExtendedAddressMap } from '../deterministic/ExtendedAddressMap.js';
+import type { SchnorrSignature } from '../buffer/BinaryReader.js';
+import { ABIDataTypes } from './ABIDataTypes.js';
+
+/**
+ * Recursive ABI type definition:
+ * - Simple: ABIDataTypes enum value (e.g. ABIDataTypes.ADDRESS)
+ * - Tuple: ordered array of AbiType (e.g. [ABIDataTypes.ADDRESS, ABIDataTypes.UINT8])
+ * - Struct: named fields mapping to AbiType (e.g. { field1: ABIDataTypes.ADDRESS, field2: ABIDataTypes.UINT256 })
+ * - Nested: any combination (e.g. [ABIDataTypes.ADDRESS, { inner: ABIDataTypes.UINT8 }])
+ */
+export type AbiType = ABIDataTypes | AbiType[] | { [field: string]: AbiType };
+
+/**
+ * Maps an AbiType to its corresponding TypeScript type at the type level.
+ *
+ * Usage with `as const`:
+ * ```ts
+ * const abi = { name: 'balance', type: ABIDataTypes.UINT256 } as const;
+ * type Result = InferAbiType<typeof abi.type>; // bigint
+ *
+ * const structAbi = { name: 'status', type: { minted: ABIDataTypes.UINT256, active: ABIDataTypes.BOOL } } as const;
+ * type StatusResult = InferAbiType<typeof structAbi.type>; // { minted: bigint; active: boolean }
+ * ```
+ */
+export type InferAbiType<T extends AbiType> =
+    // Small integers → number
+    T extends
+        | ABIDataTypes.UINT8
+        | ABIDataTypes.UINT16
+        | ABIDataTypes.UINT32
+        | ABIDataTypes.INT8
+        | ABIDataTypes.INT16
+        | ABIDataTypes.INT32
+        ? number
+        : // Large integers → bigint
+          T extends
+                | ABIDataTypes.UINT64
+                | ABIDataTypes.UINT128
+                | ABIDataTypes.UINT256
+                | ABIDataTypes.INT64
+                | ABIDataTypes.INT128
+            ? bigint
+            : T extends ABIDataTypes.BOOL
+              ? boolean
+              : T extends ABIDataTypes.STRING
+                ? string
+                : T extends ABIDataTypes.ADDRESS | ABIDataTypes.EXTENDED_ADDRESS
+                  ? Address
+                  : T extends ABIDataTypes.BYTES | ABIDataTypes.BYTES4 | ABIDataTypes.BYTES32
+                    ? Uint8Array
+                    : T extends ABIDataTypes.SCHNORR_SIGNATURE
+                      ? SchnorrSignature
+                      : T extends ABIDataTypes.ADDRESS_UINT256_TUPLE
+                        ? AddressMap<bigint>
+                        : T extends ABIDataTypes.EXTENDED_ADDRESS_UINT256_TUPLE
+                          ? ExtendedAddressMap<bigint>
+                          : // Built-in array types
+                            T extends
+                                  | ABIDataTypes.ARRAY_OF_ADDRESSES
+                                  | ABIDataTypes.ARRAY_OF_EXTENDED_ADDRESSES
+                              ? Address[]
+                              : T extends
+                                      | ABIDataTypes.ARRAY_OF_UINT256
+                                      | ABIDataTypes.ARRAY_OF_UINT128
+                                      | ABIDataTypes.ARRAY_OF_UINT64
+                                  ? bigint[]
+                                  : T extends
+                                          | ABIDataTypes.ARRAY_OF_UINT32
+                                          | ABIDataTypes.ARRAY_OF_UINT16
+                                          | ABIDataTypes.ARRAY_OF_UINT8
+                                      ? number[]
+                                      : T extends ABIDataTypes.ARRAY_OF_STRING
+                                        ? string[]
+                                        : T extends
+                                                | ABIDataTypes.ARRAY_OF_BYTES
+                                                | ABIDataTypes.ARRAY_OF_BUFFERS
+                                            ? Uint8Array[]
+                                            : // Struct: single object with mapped fields (no array wrapper)
+                                              T extends Record<string, AbiType>
+                                              ? {
+                                                    [K in keyof T]: T[K] extends AbiType
+                                                        ? InferAbiType<T[K]>
+                                                        : never;
+                                                }
+                                              : // Single-element tuple: unwrap to typed array
+                                                T extends readonly [infer Single extends AbiType]
+                                                ? InferAbiType<Single>[]
+                                                : // Multi-element tuple: array of mapped tuples
+                                                  T extends readonly [
+                                                        AbiType,
+                                                        AbiType,
+                                                        ...AbiType[],
+                                                    ]
+                                                    ? {
+                                                          [K in keyof T]: T[K] extends AbiType
+                                                              ? InferAbiType<T[K]>
+                                                              : T[K];
+                                                      }[]
+                                                    : // Generic array fallback
+                                                      T extends readonly AbiType[]
+                                                      ? unknown[]
+                                                      : never;
+
+/**
+ * Canonical string → ABIDataTypes mapping.
+ * Only includes canonical ABI-style names (not AssemblyScript aliases).
+ */
+export const StrToAbiType: { [key: string]: ABIDataTypes } = {
+    address: ABIDataTypes.ADDRESS,
+    extendedAddress: ABIDataTypes.EXTENDED_ADDRESS,
+    bool: ABIDataTypes.BOOL,
+    bytes: ABIDataTypes.BYTES,
+    uint256: ABIDataTypes.UINT256,
+    uint128: ABIDataTypes.UINT128,
+    uint64: ABIDataTypes.UINT64,
+    uint32: ABIDataTypes.UINT32,
+    uint16: ABIDataTypes.UINT16,
+    uint8: ABIDataTypes.UINT8,
+    int128: ABIDataTypes.INT128,
+    int64: ABIDataTypes.INT64,
+    int32: ABIDataTypes.INT32,
+    int16: ABIDataTypes.INT16,
+    int8: ABIDataTypes.INT8,
+    string: ABIDataTypes.STRING,
+    bytes4: ABIDataTypes.BYTES4,
+    bytes32: ABIDataTypes.BYTES32,
+    schnorrSignature: ABIDataTypes.SCHNORR_SIGNATURE,
+    'tuple(address,uint256)[]': ABIDataTypes.ADDRESS_UINT256_TUPLE,
+    'tuple(extendedAddress,uint256)[]': ABIDataTypes.EXTENDED_ADDRESS_UINT256_TUPLE,
+    'address[]': ABIDataTypes.ARRAY_OF_ADDRESSES,
+    'extendedAddress[]': ABIDataTypes.ARRAY_OF_EXTENDED_ADDRESSES,
+    'uint256[]': ABIDataTypes.ARRAY_OF_UINT256,
+    'uint128[]': ABIDataTypes.ARRAY_OF_UINT128,
+    'uint64[]': ABIDataTypes.ARRAY_OF_UINT64,
+    'uint32[]': ABIDataTypes.ARRAY_OF_UINT32,
+    'uint16[]': ABIDataTypes.ARRAY_OF_UINT16,
+    'uint8[]': ABIDataTypes.ARRAY_OF_UINT8,
+    'bytes[]': ABIDataTypes.ARRAY_OF_BYTES,
+    'buffer[]': ABIDataTypes.ARRAY_OF_BUFFERS,
+    'string[]': ABIDataTypes.ARRAY_OF_STRING,
+    boolean: ABIDataTypes.BOOL,
+};
+
+/**
+ * Canonical reverse mapping: ABIDataTypes → canonical string.
+ */
+export const AbiTypeToStr: { [key in ABIDataTypes]: string } = {
+    [ABIDataTypes.ADDRESS]: 'address',
+    [ABIDataTypes.EXTENDED_ADDRESS]: 'extendedAddress',
+    [ABIDataTypes.BOOL]: 'bool',
+    [ABIDataTypes.BYTES]: 'bytes',
+    [ABIDataTypes.BYTES32]: 'bytes32',
+    [ABIDataTypes.BYTES4]: 'bytes4',
+    [ABIDataTypes.UINT256]: 'uint256',
+    [ABIDataTypes.UINT128]: 'uint128',
+    [ABIDataTypes.UINT64]: 'uint64',
+    [ABIDataTypes.UINT32]: 'uint32',
+    [ABIDataTypes.UINT16]: 'uint16',
+    [ABIDataTypes.UINT8]: 'uint8',
+    [ABIDataTypes.INT128]: 'int128',
+    [ABIDataTypes.INT64]: 'int64',
+    [ABIDataTypes.INT32]: 'int32',
+    [ABIDataTypes.INT16]: 'int16',
+    [ABIDataTypes.INT8]: 'int8',
+    [ABIDataTypes.STRING]: 'string',
+    [ABIDataTypes.ADDRESS_UINT256_TUPLE]: 'tuple(address,uint256)[]',
+    [ABIDataTypes.EXTENDED_ADDRESS_UINT256_TUPLE]: 'tuple(extendedAddress,uint256)[]',
+    [ABIDataTypes.SCHNORR_SIGNATURE]: 'schnorrSignature',
+    [ABIDataTypes.ARRAY_OF_ADDRESSES]: 'address[]',
+    [ABIDataTypes.ARRAY_OF_EXTENDED_ADDRESSES]: 'extendedAddress[]',
+    [ABIDataTypes.ARRAY_OF_UINT256]: 'uint256[]',
+    [ABIDataTypes.ARRAY_OF_UINT128]: 'uint128[]',
+    [ABIDataTypes.ARRAY_OF_UINT64]: 'uint64[]',
+    [ABIDataTypes.ARRAY_OF_UINT32]: 'uint32[]',
+    [ABIDataTypes.ARRAY_OF_UINT16]: 'uint16[]',
+    [ABIDataTypes.ARRAY_OF_UINT8]: 'uint8[]',
+    [ABIDataTypes.ARRAY_OF_BYTES]: 'bytes[]',
+    [ABIDataTypes.ARRAY_OF_STRING]: 'string[]',
+    [ABIDataTypes.ARRAY_OF_BUFFERS]: 'buffer[]',
+};

package/src/abi/TupleUtils.ts

@@ -0,0 +1,57 @@
+import { ABIDataTypes } from './ABIDataTypes.js';
+import type { AbiType } from './AbiTypes.js';
+import { AbiTypeToStr } from './AbiTypes.js';
+
+/**
+ * Type guard: returns true if the ABI type is a tuple (ordered array of types).
+ */
+export function isAbiTuple(type: AbiType): type is AbiType[] {
+    return Array.isArray(type);
+}
+
+/**
+ * Type guard: returns true if the ABI type is a struct (named fields).
+ */
+export function isAbiStruct(type: AbiType): type is { [field: string]: AbiType } {
+    return typeof type === 'object' && type !== null && !Array.isArray(type);
+}
+
+/**
+ * Type guard: returns true if the ABI type is a simple ABIDataTypes enum value.
+ */
+export function isSimpleAbiType(type: AbiType): type is ABIDataTypes {
+    return typeof type === 'string';
+}
+
+/**
+ * Converts a structured AbiType into a canonical selector string.
+ * - Simple: ABIDataTypes.ADDRESS → "address"
+ * - Struct: { a: ADDRESS, b: UINT256 } → "tuple(address,uint256)" (inline, no [])
+ * - Single-element tuple: [UINT256] → "uint256[]"
+ * - Multi-element tuple: [ADDRESS, UINT256] → "tuple(address,uint256)[]"
+ */
+export function abiTypeToSelectorString(type: AbiType): string {
+    if (isSimpleAbiType(type)) {
+        const str = AbiTypeToStr[type];
+        if (!str) {
+            throw new Error(`Unknown ABI type: ${type}`);
+        }
+        return str;
+    }
+
+    // Struct: inline tuple (no [] suffix)
+    if (isAbiStruct(type)) {
+        const inner = Object.values(type).map((t) => abiTypeToSelectorString(t)).join(',');
+        return `tuple(${inner})`;
+    }
+
+    // Single-element tuple: unwrap to "type[]"
+    const firstType = type[0];
+    if (type.length === 1 && firstType !== undefined) {
+        return `${abiTypeToSelectorString(firstType)}[]`;
+    }
+
+    // Multi-element tuple: "tuple(types...)[]"
+    const inner = type.map((t) => abiTypeToSelectorString(t)).join(',');
+    return `tuple(${inner})[]`;
+}

package/src/branded/Branded.ts

@@ -0,0 +1,5 @@
+import type { Brand } from '@btc-vision/ecpair';
+
+export type MLDSAHashedPublicKey = Brand<Uint8Array, 'MLDSAHashedPublicKey'>;
+
+export type HybridPublicKey = Brand<Uint8Array, 'HybridPublicKey'>;

package/src/buffer/BinaryReader.ts

@@ -17,7 +17,7 @@ import {
     U64_BYTE_LENGTH,
     U8_BYTE_LENGTH,
 } from '../utils/lengths.js';
-import { BufferLike, i16, i32, i64, i8, Selector, u16, u32, u8 } from '../utils/types.js';
+import type { BufferLike, i16, i32, i64, i8, Selector, u16, u32, u8 } from '../utils/types.js';
 
 /**
  * Represents a Schnorr signature paired with the signer's Address.
@@ -40,6 +40,10 @@ export class BinaryReader {
         this.buffer = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
     }
 
+    public get byteLength(): number {
+        return this.buffer.byteLength;
+    }
+
     // Helpers for comparisons; unchanged
     public static stringCompare(a: string, b: string): number {
         return a.localeCompare(b);
@@ -62,10 +66,6 @@ export class BinaryReader {
         this.currentOffset = 0;
     }
 
-    public get byteLength(): number {
-        return this.buffer.byteLength;
-    }
-
     public length(): number {
         return this.buffer.byteLength;
     }
@@ -207,7 +207,7 @@ export class BinaryReader {
 
         // If the top bit is set (sign bit in big-endian), interpret negative
         const signBitMask = 0x80;
-        if (bytes[0] & signBitMask) {
+        if ((bytes[0] as number) & signBitMask) {
             // (1 << 128)
             const twoTo128 = BigInt(1) << BigInt(128);
             // 2's complement
@@ -512,7 +512,7 @@ export class BinaryReader {
     private reverseBytes(bytes: Uint8Array): Uint8Array {
         const out = new Uint8Array(bytes.length);
         for (let i = 0; i < bytes.length; i++) {
-            out[i] = bytes[bytes.length - 1 - i];
+            out[i] = bytes[bytes.length - 1 - i] as number;
         }
         return out;
     }