@beclab/olaresid 0.1.1 → 0.1.2

package/src/business/tag-context.ts

@@ -0,0 +1,713 @@
+import { DIDConsole } from '../index';
+import { TransactionResult } from './index';
+import { parseContractError } from '../utils/error-parser';
+import { TagTypeBuilder } from '../utils/tag-type-builder';
+import { TagAbiCodec } from '../utils/tag-abi-codec';
+
+/**
+ * Tag Operation Context
+ * Provides complete Tag management functionality
+ */
+export class TagContext {
+	constructor(private console: DIDConsole, private fromDomain: string) {}
+
+	// ========================================
+	// 1. Tag Type Definition Management
+	// ========================================
+
+	/**
+	 * Set the tagger (manager) for a Tag
+	 * Only the domain owner can set the tagger
+	 *
+	 * @param tagName Tag name
+	 * @param taggerAddress Address of the tagger (manager)
+	 * @returns Transaction result
+	 *
+	 * @example
+	 * // Set a specific address as the tagger
+	 * await tagCtx.setTagger('email', '0x1234...');
+	 *
+	 * // Set zero address to allow anyone to manage
+	 * await tagCtx.setTagger('email', '0x0000000000000000000000000000000000000000');
+	 */
+	async setTagger(
+		tagName: string,
+		taggerAddress: string
+	): Promise<TransactionResult> {
+		const contract = this.console.getSignerContractDID();
+
+		try {
+			const tx = await contract.setTagger(
+				this.fromDomain,
+				tagName,
+				taggerAddress
+			);
+
+			const receipt = await tx.wait();
+
+			return {
+				success: true,
+				transactionHash: receipt.hash,
+				gasUsed: receipt.gasUsed,
+				blockNumber: receipt.blockNumber
+			};
+		} catch (error: any) {
+			const errorInfo = parseContractError(error);
+			if (errorInfo.isNetworkError) {
+				throw new Error(`Network error: ${errorInfo.message}`);
+			}
+			throw new Error(`Failed to set tagger: ${errorInfo.message}`);
+		}
+	}
+
+	/**
+	 * Get the tagger (manager) address for a Tag
+	 *
+	 * @param tagName Tag name
+	 * @returns Tagger address (returns zero address if no tagger is set)
+	 *
+	 * @example
+	 * const tagger = await tagCtx.getTagger('email');
+	 * console.log('Tagger address:', tagger);
+	 *
+	 * if (tagger === '0x0000000000000000000000000000000000000000') {
+	 *   console.log('No specific tagger, anyone can manage');
+	 * }
+	 */
+	async getTagger(tagName: string): Promise<string> {
+		const contract = this.console.getContractDID();
+		return await contract.getTagger(this.fromDomain, tagName);
+	}
+
+	/**
+	 * Define a new Tag type
+	 * @param tagName Tag name
+	 * @param tagType Tag type object (built using TagTypeBuilder)
+	 * @returns Transaction result
+	 *
+	 * @example
+	 * const emailType = TagTypeBuilder.string();
+	 * await tagCtx.defineTag('email', emailType);
+	 */
+	async defineTag(
+		tagName: string,
+		tagType: TagTypeBuilder
+	): Promise<TransactionResult> {
+		const contract = this.console.getSignerContractDID();
+
+		// Get type bytes directly from TagTypeBuilder (no contract call needed)
+		const abiTypeBytes = '0x' + tagType.getTypeBytes();
+
+		// Get field names (for complex types)
+		const fieldNames = tagType.getFieldNames();
+
+		try {
+			const tx = await contract.defineTag(
+				this.fromDomain,
+				tagName,
+				abiTypeBytes,
+				fieldNames
+			);
+
+			const receipt = await tx.wait();
+
+			return {
+				success: true,
+				transactionHash: receipt.hash,
+				gasUsed: receipt.gasUsed,
+				blockNumber: receipt.blockNumber
+			};
+		} catch (error: any) {
+			const errorInfo = parseContractError(error);
+			if (errorInfo.isNetworkError) {
+				throw new Error(`Network error: ${errorInfo.message}`);
+			}
+			throw new Error(`Failed to define tag: ${errorInfo.message}`);
+		}
+	}
+
+	/**
+	 * Get Tag type definition
+	 * @param tagName Tag name
+	 * @returns Tag type information, or null if not found
+	 */
+	async getTagType(tagName: string): Promise<{
+		abiType: string;
+		fieldNamesHash: string[];
+	} | null> {
+		try {
+			const contract = this.console.getContractDID();
+			const [abiType, fieldNamesHash] = await contract.getTagType(
+				this.fromDomain,
+				tagName
+			);
+			return { abiType, fieldNamesHash };
+		} catch (error: any) {
+			const errorInfo = parseContractError(error);
+			if (errorInfo.errorName === 'UndefinedTag') {
+				return null;
+			}
+			throw error;
+		}
+	}
+
+	/**
+	 * Get all Tag names defined by the domain
+	 * @returns Array of Tag names
+	 */
+	async getDefinedTagNames(): Promise<string[]> {
+		const contract = this.console.getContractDID();
+		return await contract.getDefinedTagNames(this.fromDomain);
+	}
+
+	/**
+	 * Get the count of Tags defined by the domain
+	 */
+	async getDefinedTagCount(): Promise<number> {
+		const contract = this.console.getContractDID();
+		const count = await contract.getDefinedTagCount(this.fromDomain);
+		return Number(count);
+	}
+
+	// ========================================
+	// 2. Tag Value Operations
+	// ========================================
+
+	/**
+	 * Set Tag value
+	 * Supports simple values, arrays, and tuples (as objects or arrays)
+	 * Objects are automatically converted to arrays based on ABI type structure
+	 *
+	 * @param toDomain Target domain
+	 * @param tagName Tag name
+	 * @param value Tag value (objects for tuples, arrays, or simple values)
+	 * @returns Transaction result
+	 *
+	 * @example
+	 * // Simple value
+	 * await tagCtx.setTag('example.com', 'email', 'user@example.com');
+	 *
+	 * // Array type
+	 * await tagCtx.setTag('example.com', 'links', ['https://...', 'https://...']);
+	 *
+	 * // Tuple type - object notation (recommended)
+	 * await tagCtx.setTag('example.com', 'userInfo', {
+	 *   name: 'Alice',
+	 *   age: 30,
+	 *   verified: true
+	 * });
+	 *
+	 * // Tuple type - array notation (still supported)
+	 * await tagCtx.setTag('example.com', 'userInfo', ['Alice', 30, true]);
+	 *
+	 * // Nested tuple - object notation
+	 * await tagCtx.setTag('example.com', 'profile', {
+	 *   name: 'Alice',
+	 *   details: {
+	 *     age: 30,
+	 *     verified: true
+	 *   }
+	 * });
+	 */
+	async setTag(
+		toDomain: string,
+		tagName: string,
+		value: any
+	): Promise<TransactionResult> {
+		const contract = this.console.getSignerContractDID();
+
+		// Get tag type
+		const tagTypeInfo = await this.getTagType(tagName);
+		if (!tagTypeInfo) {
+			throw new Error(
+				`Tag "${tagName}" is not defined in domain "${this.fromDomain}"`
+			);
+		}
+
+		try {
+			// Parse type bytes to ABI type string
+			const abiType = TagTypeBuilder.parseTypeBytesToAbiString(
+				tagTypeInfo.abiType
+			);
+
+			// Encode the ENTIRE value using TagAbiCodec
+			// Objects are automatically converted to arrays based on ABI type structure
+			const encodedValue = TagAbiCodec.encode(abiType, value);
+
+			// Check if tag already exists
+			const hasTag = await contract.hasTag(
+				this.fromDomain,
+				toDomain,
+				tagName
+			);
+
+			let tx;
+			if (hasTag) {
+				// Update tag value
+				tx = await contract.updateTagElem(
+					this.fromDomain,
+					toDomain,
+					tagName,
+					[], // Empty path means root element
+					encodedValue
+				);
+			} else {
+				// Add new tag
+				tx = await contract.addTag(
+					this.fromDomain,
+					toDomain,
+					tagName,
+					encodedValue
+				);
+			}
+
+			const receipt = await tx.wait();
+
+			return {
+				success: true,
+				transactionHash: receipt.hash,
+				gasUsed: receipt.gasUsed,
+				blockNumber: receipt.blockNumber
+			};
+		} catch (error: any) {
+			const errorInfo = parseContractError(error);
+			if (errorInfo.isNetworkError) {
+				throw new Error(`Network error: ${errorInfo.message}`);
+			}
+			throw new Error(`Failed to set tag: ${errorInfo.message}`);
+		}
+	}
+
+	/**
+	 * Get Tag value
+	 * @param toDomain Target domain
+	 * @param tagName Tag name
+	 * @returns Tag value, or null if not found
+	 */
+	async getTag(toDomain: string, tagName: string): Promise<any | null> {
+		try {
+			const contract = this.console.getContractDID();
+
+			// Get tag type
+			const tagTypeInfo = await this.getTagType(tagName);
+			if (!tagTypeInfo) {
+				return null;
+			}
+
+			// Get encoded value
+			const encodedValue = await contract.getTagElem(
+				this.fromDomain,
+				toDomain,
+				tagName,
+				[]
+			);
+
+			// Parse type and decode
+			const abiType = TagTypeBuilder.parseTypeBytesToAbiString(
+				tagTypeInfo.abiType
+			);
+			return TagAbiCodec.decode(abiType, encodedValue);
+		} catch (error: any) {
+			const errorInfo = parseContractError(error);
+			if (
+				errorInfo.errorName === 'TagInvalidOp' ||
+				errorInfo.errorName === 'UndefinedTag'
+			) {
+				return null;
+			}
+			if (errorInfo.isNetworkError) {
+				throw new Error(`Network error: ${errorInfo.message}`);
+			}
+			throw error;
+		}
+	}
+
+	/**
+	 * Remove Tag
+	 * @param toDomain Target domain
+	 * @param tagName Tag name
+	 * @returns Transaction result
+	 */
+	async removeTag(
+		toDomain: string,
+		tagName: string
+	): Promise<TransactionResult> {
+		try {
+			const contract = this.console.getSignerContractDID();
+			const tx = await contract.removeTag(
+				this.fromDomain,
+				toDomain,
+				tagName
+			);
+			const receipt = await tx.wait();
+
+			return {
+				success: true,
+				transactionHash: receipt.hash,
+				gasUsed: receipt.gasUsed,
+				blockNumber: receipt.blockNumber
+			};
+		} catch (error: any) {
+			const errorInfo = parseContractError(error);
+			if (errorInfo.isNetworkError) {
+				throw new Error(`Network error: ${errorInfo.message}`);
+			}
+			throw new Error(`Failed to remove tag: ${errorInfo.message}`);
+		}
+	}
+
+	/**
+	 * Check if Tag exists
+	 * @param toDomain Target domain
+	 * @param tagName Tag name
+	 * @returns Whether the tag exists
+	 */
+	async hasTag(toDomain: string, tagName: string): Promise<boolean> {
+		const contract = this.console.getContractDID();
+		return await contract.hasTag(this.fromDomain, toDomain, tagName);
+	}
+
+	/**
+	 * Get all Tag names for the domain
+	 * @param toDomain Target domain
+	 * @returns Array of Tag names
+	 */
+	async getTagNames(toDomain: string): Promise<string[]> {
+		const contract = this.console.getContractDID();
+		const count = await contract.getTagCount(this.fromDomain, toDomain);
+		const names: string[] = [];
+
+		for (let i = 0; i < count; i++) {
+			const name = await contract.getTagNameByIndex(
+				this.fromDomain,
+				toDomain,
+				i
+			);
+			names.push(name);
+		}
+
+		return names;
+	}
+
+	/**
+	 * Get all Tags and their values for the domain
+	 * @param toDomain Target domain
+	 * @returns Array of Tags, each containing name and value
+	 */
+	async getAllTags(
+		toDomain: string
+	): Promise<Array<{ name: string; value: any }>> {
+		const names = await this.getTagNames(toDomain);
+		const result = [];
+
+		for (const name of names) {
+			const value = await this.getTag(toDomain, name);
+			result.push({ name, value });
+		}
+
+		return result;
+	}
+
+	// ========================================
+	// 3. Array Operations (Advanced Features)
+	// ========================================
+
+	/**
+	 * Add an element to an array Tag
+	 * @param toDomain Target domain
+	 * @param tagName Tag name
+	 * @param value Element value to add
+	 * @param elemPath Element path (for nested arrays), defaults to empty array
+	 * @returns Transaction result
+	 *
+	 * @example
+	 * // Add element to a 1D array
+	 * await tagCtx.pushElement('example.com', 'socialLinks', 'https://twitter.com/user');
+	 *
+	 * // Add element to the first sub-array of a 2D array
+	 * await tagCtx.pushElement('example.com', 'matrix', 'value', [0]);
+	 */
+	async pushElement(
+		toDomain: string,
+		tagName: string,
+		value: any,
+		elemPath: number[] = []
+	): Promise<TransactionResult> {
+		const contract = this.console.getSignerContractDID();
+
+		// Get tag type and encode element
+		const tagTypeInfo = await this.getTagType(tagName);
+		if (!tagTypeInfo) {
+			throw new Error(`Tag "${tagName}" is not defined`);
+		}
+
+		try {
+			// Parse type bytes to ABI string
+			const rootAbiType = TagTypeBuilder.parseTypeBytesToAbiString(
+				tagTypeInfo.abiType
+			);
+			// Get ELEMENT type (not root type!)
+			const elementAbiType = this.getElementAbiType(
+				rootAbiType,
+				elemPath
+			);
+			// Encode the SINGLE ELEMENT (not the whole array)
+			const encodedValue = TagAbiCodec.encode(elementAbiType, value);
+
+			const tx = await contract.pushTagElem(
+				this.fromDomain,
+				toDomain,
+				tagName,
+				elemPath,
+				encodedValue
+			);
+			const receipt = await tx.wait();
+
+			return {
+				success: true,
+				transactionHash: receipt.hash,
+				gasUsed: receipt.gasUsed,
+				blockNumber: receipt.blockNumber
+			};
+		} catch (error: any) {
+			const errorInfo = parseContractError(error);
+			if (errorInfo.isNetworkError) {
+				throw new Error(`Network error: ${errorInfo.message}`);
+			}
+			throw new Error(`Failed to push element: ${errorInfo.message}`);
+		}
+	}
+
+	/**
+	 * Remove the last element from an array Tag
+	 * @param toDomain Target domain
+	 * @param tagName Tag name
+	 * @param elemPath Element path, defaults to empty array
+	 * @returns Transaction result
+	 */
+	async popElement(
+		toDomain: string,
+		tagName: string,
+		elemPath: number[] = []
+	): Promise<TransactionResult> {
+		try {
+			const contract = this.console.getSignerContractDID();
+			const tx = await contract.popTagElem(
+				this.fromDomain,
+				toDomain,
+				tagName,
+				elemPath
+			);
+			const receipt = await tx.wait();
+
+			return {
+				success: true,
+				transactionHash: receipt.hash,
+				gasUsed: receipt.gasUsed,
+				blockNumber: receipt.blockNumber
+			};
+		} catch (error: any) {
+			const errorInfo = parseContractError(error);
+			if (errorInfo.isNetworkError) {
+				throw new Error(`Network error: ${errorInfo.message}`);
+			}
+			throw new Error(`Failed to pop element: ${errorInfo.message}`);
+		}
+	}
+
+	/**
+	 * Update a specific element in an array or tuple
+	 * @param toDomain Target domain
+	 * @param tagName Tag name
+	 * @param elemPath Element path (e.g., [0] for the first element)
+	 * @param value New value
+	 * @returns Transaction result
+	 *
+	 * @example
+	 * // Update the first element of an array
+	 * await tagCtx.updateElement('example.com', 'links', [0], 'https://new-url.com');
+	 *
+	 * // Update an element in a 2D array
+	 * await tagCtx.updateElement('example.com', 'matrix', [0, 1], 'value');
+	 */
+	async updateElement(
+		toDomain: string,
+		tagName: string,
+		elemPath: number[],
+		value: any
+	): Promise<TransactionResult> {
+		const contract = this.console.getSignerContractDID();
+
+		const tagTypeInfo = await this.getTagType(tagName);
+		if (!tagTypeInfo) {
+			throw new Error(`Tag "${tagName}" is not defined`);
+		}
+
+		try {
+			// Parse type bytes to ABI string
+			const rootAbiType = TagTypeBuilder.parseTypeBytesToAbiString(
+				tagTypeInfo.abiType
+			);
+			// Get element type
+			const elementAbiType = this.getElementAbiType(
+				rootAbiType,
+				elemPath
+			);
+			// Encode the element value
+			const encodedValue = TagAbiCodec.encode(elementAbiType, value);
+
+			const tx = await contract.updateTagElem(
+				this.fromDomain,
+				toDomain,
+				tagName,
+				elemPath,
+				encodedValue
+			);
+			const receipt = await tx.wait();
+
+			return {
+				success: true,
+				transactionHash: receipt.hash,
+				gasUsed: receipt.gasUsed,
+				blockNumber: receipt.blockNumber
+			};
+		} catch (error: any) {
+			const errorInfo = parseContractError(error);
+			if (errorInfo.isNetworkError) {
+				throw new Error(`Network error: ${errorInfo.message}`);
+			}
+			throw new Error(`Failed to update element: ${errorInfo.message}`);
+		}
+	}
+
+	/**
+	 * Get the length of an array Tag
+	 * @param toDomain Target domain
+	 * @param tagName Tag name
+	 * @param elemPath Element path, defaults to empty array
+	 * @returns Array length
+	 */
+	async getArrayLength(
+		toDomain: string,
+		tagName: string,
+		elemPath: number[] = []
+	): Promise<number> {
+		const contract = this.console.getContractDID();
+		const length = await contract.getTagElemLength(
+			this.fromDomain,
+			toDomain,
+			tagName,
+			elemPath
+		);
+		return Number(length);
+	}
+
+	/**
+	 * Get a specific element from an array or tuple
+	 * @param toDomain Target domain
+	 * @param tagName Tag name
+	 * @param elemPath Element path
+	 * @returns Element value, or null if not found
+	 *
+	 * @example
+	 * // Get the first element of an array
+	 * const first = await tagCtx.getElement('example.com', 'links', [0]);
+	 *
+	 * // Get an element from a 2D array
+	 * const value = await tagCtx.getElement('example.com', 'matrix', [0, 1]);
+	 */
+	async getElement(
+		toDomain: string,
+		tagName: string,
+		elemPath: number[]
+	): Promise<any | null> {
+		try {
+			const contract = this.console.getContractDID();
+
+			const encodedValue = await contract.getTagElem(
+				this.fromDomain,
+				toDomain,
+				tagName,
+				elemPath
+			);
+
+			// Get tag type and decode element value
+			const tagTypeInfo = await this.getTagType(tagName);
+			if (!tagTypeInfo) {
+				return null;
+			}
+
+			// Parse type bytes to ABI string
+			const rootAbiType = TagTypeBuilder.parseTypeBytesToAbiString(
+				tagTypeInfo.abiType
+			);
+			// Get element type
+			const elementAbiType = this.getElementAbiType(
+				rootAbiType,
+				elemPath
+			);
+			// Decode the element
+			return TagAbiCodec.decode(elementAbiType, encodedValue);
+		} catch (error: any) {
+			const errorInfo = parseContractError(error);
+			if (errorInfo.errorName === 'TagInvalidOp') {
+				return null;
+			}
+			if (errorInfo.isNetworkError) {
+				throw new Error(`Network error: ${errorInfo.message}`);
+			}
+			throw error;
+		}
+	}
+
+	// ========================================
+	// Helper Methods (Private)
+	// ========================================
+
+	/**
+	 * Get element ABI type based on path
+	 * Example: string[][] + [0] = string[]
+	 *         string[][] + [0, 0] = string
+	 *
+	 * Special case: For pushElement/popElement on array type with empty path,
+	 * we want the element type:
+	 * Example: string[] + [] → string (for push operation)
+	 */
+	private getElementAbiType(abiType: string, elemPath: number[]): string {
+		let currentType = abiType;
+
+		// If elemPath is empty and currentType is an array,
+		// return the element type (for push/pop operations)
+		if (elemPath.length === 0) {
+			const arrayMatch = currentType.match(/^(.+?)\[(\d*)\]$/);
+			if (arrayMatch) {
+				return arrayMatch[1]; // Return element type
+			}
+			// Not an array, return as-is
+			return currentType;
+		}
+
+		// Process each level of the path
+		for (const _index of elemPath) {
+			// Parse ABI type string
+			// Handle array types: type[] or type[N]
+			const arrayMatch = currentType.match(/^(.+?)\[(\d*)\]$/);
+
+			if (arrayMatch) {
+				// Array type, element type is the base type
+				currentType = arrayMatch[1];
+			} else if (currentType.startsWith('tuple(')) {
+				// Tuple type - not supported for element access by index
+				throw new Error(
+					'Tuple element access by index not supported yet. Use field names instead.'
+				);
+			} else {
+				throw new Error(
+					`Cannot access element of non-array type "${currentType}" at path ${elemPath}`
+				);
+			}
+		}
+
+		return currentType;
+	}
+}