@beclab/olaresid 0.1.1 → 0.1.3

package/dist/utils/olares-id.d.ts

@@ -0,0 +1,36 @@
+/**
+ * Olares ID Utilities
+ *
+ * Olares ID is a new format that looks like email addresses: user@domain.com
+ * It's essentially a domain name where the first dot (.) is replaced with an at sign (@)
+ *
+ * Examples:
+ *   - alice.example.com → alice@example.com (Olares ID)
+ *   - bob.sub.example.com → bob@sub.example.com (Olares ID)
+ */
+/**
+ * Convert Olares ID format to standard domain format
+ * Replaces the first @ with a dot (.)
+ *
+ * @param input The input string (can be either Olares ID or domain format)
+ * @returns The normalized domain format
+ *
+ * @example
+ * normalizeToDomain('alice@example.com') // returns 'alice.example.com'
+ * normalizeToDomain('alice.example.com') // returns 'alice.example.com' (no change)
+ * normalizeToDomain('bob@sub.example.com') // returns 'bob.sub.example.com'
+ */
+export declare function normalizeToDomain(input: string): string;
+/**
+ * Convert standard domain format to Olares ID format
+ * Replaces the first dot (.) with an at sign (@)
+ *
+ * @param domain The domain name
+ * @returns The Olares ID format
+ *
+ * @example
+ * normalizeToOlaresId('alice.example.com') // returns 'alice@example.com'
+ * normalizeToOlaresId('bob.sub.example.com') // returns 'bob@sub.example.com'
+ */
+export declare function normalizeToOlaresId(domain: string): string;
+//# sourceMappingURL=olares-id.d.ts.map

package/dist/utils/olares-id.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"olares-id.d.ts","sourceRoot":"","sources":["../../src/utils/olares-id.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH;;;;;;;;;;;GAWG;AACH,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAMvD;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,mBAAmB,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAM1D"}

package/dist/utils/olares-id.js

@@ -0,0 +1,52 @@
+"use strict";
+/**
+ * Olares ID Utilities
+ *
+ * Olares ID is a new format that looks like email addresses: user@domain.com
+ * It's essentially a domain name where the first dot (.) is replaced with an at sign (@)
+ *
+ * Examples:
+ *   - alice.example.com → alice@example.com (Olares ID)
+ *   - bob.sub.example.com → bob@sub.example.com (Olares ID)
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.normalizeToDomain = normalizeToDomain;
+exports.normalizeToOlaresId = normalizeToOlaresId;
+/**
+ * Convert Olares ID format to standard domain format
+ * Replaces the first @ with a dot (.)
+ *
+ * @param input The input string (can be either Olares ID or domain format)
+ * @returns The normalized domain format
+ *
+ * @example
+ * normalizeToDomain('alice@example.com') // returns 'alice.example.com'
+ * normalizeToDomain('alice.example.com') // returns 'alice.example.com' (no change)
+ * normalizeToDomain('bob@sub.example.com') // returns 'bob.sub.example.com'
+ */
+function normalizeToDomain(input) {
+    if (!input) {
+        return input;
+    }
+    // Replace the first @ with a dot
+    return input.replace('@', '.');
+}
+/**
+ * Convert standard domain format to Olares ID format
+ * Replaces the first dot (.) with an at sign (@)
+ *
+ * @param domain The domain name
+ * @returns The Olares ID format
+ *
+ * @example
+ * normalizeToOlaresId('alice.example.com') // returns 'alice@example.com'
+ * normalizeToOlaresId('bob.sub.example.com') // returns 'bob@sub.example.com'
+ */
+function normalizeToOlaresId(domain) {
+    if (!domain) {
+        return domain;
+    }
+    // Replace the first dot with @
+    return domain.replace('.', '@');
+}
+//# sourceMappingURL=olares-id.js.map

