@beclab/olaresid 0.1.13 → 0.2.1

package/src/config/index.ts

@@ -1,13 +1,15 @@
 import * as fs from 'fs';
 import * as path from 'path';
+import configData from '../../config.json';
 
 export interface NetworkConfig {
 	rpc: string;
 	contractDid: string;
 	contractRootResolver: string;
 	contractAbiType: string;
-	contractRootResolver2: string;
-	supportSvcUrl: string;
+	contractRootResolver2?: string;
+	supportSvcUrl?: string;
+	queryContract?: string;
 }
 
 export interface ConfigData {
@@ -16,34 +18,31 @@ export interface ConfigData {
 	};
 }
 
-// Configuration file path - in the project directory
-const CONFIG_FILE = path.join(__dirname, '../../config.json');
+export interface ContractConfig {
+	contractDid: string;
+	contractRootResolver: string;
+	contractAbiType: string;
+	contractRootResolver2?: string;
+}
 
 /**
- * Load configuration from file
+ * Load configuration from imported JSON
+ * Works in both Node.js and browser environments
  */
 export function loadConfig(): ConfigData {
-	try {
-		const data = fs.readFileSync(CONFIG_FILE, 'utf-8');
-		return JSON.parse(data);
-	} catch (error) {
-		throw new Error(
-			`Failed to load config from ${CONFIG_FILE}: ${
-				error instanceof Error ? error.message : String(error)
-			}`
-		);
-	}
+	return configData;
 }
 
 /**
- * Save configuration to file
+ * Save configuration to file (Node.js only)
  */
 export function saveConfig(config: ConfigData): void {
 	try {
-		fs.writeFileSync(CONFIG_FILE, JSON.stringify(config, null, 2));
+		const configPath = path.join(__dirname, '../../config.json');
+		fs.writeFileSync(configPath, JSON.stringify(config, null, 4));
 	} catch (error) {
 		throw new Error(
-			`Failed to save config to ${CONFIG_FILE}: ${
+			`Failed to save config: ${
 				error instanceof Error ? error.message : String(error)
 			}`
 		);
@@ -70,5 +69,21 @@ export function getAvailableNetworks(): string[] {
  * Get configuration file path
  */
 export function getConfigFilePath(): string {
-	return CONFIG_FILE;
+	return path.join(__dirname, '../../config.json');
+}
+
+/**
+ * Get contract configuration for a specific network
+ */
+export function getContractConfig(network: string): ContractConfig | undefined {
+	const networkConfig = getNetworkConfig(network);
+	if (!networkConfig) {
+		return undefined;
+	}
+	return {
+		contractDid: networkConfig.contractDid,
+		contractRootResolver: networkConfig.contractRootResolver,
+		contractAbiType: networkConfig.contractAbiType,
+		contractRootResolver2: networkConfig.contractRootResolver2
+	};
 }

package/src/domain/core.ts

@@ -0,0 +1,382 @@
+import { ethers, AbiCoder } from 'ethers';
+import QUERY_CONTRACT_ABI from '../abi/TerminusDIDQueryABI';
+import { RawDomainData, RawTagData, FlatDomainData, Tag } from './types';
+import { TagTypeParser } from '../utils/tag-type-parser';
+import { parseContractError } from '../utils/error-parser';
+import { getFullyQualifiedVerificationMethodID } from '../utils/crypto-utils';
+
+// ============================================================================
+// Query Contract Helper
+// ============================================================================
+
+/**
+ * Helper class for interacting with TerminusDIDQuery contract
+ */
+export class QueryContractHelper {
+	private contract: ethers.Contract;
+
+	constructor(queryContractAddress: string, provider: ethers.Provider) {
+		this.contract = new ethers.Contract(
+			queryContractAddress,
+			QUERY_CONTRACT_ABI,
+			provider
+		);
+	}
+
+	/**
+	 * Get total supply of domains
+	 */
+	async getTotalSupply(): Promise<number> {
+		try {
+			const supply = await this.contract.totalSupply();
+			return Number(supply);
+		} catch (error) {
+			const parsedError = parseContractError(error);
+			console.error('[core] getTotalSupply failed:', parsedError.message);
+			throw new Error(parsedError.message);
+		}
+	}
+
+	/**
+	 * Get token ID by index
+	 */
+	async getTokenByIndex(index: number): Promise<bigint> {
+		try {
+			return await this.contract.tokenByIndex(index);
+		} catch (error) {
+			const parsedError = parseContractError(error);
+			console.error(
+				'[core] getTokenByIndex failed:',
+				parsedError.message
+			);
+			throw new Error(parsedError.message);
+		}
+	}
+
+	/**
+	 * Get single domain data by token ID or domain name
+	 * Automatically detects if input is tokenId (starts with 0x or is bigint) or domain name
+	 */
+	async getDomain(
+		nameOrTokenId: string | bigint
+	): Promise<RawDomainData | null> {
+		try {
+			let data: any;
+
+			// Check if it's a tokenId (hex string or bigint)
+			if (
+				typeof nameOrTokenId === 'bigint' ||
+				(typeof nameOrTokenId === 'string' &&
+					nameOrTokenId.startsWith('0x'))
+			) {
+				data = await this.contract.getDomain(nameOrTokenId);
+			} else {
+				// It's a domain name
+				data = await this.contract.getDomainByName(nameOrTokenId);
+			}
+
+			return this._convertDomainData(data);
+		} catch (error) {
+			const parsedError = parseContractError(error);
+			console.error('[core] getDomain failed:', parsedError.message);
+			throw new Error(parsedError.message);
+		}
+	}
+
+	/**
+	 * Get multiple domains data by token IDs
+	 */
+	async getDomains(tokenIds: (string | bigint)[]): Promise<RawDomainData[]> {
+		try {
+			const data = await this.contract.getDomains(tokenIds);
+			return data.map((d: any) => this._convertDomainData(d));
+		} catch (error) {
+			const parsedError = parseContractError(error);
+			console.error('[core] getDomains failed:', parsedError.message);
+			throw new Error(parsedError.message);
+		}
+	}
+
+	/**
+	 * Get all domains with pagination
+	 */
+	async getAllDomains(
+		offset: number,
+		limit: number
+	): Promise<RawDomainData[]> {
+		try {
+			const data = await this.contract.getAllDomains(offset, limit);
+			return data.map((d: any) => this._convertDomainData(d));
+		} catch (error) {
+			const parsedError = parseContractError(error);
+			console.error('[core] getAllDomains failed:', parsedError.message);
+			throw new Error(parsedError.message);
+		}
+	}
+
+	/**
+	 * Get domains by specific indices (single RPC call)
+	 */
+	async getDomainsByIndices(indices: number[]): Promise<RawDomainData[]> {
+		try {
+			const data = await this.contract.getDomainsByIndices(indices);
+			return data.map((d: any) => this._convertDomainData(d));
+		} catch (error) {
+			const parsedError = parseContractError(error);
+			console.error(
+				'[core] getDomainsByIndices failed:',
+				parsedError.message
+			);
+			throw new Error(parsedError.message);
+		}
+	}
+
+	/**
+	 * Convert contract response to RawDomainData
+	 */
+	private _convertDomainData(data: any): RawDomainData {
+		return {
+			tokenId: data.tokenId,
+			domain: data.domain,
+			did: data.did,
+			notes: data.notes,
+			allowSubdomain: data.allowSubdomain,
+			owner: data.owner,
+			tags: data.tags.map((tag: any) => ({
+				from: tag.from,
+				name: tag.name,
+				// ethers v6 returns bytes fields as Uint8Array; normalize to hex string
+				abiType: ethers.hexlify(tag.abiType ?? '0x'),
+				value: ethers.hexlify(tag.value ?? '0x'),
+				fieldNamesHash: tag.fieldNamesHash
+			}))
+		};
+	}
+}
+
+// ============================================================================
+// Field Names Fetching
+// ============================================================================
+
+/**
+ * Collect all unique field name hashes from raw domains
+ */
+export function collectFieldNameHashes(rawDomains: RawDomainData[]): string[] {
+	const hashSet = new Set<string>();
+
+	for (const domain of rawDomains) {
+		for (const tag of domain.tags) {
+			for (const hash of tag.fieldNamesHash) {
+				if (
+					hash &&
+					hash !==
+						'0x0000000000000000000000000000000000000000000000000000000000000000'
+				) {
+					hashSet.add(hash);
+				}
+			}
+		}
+	}
+
+	return Array.from(hashSet);
+}
+
+/**
+ * Batch fetch field names from blockchain events
+ * Groups queries by block number to minimize RPC calls
+ */
+export async function batchFetchFieldNames(
+	contract: ethers.Contract,
+	hashes: string[]
+): Promise<Map<string, string[]>> {
+	const fieldNamesMap = new Map<string, string[]>();
+
+	if (hashes.length === 0) {
+		return fieldNamesMap;
+	}
+
+	// Step 1: Batch get block numbers for all hashes
+	const hashToBlock = new Map<string, number>();
+	for (const hash of hashes) {
+		try {
+			const blockNum = await contract.getFieldNamesEventBlock(hash);
+			hashToBlock.set(hash, Number(blockNum));
+		} catch (error) {
+			console.error(
+				`[core] failed to get block number for field name hash ${hash}:`,
+				error instanceof Error ? error.message : String(error)
+			);
+			throw error;
+		}
+	}
+
+	// Step 2: Group hashes by block number
+	const blockToHashes = new Map<number, string[]>();
+	for (const [hash, blockNum] of hashToBlock.entries()) {
+		if (!blockToHashes.has(blockNum)) {
+			blockToHashes.set(blockNum, []);
+		}
+		blockToHashes.get(blockNum)!.push(hash);
+	}
+
+	// Step 3: Batch query events by block
+	for (const [blockNum, hashesInBlock] of blockToHashes.entries()) {
+		try {
+			const events = await contract.queryFilter(
+				'OffchainStringArray',
+				blockNum,
+				blockNum
+			);
+
+			for (const event of events) {
+				const eventHash = (event as any).args.hash;
+				if (hashesInBlock.includes(eventHash)) {
+					fieldNamesMap.set(eventHash, (event as any).args.value);
+				}
+			}
+		} catch (error) {
+			console.error(
+				`[core] failed to query events at block ${blockNum} for ${hashesInBlock.length} hashes:`,
+				error instanceof Error ? error.message : String(error)
+			);
+			throw error;
+		}
+	}
+
+	return fieldNamesMap;
+}
+
+// ============================================================================
+// Domain Parsing
+// ============================================================================
+
+/**
+ * Parse a single raw domain into flat domain data
+ */
+export function parseDomain(
+	rawDomain: RawDomainData,
+	fieldNamesMap: Map<string, string[]>
+): FlatDomainData {
+	const abiCoder = new AbiCoder();
+
+	const domain: FlatDomainData = {
+		id: ethers.toBeHex(rawDomain.tokenId, 32),
+		name: rawDomain.domain,
+		did: rawDomain.did,
+		note: rawDomain.notes,
+		allowSubdomain: rawDomain.allowSubdomain,
+		owner: ethers.getAddress(rawDomain.owner),
+		level: calculateLevel(rawDomain.domain),
+		tags: []
+	};
+
+	// Parse tags
+	for (const rawTag of rawDomain.tags) {
+		try {
+			const tag = TagTypeParser.parseTag(rawTag, fieldNamesMap, abiCoder);
+			domain.tags.push(tag);
+		} catch (error) {
+			console.error(`[core] failed to parse tag ${rawTag.name}:`, error);
+			throw error;
+		}
+	}
+
+	applyLatestDID(domain);
+
+	return domain;
+}
+
+/**
+ * Parse all raw domains into flat domain data
+ * Also calculates parentId for each domain
+ */
+export function parseAllDomains(
+	rawDomains: RawDomainData[],
+	fieldNamesMap: Map<string, string[]>
+): FlatDomainData[] {
+	const abiCoder = new AbiCoder();
+
+	// Step 1: Create all domain objects
+	const domainMap = new Map<string, FlatDomainData>();
+
+	for (const rawDomain of rawDomains) {
+		const domain: FlatDomainData = {
+			id: ethers.toBeHex(rawDomain.tokenId, 32),
+			name: rawDomain.domain,
+			did: rawDomain.did,
+			note: rawDomain.notes,
+			allowSubdomain: rawDomain.allowSubdomain,
+			owner: ethers.getAddress(rawDomain.owner),
+			level: calculateLevel(rawDomain.domain),
+			tags: []
+		};
+
+		// Parse tags
+		for (const rawTag of rawDomain.tags) {
+			try {
+				const tag = TagTypeParser.parseTag(
+					rawTag,
+					fieldNamesMap,
+					abiCoder
+				);
+				domain.tags.push(tag);
+			} catch (error) {
+				console.error(
+					`[core] failed to parse tag ${rawTag.name}:`,
+					error
+				);
+				throw error;
+			}
+		}
+
+		applyLatestDID(domain);
+
+		domainMap.set(domain.name, domain);
+	}
+
+	// Step 2: Calculate parentId
+	const flatDomains: FlatDomainData[] = [];
+	for (const domain of domainMap.values()) {
+		if (domain.level > 1) {
+			const parentName = getParentDomainName(domain.name);
+			const parent = domainMap.get(parentName);
+			if (parent) {
+				domain.parentId = parent.id;
+			}
+		}
+		flatDomains.push(domain);
+	}
+
+	return flatDomains;
+}
+
+// ============================================================================
+// Utility Functions
+// ============================================================================
+
+/**
+ * If a domain has a latestDID tag with a non-empty valueFormatted, override did with it
+ */
+function applyLatestDID(domain: FlatDomainData): void {
+	const latestDIDTag = domain.tags.find((t) => t.name === 'latestDID');
+	if (latestDIDTag?.valueFormatted) {
+		domain.did = getFullyQualifiedVerificationMethodID(
+			latestDIDTag.valueFormatted
+		);
+	}
+}
+
+/**
+ * Calculate domain level (number of dots + 1)
+ */
+export function calculateLevel(domainName: string): number {
+	return domainName.split('.').length;
+}
+
+/**
+ * Get parent domain name
+ */
+export function getParentDomainName(domainName: string): string {
+	const parts = domainName.split('.');
+	return parts.slice(1).join('.');
+}