@beclab/olaresid 0.1.12 → 0.2.0

package/src/utils/tag-type-builder.ts

@@ -443,6 +443,144 @@ export class TagTypeBuilder {
 	static uint256Array() {
 		return this.array(this.uint256());
 	}
+
+	// ========================================
+	// Object to Array Conversion (for encoding)
+	// ========================================
+
+	/**
+	 * Convert object to array for tuple encoding
+	 * Recursively handles nested tuples and tuple arrays
+	 *
+	 * @param abiType ABI type string (e.g., "tuple(string,uint8)")
+	 * @param value Value to convert (object or array)
+	 * @returns Array representation suitable for ABI encoding
+	 *
+	 * @example
+	 * // Simple tuple
+	 * convertObjectToArray(
+	 *   "tuple(string,uint8)",
+	 *   {name: "Alice", age: 30}
+	 * ) // → ["Alice", 30]
+	 *
+	 * // Nested tuple
+	 * convertObjectToArray(
+	 *   "tuple(string,tuple(uint8,bool))",
+	 *   {name: "Bob", profile: {age: 25, active: true}}
+	 * ) // → ["Bob", [25, true]]
+	 *
+	 * // Tuple array
+	 * convertObjectToArray(
+	 *   "tuple(uint8,address)[]",
+	 *   [{algorithm: 0, addr: "0x123..."}, {algorithm: 1, addr: "0x456..."}]
+	 * ) // → [[0, "0x123..."], [1, "0x456..."]]
+	 */
+	static convertObjectToArray(abiType: string, value: any): any {
+		// Handle null and primitives
+		if (value === null || typeof value !== 'object') {
+			return value;
+		}
+
+		// Handle tuple[] type (array of tuples)
+		// Check if it ends with [] and starts with tuple
+		if (abiType.startsWith('tuple(') && abiType.endsWith('[]')) {
+			if (Array.isArray(value)) {
+				// Remove [] suffix to get element type: "tuple(uint8,address)[]" → "tuple(uint8,address)"
+				const elementType = abiType.slice(0, -2);
+				// Recursively convert each element
+				return value.map((item) =>
+					this.convertObjectToArray(elementType, item)
+				);
+			}
+			// If not an array but type is tuple[], return as-is
+			return value;
+		}
+
+		// If already an array (but not tuple[]), return as-is
+		if (Array.isArray(value)) {
+			return value;
+		}
+
+		// If not a tuple type, return as-is
+		if (!abiType.startsWith('tuple(')) {
+			return value;
+		}
+
+		// Parse tuple field types
+		const fieldTypes = this.parseTupleFieldTypes(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}`
+			);
+		}
+
+		// Convert object to array, recursively handling nested tuples
+		const result: any[] = [];
+		for (let i = 0; i < fieldNames.length; i++) {
+			const fieldName = fieldNames[i];
+			const fieldType = fieldTypes[i];
+			const fieldValue = value[fieldName];
+
+			// Recursively convert nested tuples (including nested tuple arrays)
+			if (fieldType.startsWith('tuple(')) {
+				result.push(this.convertObjectToArray(fieldType, fieldValue));
+			} else {
+				result.push(fieldValue);
+			}
+		}
+
+		return result;
+	}
+
+	/**
+	 * Parse tuple field types from ABI type string
+	 * Handles nested tuples correctly
+	 *
+	 * @param abiType Tuple ABI type string
+	 * @returns Array of field type strings
+	 *
+	 * @example
+	 * parseTupleFieldTypes("tuple(string,uint8)")
+	 * // → ["string", "uint8"]
+	 *
+	 * parseTupleFieldTypes("tuple(string,tuple(uint8,bool))")
+	 * // → ["string", "tuple(uint8,bool)"]
+	 */
+	static parseTupleFieldTypes(abiType: string): string[] {
+		if (!abiType.startsWith('tuple(')) {
+			return [];
+		}
+
+		const innerTypes = abiType.slice(6, -1); // Remove "tuple(" and ")"
+		const fields: string[] = [];
+		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;
+	}
 }
 
 /**

package/src/utils/tag-type-parser.ts

@@ -0,0 +1,246 @@
+import { AbiCoder } from 'ethers';
+import { TagTypeBuilder } from './tag-type-builder';
+import { RawTagData, Tag } from '../domain/types';
+
+/**
+ * Tag Type Parser
+ * Parse and decode Tag values with field name support
+ *
+ * Pair with TagTypeBuilder:
+ * - TagTypeBuilder: Encoding (build types, object → array)
+ * - TagTypeParser: Decoding (parse types, array → object, parse tags)
+ */
+export class TagTypeParser {
+	/**
+	 * Parse a raw tag into a formatted Tag object
+	 * Handles all types including nested tuples
+	 *
+	 * @param rawTag Raw tag data from contract
+	 * @param fieldNamesMap Map of field name hashes to field names
+	 * @param abiCoder AbiCoder instance for decoding
+	 * @returns Formatted Tag object
+	 */
+	static parseTag(
+		rawTag: RawTagData,
+		fieldNamesMap: Map<string, string[]>,
+		abiCoder: AbiCoder
+	): Tag {
+		// Step 1: Parse type bytes to ABI type string
+		const abiTypeString = TagTypeBuilder.parseTypeBytesToAbiString(
+			rawTag.abiType
+		);
+
+		// If the tag has no value (defined but not set), return it with null formatted value
+		if (!rawTag.value || rawTag.value === '0x' || rawTag.value === '') {
+			return {
+				from: rawTag.from,
+				name: rawTag.name,
+				abiType: abiTypeString,
+				value: rawTag.value,
+				fieldNamesHash: rawTag.fieldNamesHash,
+				valueFormatted: null
+			};
+		}
+
+		// Step 2: Decode value
+		const decoded = abiCoder.decode([abiTypeString], rawTag.value);
+		let decodedValue = decoded[0];
+
+		// Step 3: Convert to user-friendly format
+		let formattedValue: any = decodedValue;
+
+		// Handle tuple types (including tuple arrays and nested tuples)
+		if (abiTypeString.includes('tuple')) {
+			// Get all field names in pre-order (for nested tuples)
+			const allFieldNames = this.getAllFieldNames(
+				rawTag.fieldNamesHash,
+				fieldNamesMap
+			);
+
+			if (allFieldNames.length > 0) {
+				// Use a counter to track which field name array we're using
+				const context = { fieldNameIndex: 0 };
+
+				// Check if it's an array of tuples
+				if (
+					abiTypeString.startsWith('tuple(') &&
+					abiTypeString.endsWith('[]')
+				) {
+					// Array of tuples: convert each element
+					if (Array.isArray(decodedValue)) {
+						formattedValue = decodedValue.map((item) => {
+							// Reset field name index for each array element
+							const itemContext = { fieldNameIndex: 0 };
+							return this.convertTupleToObject(
+								item,
+								abiTypeString.slice(0, -2),
+								allFieldNames,
+								itemContext
+							);
+						});
+					}
+				} else if (abiTypeString.startsWith('tuple(')) {
+					// Single tuple: convert to object (with nested tuple support)
+					formattedValue = this.convertTupleToObject(
+						decodedValue,
+						abiTypeString,
+						allFieldNames,
+						context
+					);
+				}
+			} else {
+				// Log warning if field names not found for tuple
+				if (
+					rawTag.fieldNamesHash.length > 0 &&
+					rawTag.fieldNamesHash[0] !==
+						'0x0000000000000000000000000000000000000000000000000000000000000000'
+				) {
+					console.warn(
+						`⚠️  Field names not found for tag "${
+							rawTag.name
+						}" with hash(es): ${rawTag.fieldNamesHash.join(', ')}`
+					);
+				}
+			}
+		}
+
+		// Convert BigInt to string for serialization
+		formattedValue = this.convertBigIntToString(formattedValue);
+
+		// Serialize objects/arrays to JSON string for did-support compatibility
+		if (formattedValue !== null && typeof formattedValue === 'object') {
+			formattedValue = JSON.stringify(formattedValue);
+		}
+
+		return {
+			from: rawTag.from,
+			name: rawTag.name,
+			abiType: abiTypeString,
+			value: rawTag.value,
+			fieldNamesHash: rawTag.fieldNamesHash,
+			valueFormatted: formattedValue
+		};
+	}
+
+	/**
+	 * Convert decoded tuple array to object using field names
+	 * Recursively handles nested tuples
+	 *
+	 * @param value Decoded tuple value (array form)
+	 * @param abiType ABI type string of the tuple
+	 * @param allFieldNames All field names in pre-order traversal
+	 * @param context Context to track which field name array we're using
+	 * @returns Object representation with field names
+	 *
+	 * @example
+	 * // Simple tuple
+	 * convertTupleToObject(
+	 *   ["Alice", 30],
+	 *   "tuple(string,uint8)",
+	 *   [["name", "age"]],
+	 *   { fieldNameIndex: 0 }
+	 * ) // → { name: "Alice", age: 30 }
+	 *
+	 * // Nested tuple
+	 * convertTupleToObject(
+	 *   ["Bob", [25, true]],
+	 *   "tuple(string,tuple(uint8,bool))",
+	 *   [["name", "profile"], ["age", "verified"]],
+	 *   { fieldNameIndex: 0 }
+	 * ) // → { name: "Bob", profile: { age: 25, verified: true } }
+	 */
+	static convertTupleToObject(
+		value: any,
+		abiType: string,
+		allFieldNames: string[][],
+		context: { fieldNameIndex: number }
+	): any {
+		if (!Array.isArray(value) || !abiType.startsWith('tuple(')) {
+			return value;
+		}
+
+		// Get field names for current tuple level
+		if (context.fieldNameIndex >= allFieldNames.length) {
+			return value;
+		}
+
+		const fieldNames = allFieldNames[context.fieldNameIndex];
+		context.fieldNameIndex++;
+
+		if (fieldNames.length !== value.length) {
+			return value;
+		}
+
+		// Parse field types to determine which fields are nested tuples
+		const fieldTypes = TagTypeBuilder.parseTupleFieldTypes(abiType);
+
+		const obj: any = {};
+		for (let i = 0; i < fieldNames.length; i++) {
+			const fieldName = fieldNames[i];
+			const fieldValue = value[i];
+			const fieldType = fieldTypes[i];
+
+			// Recursively convert nested tuples
+			if (fieldType.startsWith('tuple(')) {
+				obj[fieldName] = this.convertTupleToObject(
+					fieldValue,
+					fieldType,
+					allFieldNames,
+					context
+				);
+			} else {
+				obj[fieldName] = fieldValue;
+			}
+		}
+
+		return obj;
+	}
+
+	/**
+	 * Recursively convert BigInt values to strings
+	 * Handles primitives, arrays, and objects
+	 *
+	 * @param value Value to convert
+	 * @returns Value with all BigInts converted to strings
+	 */
+	static convertBigIntToString(value: any): any {
+		if (typeof value === 'bigint') {
+			return value.toString();
+		}
+		if (Array.isArray(value)) {
+			return value.map((v) => this.convertBigIntToString(v));
+		}
+		if (value !== null && typeof value === 'object') {
+			const result: any = {};
+			for (const key in value) {
+				result[key] = this.convertBigIntToString(value[key]);
+			}
+			return result;
+		}
+		return value;
+	}
+
+	/**
+	 * Get all field names for a tag from the field names map
+	 * Returns all field name arrays in pre-order (for nested tuples)
+	 *
+	 * @param fieldNamesHashes Array of field name hashes
+	 * @param fieldNamesMap Map of hash to field names
+	 * @returns Array of field name arrays in pre-order
+	 */
+	private static getAllFieldNames(
+		fieldNamesHashes: string[],
+		fieldNamesMap: Map<string, string[]>
+	): string[][] {
+		const allFieldNames: string[][] = [];
+
+		for (const hash of fieldNamesHashes) {
+			const names = fieldNamesMap.get(hash);
+			if (names) {
+				allFieldNames.push(names);
+			}
+		}
+
+		return allFieldNames;
+	}
+}