package/dist/utils/olares-id.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"olares-id.js","sourceRoot":"","sources":["../../src/utils/olares-id.ts"],"names":[],"mappings":";AAAA;;;;;;;;;GASG;;AAcH,8CAMC;AAaD,kDAMC;AArCD;;;;;;;;;;;GAWG;AACH,SAAgB,iBAAiB,CAAC,KAAa;IAC9C,IAAI,CAAC,KAAK,EAAE,CAAC;QACZ,OAAO,KAAK,CAAC;IACd,CAAC;IACD,iCAAiC;IACjC,OAAO,KAAK,CAAC,OAAO,CAAC,GAAG,EAAE,GAAG,CAAC,CAAC;AAChC,CAAC;AAED;;;;;;;;;;GAUG;AACH,SAAgB,mBAAmB,CAAC,MAAc;IACjD,IAAI,CAAC,MAAM,EAAE,CAAC;QACb,OAAO,MAAM,CAAC;IACf,CAAC;IACD,+BAA+B;IAC/B,OAAO,MAAM,CAAC,OAAO,CAAC,GAAG,EAAE,GAAG,CAAC,CAAC;AACjC,CAAC"}

package/dist/utils/tag-abi-codec.d.ts

@@ -0,0 +1,69 @@
+/**
+ * Tag ABI Codec
+ * Unified encoding/decoding utility for Tag values
+ *
+ * Key Principle: ALL values use abi.encode()
+ * - Simple values: abi.encode("value")
+ * - Arrays: abi.encode(["a", "b", "c"])
+ * - Tuples: abi.encode(struct)
+ * - Elements for push: abi.encode(singleElement)
+ */
+export declare class TagAbiCodec {
+    private static abiCoder;
+    /**
+     * Parse tuple field types from ABI type string
+     * @param abiType e.g., "tuple(string,uint8,tuple(bool,address))"
+     * @returns Array of field types: ["string", "uint8", "tuple(bool,address)"]
+     */
+    private static parseTupleFields;
+    /**
+     * Convert object to array based on ABI type structure
+     * Supports nested tuples recursively
+     *
+     * @param abiType ABI type string
+     * @param value Value (can be object or array)
+     * @returns Array value
+     */
+    private static convertObjectToArray;
+    /**
+     * Encode a value with given ABI type
+     *
+     * @param abiType ABI type string (e.g., "string", "uint256", "tuple(string,uint8)")
+     * @param value Value to encode (objects are automatically converted to arrays)
+     * @returns Encoded bytes (with 0x prefix)
+     *
+     * @example
+     * // Simple value
+     * TagAbiCodec.encode("string", "hello");
+     *
+     * // Array value
+     * TagAbiCodec.encode("string[]", ["a", "b", "c"]);
+     *
+     * // Tuple with object input
+     * TagAbiCodec.encode("tuple(string,uint8)", {name: "Alice", age: 30});
+     *
+     * // Nested tuple with object input
+     * TagAbiCodec.encode(
+     *   "tuple(string,tuple(uint8,bool))",
+     *   {name: "Alice", profile: {age: 30, verified: true}}
+     * );
+     *
+     * // Tuple with array input (still supported)
+     * TagAbiCodec.encode("tuple(string,uint8)", ["Alice", 30]);
+     */
+    static encode(abiType: string, value: any): string;
+    /**
+     * Decode bytes with given ABI type
+     *
+     * @param abiType ABI type string
+     * @param encodedData Encoded bytes (with or without 0x prefix)
+     * @returns Decoded value
+     *
+     * @example
+     * TagAbiCodec.decode("string", encodedBytes);  // → "hello"
+     * TagAbiCodec.decode("uint256", encodedBytes); // → 123n (BigInt)
+     * TagAbiCodec.decode("tuple(string,uint8)", encodedBytes); // → ["Alice", 30n]
+     */
+    static decode(abiType: string, encodedData: string): any;
+}
+//# sourceMappingURL=tag-abi-codec.d.ts.map

package/dist/utils/tag-abi-codec.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tag-abi-codec.d.ts","sourceRoot":"","sources":["../../src/utils/tag-abi-codec.ts"],"names":[],"mappings":"AAEA;;;;;;;;;GASG;AACH,qBAAa,WAAW;IACvB,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAkB;IAEzC;;;;OAIG;IACH,OAAO,CAAC,MAAM,CAAC,gBAAgB;IAkC/B;;;;;;;OAOG;IACH,OAAO,CAAC,MAAM,CAAC,oBAAoB;IA6CnC;;;;;;;;;;;;;;;;;;;;;;;;;OAyBG;IACH,MAAM,CAAC,MAAM,CAAC,OAAO,EAAE,MAAM,EAAE,KAAK,EAAE,GAAG,GAAG,MAAM;IAQlD;;;;;;;;;;;OAWG;IACH,MAAM,CAAC,MAAM,CAAC,OAAO,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,GAAG,GAAG;CAIxD"}

package/dist/utils/tag-abi-codec.js

@@ -0,0 +1,144 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TagAbiCodec = void 0;
+const ethers_1 = require("ethers");
+/**
+ * Tag ABI Codec
+ * Unified encoding/decoding utility for Tag values
+ *
+ * Key Principle: ALL values use abi.encode()
+ * - Simple values: abi.encode("value")
+ * - Arrays: abi.encode(["a", "b", "c"])
+ * - Tuples: abi.encode(struct)
+ * - Elements for push: abi.encode(singleElement)
+ */
+class TagAbiCodec {
+    /**
+     * Parse tuple field types from ABI type string
+     * @param abiType e.g., "tuple(string,uint8,tuple(bool,address))"
+     * @returns Array of field types: ["string", "uint8", "tuple(bool,address)"]
+     */
+    static parseTupleFields(abiType) {
+        if (!abiType.startsWith('tuple(')) {
+            return [];
+        }
+        const innerTypes = abiType.slice(6, -1); // Remove "tuple(" and ")"
+        const fields = [];
+        let depth = 0;
+        let currentField = '';
+        for (let i = 0; i < innerTypes.length; i++) {
+            const char = innerTypes[i];
+            if (char === '(') {
+                depth++;
+                currentField += char;
+            }
+            else if (char === ')') {
+                depth--;
+                currentField += char;
+            }
+            else if (char === ',' && depth === 0) {
+                fields.push(currentField.trim());
+                currentField = '';
+            }
+            else {
+                currentField += char;
+            }
+        }
+        if (currentField) {
+            fields.push(currentField.trim());
+        }
+        return fields;
+    }
+    /**
+     * Convert object to array based on ABI type structure
+     * Supports nested tuples recursively
+     *
+     * @param abiType ABI type string
+     * @param value Value (can be object or array)
+     * @returns Array value
+     */
+    static convertObjectToArray(abiType, value) {
+        // If already an array or not an object, return as-is
+        if (Array.isArray(value) ||
+            typeof value !== 'object' ||
+            value === null) {
+            return value;
+        }
+        // If not a tuple type, return as-is
+        if (!abiType.startsWith('tuple(')) {
+            return value;
+        }
+        // Parse tuple field types
+        const fieldTypes = this.parseTupleFields(abiType);
+        const fieldNames = Object.keys(value);
+        if (fieldNames.length !== fieldTypes.length) {
+            throw new Error(`Tuple field count mismatch: expected ${fieldTypes.length} fields, got ${fieldNames.length} (${fieldNames.join(', ')})`);
+        }
+        // Convert object to array, recursively handling nested tuples
+        const result = [];
+        for (let i = 0; i < fieldNames.length; i++) {
+            const fieldName = fieldNames[i];
+            const fieldType = fieldTypes[i];
+            const fieldValue = value[fieldName];
+            // Recursively convert nested tuples
+            if (fieldType.startsWith('tuple(')) {
+                result.push(this.convertObjectToArray(fieldType, fieldValue));
+            }
+            else {
+                result.push(fieldValue);
+            }
+        }
+        return result;
+    }
+    /**
+     * Encode a value with given ABI type
+     *
+     * @param abiType ABI type string (e.g., "string", "uint256", "tuple(string,uint8)")
+     * @param value Value to encode (objects are automatically converted to arrays)
+     * @returns Encoded bytes (with 0x prefix)
+     *
+     * @example
+     * // Simple value
+     * TagAbiCodec.encode("string", "hello");
+     *
+     * // Array value
+     * TagAbiCodec.encode("string[]", ["a", "b", "c"]);
+     *
+     * // Tuple with object input
+     * TagAbiCodec.encode("tuple(string,uint8)", {name: "Alice", age: 30});
+     *
+     * // Nested tuple with object input
+     * TagAbiCodec.encode(
+     *   "tuple(string,tuple(uint8,bool))",
+     *   {name: "Alice", profile: {age: 30, verified: true}}
+     * );
+     *
+     * // Tuple with array input (still supported)
+     * TagAbiCodec.encode("tuple(string,uint8)", ["Alice", 30]);
+     */
+    static encode(abiType, value) {
+        // Convert object to array if needed (handles nested tuples recursively)
+        const convertedValue = this.convertObjectToArray(abiType, value);
+        // Use ethers AbiCoder to encode
+        return this.abiCoder.encode([abiType], [convertedValue]);
+    }
+    /**
+     * Decode bytes with given ABI type
+     *
+     * @param abiType ABI type string
+     * @param encodedData Encoded bytes (with or without 0x prefix)
+     * @returns Decoded value
+     *
+     * @example
+     * TagAbiCodec.decode("string", encodedBytes);  // → "hello"
+     * TagAbiCodec.decode("uint256", encodedBytes); // → 123n (BigInt)
+     * TagAbiCodec.decode("tuple(string,uint8)", encodedBytes); // → ["Alice", 30n]
+     */
+    static decode(abiType, encodedData) {
+        const decoded = this.abiCoder.decode([abiType], encodedData);
+        return decoded[0];
+    }
+}
+exports.TagAbiCodec = TagAbiCodec;
+TagAbiCodec.abiCoder = new ethers_1.AbiCoder();
+//# sourceMappingURL=tag-abi-codec.js.map

package/dist/utils/tag-abi-codec.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"tag-abi-codec.js","sourceRoot":"","sources":["../../src/utils/tag-abi-codec.ts"],"names":[],"mappings":";;;AAAA,mCAAkC;AAElC;;;;;;;;;GASG;AACH,MAAa,WAAW;IAGvB;;;;OAIG;IACK,MAAM,CAAC,gBAAgB,CAAC,OAAe;QAC9C,IAAI,CAAC,OAAO,CAAC,UAAU,CAAC,QAAQ,CAAC,EAAE,CAAC;YACnC,OAAO,EAAE,CAAC;QACX,CAAC;QAED,MAAM,UAAU,GAAG,OAAO,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC,0BAA0B;QACnE,MAAM,MAAM,GAAa,EAAE,CAAC;QAC5B,IAAI,KAAK,GAAG,CAAC,CAAC;QACd,IAAI,YAAY,GAAG,EAAE,CAAC;QAEtB,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,UAAU,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE,CAAC;YAC5C,MAAM,IAAI,GAAG,UAAU,CAAC,CAAC,CAAC,CAAC;YAE3B,IAAI,IAAI,KAAK,GAAG,EAAE,CAAC;gBAClB,KAAK,EAAE,CAAC;gBACR,YAAY,IAAI,IAAI,CAAC;YACtB,CAAC;iBAAM,IAAI,IAAI,KAAK,GAAG,EAAE,CAAC;gBACzB,KAAK,EAAE,CAAC;gBACR,YAAY,IAAI,IAAI,CAAC;YACtB,CAAC;iBAAM,IAAI,IAAI,KAAK,GAAG,IAAI,KAAK,KAAK,CAAC,EAAE,CAAC;gBACxC,MAAM,CAAC,IAAI,CAAC,YAAY,CAAC,IAAI,EAAE,CAAC,CAAC;gBACjC,YAAY,GAAG,EAAE,CAAC;YACnB,CAAC;iBAAM,CAAC;gBACP,YAAY,IAAI,IAAI,CAAC;YACtB,CAAC;QACF,CAAC;QAED,IAAI,YAAY,EAAE,CAAC;YAClB,MAAM,CAAC,IAAI,CAAC,YAAY,CAAC,IAAI,EAAE,CAAC,CAAC;QAClC,CAAC;QAED,OAAO,MAAM,CAAC;IACf,CAAC;IAED;;;;;;;OAOG;IACK,MAAM,CAAC,oBAAoB,CAAC,OAAe,EAAE,KAAU;QAC9D,qDAAqD;QACrD,IACC,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC;YACpB,OAAO,KAAK,KAAK,QAAQ;YACzB,KAAK,KAAK,IAAI,EACb,CAAC;YACF,OAAO,KAAK,CAAC;QACd,CAAC;QAED,oCAAoC;QACpC,IAAI,CAAC,OAAO,CAAC,UAAU,CAAC,QAAQ,CAAC,EAAE,CAAC;YACnC,OAAO,KAAK,CAAC;QACd,CAAC;QAED,0BAA0B;QAC1B,MAAM,UAAU,GAAG,IAAI,CAAC,gBAAgB,CAAC,OAAO,CAAC,CAAC;QAClD,MAAM,UAAU,GAAG,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;QAEtC,IAAI,UAAU,CAAC,MAAM,KAAK,UAAU,CAAC,MAAM,EAAE,CAAC;YAC7C,MAAM,IAAI,KAAK,CACd,wCACC,UAAU,CAAC,MACZ,gBAAgB,UAAU,CAAC,MAAM,KAAK,UAAU,CAAC,IAAI,CAAC,IAAI,CAAC,GAAG,CAC9D,CAAC;QACH,CAAC;QAED,8DAA8D;QAC9D,MAAM,MAAM,GAAU,EAAE,CAAC;QACzB,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,UAAU,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE,CAAC;YAC5C,MAAM,SAAS,GAAG,UAAU,CAAC,CAAC,CAAC,CAAC;YAChC,MAAM,SAAS,GAAG,UAAU,CAAC,CAAC,CAAC,CAAC;YAChC,MAAM,UAAU,GAAG,KAAK,CAAC,SAAS,CAAC,CAAC;YAEpC,oCAAoC;YACpC,IAAI,SAAS,CAAC,UAAU,CAAC,QAAQ,CAAC,EAAE,CAAC;gBACpC,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,oBAAoB,CAAC,SAAS,EAAE,UAAU,CAAC,CAAC,CAAC;YAC/D,CAAC;iBAAM,CAAC;gBACP,MAAM,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC;YACzB,CAAC;QACF,CAAC;QAED,OAAO,MAAM,CAAC;IACf,CAAC;IAED;;;;;;;;;;;;;;;;;;;;;;;;;OAyBG;IACH,MAAM,CAAC,MAAM,CAAC,OAAe,EAAE,KAAU;QACxC,wEAAwE;QACxE,MAAM,cAAc,GAAG,IAAI,CAAC,oBAAoB,CAAC,OAAO,EAAE,KAAK,CAAC,CAAC;QAEjE,gCAAgC;QAChC,OAAO,IAAI,CAAC,QAAQ,CAAC,MAAM,CAAC,CAAC,OAAO,CAAC,EAAE,CAAC,cAAc,CAAC,CAAC,CAAC;IAC1D,CAAC;IAED;;;;;;;;;;;OAWG;IACH,MAAM,CAAC,MAAM,CAAC,OAAe,EAAE,WAAmB;QACjD,MAAM,OAAO,GAAG,IAAI,CAAC,QAAQ,CAAC,MAAM,CAAC,CAAC,OAAO,CAAC,EAAE,WAAW,CAAC,CAAC;QAC7D,OAAO,OAAO,CAAC,CAAC,CAAC,CAAC;IACnB,CAAC;;AAhJF,kCAiJC;AAhJe,oBAAQ,GAAG,IAAI,iBAAQ,EAAE,CAAC"}

package/dist/utils/tag-type-builder.d.ts

@@ -0,0 +1,158 @@
+/**
+ * Tag Type Builder
+ * Calculate ABI type bytes offline without contract calls
+ * Does NOT handle encoding/decoding - use TagAbiCodec for that
+ *
+ * Encoding Rules:
+ * - uint: 0x01 + size (size = bits/8)
+ * - int: 0x00 + size
+ * - bool: 0x02
+ * - string: 0x03
+ * - array: 0x04 + elementType
+ * - fixedArray: 0x05 + length (2 bytes) + elementType
+ * - tuple: 0x06 + fieldCount (2 bytes) + fieldTypes...
+ * - address: 0x07
+ * - fixedBytes: 0x08 + size
+ * - bytes: 0x09
+ */
+export declare class TagTypeBuilder {
+    private typeBytes;
+    private abiTypeString;
+    protected constructor(typeBytes: string, abiTypeString?: string);
+    /**
+     * Get ABI type bytes (without 0x prefix)
+     */
+    getTypeBytes(): string;
+    /**
+     * Get ABI type string (e.g., "string", "uint256", "tuple(string,uint8)")
+     */
+    getAbiTypeString(): string;
+    /**
+     * Parse type bytes to ABI type string
+     * This is the reverse operation of building type bytes
+     * @param typeBytes Hex string of type bytes (with or without 0x prefix)
+     * @returns ABI type string
+     */
+    static parseTypeBytesToAbiString(typeBytes: string): string;
+    /**
+     * Calculate the byte length of a type bytes string (without 0x prefix)
+     * @private
+     */
+    private static getTypeBytesLength;
+    /**
+     * Get field names (for Tuple types)
+     * Returns format: string[][], each element is a tuple's field name array
+     */
+    getFieldNames(): string[][];
+    /**
+     * uint type
+     * @param bits Bit count: 8, 16, 24, ..., 256 (must be divisible by 8)
+     * @example
+     * TagTypeBuilder.uint(8)   → "0101"
+     * TagTypeBuilder.uint(256) → "0120"
+     */
+    static uint(bits?: number): TagTypeBuilder;
+    /**
+     * int type
+     * @param bits Bit count: 8, 16, 24, ..., 256 (must be divisible by 8)
+     * @example
+     * TagTypeBuilder.int(8)   → "0001"
+     * TagTypeBuilder.int(256) → "0020"
+     */
+    static int(bits?: number): TagTypeBuilder;
+    /**
+     * bool type
+     * @example
+     * TagTypeBuilder.bool() → "02"
+     */
+    static bool(): TagTypeBuilder;
+    /**
+     * string type
+     * @example
+     * TagTypeBuilder.string() → "03"
+     */
+    static string(): TagTypeBuilder;
+    /**
+     * address type
+     * @example
+     * TagTypeBuilder.address() → "07"
+     */
+    static address(): TagTypeBuilder;
+    /**
+     * bytes type (dynamic length)
+     * @example
+     * TagTypeBuilder.bytes() → "09"
+     */
+    static bytes(): TagTypeBuilder;
+    /**
+     * bytesN type (fixed length)
+     * @param size Byte count: 1-32
+     * @example
+     * TagTypeBuilder.fixedBytes(32) → "0820"
+     */
+    static fixedBytes(size: number): TagTypeBuilder;
+    /**
+     * Dynamic array
+     * @param elementType Element type
+     * @example
+     * TagTypeBuilder.array(TagTypeBuilder.address()) → "0407"
+     */
+    static array(elementType: TagTypeBuilder): TagTypeBuilder;
+    /**
+     * Fixed-length array
+     * @param elementType Element type
+     * @param length Array length (1-65535)
+     * @example
+     * TagTypeBuilder.fixedArray(TagTypeBuilder.address(), 5) → "05000507"
+     */
+    static fixedArray(elementType: TagTypeBuilder, length: number): TagTypeBuilder;
+    /**
+     * tuple type
+     * @param fields Field definitions, format: { fieldName: fieldType }
+     * @example
+     * TagTypeBuilder.tuple({
+     *   name: TagTypeBuilder.string(),
+     *   age: TagTypeBuilder.uint8()
+     * }) → "060002" + "03" + "0101"
+     *
+     * Field names are collected in pre-order traversal (DFS pre-order) for nested tuples.
+     * Pre-order: Visit root first, then recursively visit children left-to-right.
+     *
+     * Example tree structure: A{B{D{E, F}}, C}
+     * fieldNames = [
+     *   ["i", "j"],  // A's fields (root)
+     *   ["i"],       // B's fields (A's 1st child)
+     *   ["i", "j"],  // D's fields (B's child)
+     *   ["i", "j"],  // E's fields (D's 1st child)
+     *   ["i", "j"],  // F's fields (D's 2nd child)
+     *   ["i"]        // C's fields (A's 2nd child)
+     * ]
+     */
+    static tuple(fields: Record<string, TagTypeBuilder>): TupleTypeBuilder;
+    static uint8(): TagTypeBuilder;
+    static uint16(): TagTypeBuilder;
+    static uint32(): TagTypeBuilder;
+    static uint64(): TagTypeBuilder;
+    static uint128(): TagTypeBuilder;
+    static uint256(): TagTypeBuilder;
+    static int8(): TagTypeBuilder;
+    static int16(): TagTypeBuilder;
+    static int32(): TagTypeBuilder;
+    static int64(): TagTypeBuilder;
+    static int128(): TagTypeBuilder;
+    static int256(): TagTypeBuilder;
+    static bytes32(): TagTypeBuilder;
+    static addressArray(): TagTypeBuilder;
+    static stringArray(): TagTypeBuilder;
+    static uint256Array(): TagTypeBuilder;
+}
+/**
+ * Tuple Type Builder (supports field names and object encoding)
+ */
+export declare class TupleTypeBuilder extends TagTypeBuilder {
+    private fieldNames;
+    private fieldTypes?;
+    constructor(typeBytes: string, fieldNames: string[][], abiTypeString?: string, fieldTypes?: Record<string, TagTypeBuilder>);
+    getFieldNames(): string[][];
+}
+//# sourceMappingURL=tag-type-builder.d.ts.map

package/dist/utils/tag-type-builder.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tag-type-builder.d.ts","sourceRoot":"","sources":["../../src/utils/tag-type-builder.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AACH,qBAAa,cAAc;IAC1B,OAAO,CAAC,SAAS,CAAc;IAC/B,OAAO,CAAC,aAAa,CAAc;IAEnC,SAAS,aAAa,SAAS,EAAE,MAAM,EAAE,aAAa,GAAE,MAAW;IAKnE;;OAEG;IACH,YAAY,IAAI,MAAM;IAItB;;OAEG;IACH,gBAAgB,IAAI,MAAM;IAI1B;;;;;OAKG;IACH,MAAM,CAAC,yBAAyB,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM;IAsF3D;;;OAGG;IACH,OAAO,CAAC,MAAM,CAAC,kBAAkB;IAgDjC;;;OAGG;IACH,aAAa,IAAI,MAAM,EAAE,EAAE;IAS3B;;;;;;OAMG;IACH,MAAM,CAAC,IAAI,CAAC,IAAI,GAAE,MAAY,GAAG,cAAc;IAS/C;;;;;;OAMG;IACH,MAAM,CAAC,GAAG,CAAC,IAAI,GAAE,MAAY,GAAG,cAAc;IAS9C;;;;OAIG;IACH,MAAM,CAAC,IAAI,IAAI,cAAc;IAI7B;;;;OAIG;IACH,MAAM,CAAC,MAAM,IAAI,cAAc;IAI/B;;;;OAIG;IACH,MAAM,CAAC,OAAO,IAAI,cAAc;IAIhC;;;;OAIG;IACH,MAAM,CAAC,KAAK,IAAI,cAAc;IAI9B;;;;;OAKG;IACH,MAAM,CAAC,UAAU,CAAC,IAAI,EAAE,MAAM,GAAG,cAAc;IAY/C;;;;;OAKG;IACH,MAAM,CAAC,KAAK,CAAC,WAAW,EAAE,cAAc,GAAG,cAAc;IAYzD;;;;;;OAMG;IACH,MAAM,CAAC,UAAU,CAChB,WAAW,EAAE,cAAc,EAC3B,MAAM,EAAE,MAAM,GACZ,cAAc;IAoBjB;;;;;;;;;;;;;;;;;;;;;OAqBG;IACH,MAAM,CAAC,KAAK,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,cAAc,CAAC,GAAG,gBAAgB;IAyCtE,MAAM,CAAC,KAAK;IAGZ,MAAM,CAAC,MAAM;IAGb,MAAM,CAAC,MAAM;IAGb,MAAM,CAAC,MAAM;IAGb,MAAM,CAAC,OAAO;IAGd,MAAM,CAAC,OAAO;IAId,MAAM,CAAC,IAAI;IAGX,MAAM,CAAC,KAAK;IAGZ,MAAM,CAAC,KAAK;IAGZ,MAAM,CAAC,KAAK;IAGZ,MAAM,CAAC,MAAM;IAGb,MAAM,CAAC,MAAM;IAIb,MAAM,CAAC,OAAO;IAId,MAAM,CAAC,YAAY;IAGnB,MAAM,CAAC,WAAW;IAGlB,MAAM,CAAC,YAAY;CAGnB;AAED;;GAEG;AACH,qBAAa,gBAAiB,SAAQ,cAAc;IACnD,OAAO,CAAC,UAAU,CAAa;IAC/B,OAAO,CAAC,UAAU,CAAC,CAAiC;gBAGnD,SAAS,EAAE,MAAM,EACjB,UAAU,EAAE,MAAM,EAAE,EAAE,EACtB,aAAa,GAAE,MAAW,EAC1B,UAAU,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,cAAc,CAAC;IAO5C,aAAa,IAAI,MAAM,EAAE,EAAE;CAG3B"}