@beclab/olaresid 0.1.13 → 0.2.0

package/src/domain/types.ts

@@ -0,0 +1,59 @@
+/**
+ * Tag data structure
+ */
+export interface Tag {
+	from: string;
+	name: string;
+	abiType: string; // ABI type string (e.g., "tuple(string,uint8)")
+	value: string; // bytes (hex string) - raw encoded value
+	fieldNamesHash: string[]; // bytes32[] (hex strings)
+	valueFormatted?: string | null; // Decoded value; objects/arrays are JSON.stringify'd; null if tag has no value
+}
+
+/**
+ * Flattened domain data structure
+ */
+export interface FlatDomainData {
+	id: string; // tokenId (hex)
+	name: string;
+	did: string;
+	note: string;
+	allowSubdomain: boolean;
+	owner: string;
+	parentId?: string; // ⭐ New: parent domain ID
+	level: number; // ⭐ New: level (1=top-level, 2=second-level...)
+	tags: Tag[];
+}
+
+/**
+ * Raw domain data returned by contract
+ */
+export interface RawDomainData {
+	tokenId: bigint;
+	domain: string;
+	did: string;
+	notes: string;
+	allowSubdomain: boolean;
+	owner: string;
+	tags: RawTagData[];
+}
+
+/**
+ * Raw Tag data returned by contract
+ */
+export interface RawTagData {
+	from: string;
+	name: string;
+	abiType: string; // bytes (hex string)
+	value: string; // bytes (hex string)
+	fieldNamesHash: string[]; // bytes32[] (hex strings)
+}
+
+/**
+ * fetchAll options
+ */
+export interface FetchAllOptions {
+	queryContractAddress?: string;
+	batchSize?: number; // Number of domains to fetch per batch, default 100
+	onProgress?: (current: number, total: number) => void;
+}

package/src/index.ts

@@ -1,21 +1,21 @@
-import { PackageDomain } from './domain/index';
-import DIDTag from './tag/index';
 import { ethers } from 'ethers';
 import DID_ABI from './abi/TerminusDIDABI';
 import RootResolverABI from './abi/RootResolverABI';
 import RootResolver2ABI from './abi/RootResolver2ABI';
-import { debug } from './debug';
 import { parseContractError } from './utils/error-parser';
-import { normalizeToDomain } from './utils/olares-id';
 
 import { DomainContext, TransactionResult } from './business';
 
-// Import Tag utilities
-import { TagTypeBuilder } from './utils/tag-type-builder';
-import { TagAbiCodec } from './utils/tag-abi-codec';
-
 // Import config utilities
-import { getNetworkConfig, getAvailableNetworks } from './config';
+import { getNetworkConfig } from './config';
+
+// Import domain functions
+import {
+	fetchDomain,
+	fetchDomains,
+	fetchDomainsByIndices,
+	fetchAllFlat
+} from './domain/index';
 
 export type {
 	DomainInfo,
@@ -45,23 +45,17 @@ export {
 	getEd25519JwkFromMnemonic
 } from './business';
 
-type Domain = PackageDomain.Domain;
-
-type StoreDomain = PackageDomain.DomainData;
-
-export class DIDConsole implements DIDTag.ABITypeProviderHolder {
+export class DIDConsole {
 	rpcNode: string;
 	contractDid: string;
 	contractRootResolver: string;
 	contractAbiType: string;
 	contractRootResolver2?: string;
 	supportSvcUrl?: string;
+	queryContractAddress?: string; // New: query contract address
 
 	signer?: ethers.Signer;
 
-	allDomainCache: Domain[] = [];
-	treesCache: Domain[] = [];
-
 	// caching contract instances
 	private _contractDID?: ethers.Contract;
 	private _signerContractDID?: ethers.Contract;
@@ -78,7 +72,8 @@ export class DIDConsole implements DIDTag.ABITypeProviderHolder {
 		contractRootResolver: string,
 		contractAbiType: string,
 		contractRootResolver2?: string,
-		supportSvcUrl?: string
+		supportSvcUrl?: string,
+		queryContractAddress?: string
 	) {
 		this.rpcNode = rpcNode;
 		this.contractDid = contractDid;
@@ -86,6 +81,7 @@ export class DIDConsole implements DIDTag.ABITypeProviderHolder {
 		this.contractAbiType = contractAbiType;
 		this.contractRootResolver2 = contractRootResolver2;
 		this.supportSvcUrl = supportSvcUrl;
+		this.queryContractAddress = queryContractAddress;
 	}
 
 	getProvider = (): ethers.JsonRpcProvider => {
@@ -247,193 +243,98 @@ export class DIDConsole implements DIDTag.ABITypeProviderHolder {
 			await provider.getSigner()
 		);
 
-	fetchAll = () =>
-		new Promise<Domain[]>(async (resolve, reject) => {
-			debug.group('fetchAll');
-			const contract = await this.getContractDID();
-			const size = await contract.totalSupply();
-			debug.info('fetchAll--->domain size', size);
-
-			let arr: Domain[] = [];
-			for (let index = 0; index < size; index++) {
-				const domain = await PackageDomain.syncByIndex(index, contract);
-				debug.debug('fetchAll--->synced domain', domain);
-				debug.info(
-					`fetchAll--->${((index / parseInt(size)) * 100).toFixed(
-						0
-					)}%`
-				);
-				arr.push(domain);
-			}
-			this.allDomainCache = arr;
-			this.treesCache = PackageDomain.buildTree(this.allDomainCache);
-
-			debug.groupEnd();
-			resolve(this.treesCache);
-		});
-
-	fetchDomain = (name: string) =>
-		new Promise<Domain | undefined>(async (resolve, reject) => {
-			// Support Olares ID format (user@domain.com)
-			const normalizedName = normalizeToDomain(name);
-
-			debug.group('fetchDomain');
-			const hasCache = this.allDomainCache.length > 0;
-			debug.info('fetchDomain--->hasCache', hasCache);
-
-			if (hasCache) {
-				const domain = PackageDomain.findASubtree(
-					normalizedName,
-					this.allDomainCache
-				);
-
-				debug.groupEnd();
-				resolve(domain);
-			} else {
-				const domain = await PackageDomain.syncByName(
-					normalizedName,
-					await this.getContractDID()
-				);
-
-				debug.groupEnd();
-				resolve(domain);
-			}
-		});
-
-	updateDomain = (name: string) =>
-		new Promise<Domain>(async (resolve, reject) => {
-			// Support Olares ID format (user@domain.com)
-			const normalizedName = normalizeToDomain(name);
-
-			const domain = await PackageDomain.syncByName(
-				normalizedName,
-				await this.getContractDID()
-			);
-
-			if (domain == undefined) {
-				reject('not found domain');
-				return;
-			}
-
-			const [oldDomain] = this.allDomainCache.filter(
-				(d) => d.name == domain.name
-			);
-
-			if (oldDomain != undefined) {
-				for (const tagNew of domain.tags) {
-					for (const tagOld of oldDomain.tags) {
-						if (tagNew.name == tagOld.name) {
-							if (
-								tagNew.valueFormated == undefined &&
-								tagOld.valueFormated != undefined
-							) {
-								tagNew.valueFormated = tagOld.valueFormated;
-							}
-							if (
-								tagNew.valueSource == undefined &&
-								tagOld.valueSource != undefined
-							) {
-								tagNew.valueSource = tagOld.valueSource;
-							}
-							if (
-								tagNew.definition == undefined &&
-								tagOld.definition != undefined
-							) {
-								tagNew.definition = tagOld.definition;
-							}
-						}
-					}
-				}
-			}
-
-			this.allDomainCache = this.allDomainCache.filter(
-				(d) => d.name != domain.name
+	/**
+	 * Fetch a single domain by name or tokenId
+	 * Uses the query contract configured for this network
+	 *
+	 * @param nameOrTokenId - Domain name or tokenId
+	 * @returns Domain data or null if not found
+	 *
+	 * @example
+	 * const domain = await console.fetchDomain("alice.olares.com");
+	 */
+	async fetchDomain(nameOrTokenId: string | bigint) {
+		if (!this.queryContractAddress) {
+			throw new Error(
+				'Query contract address not configured for this network'
 			);
-			this.allDomainCache.push(domain);
-
-			this.treesCache = PackageDomain.buildTree(this.allDomainCache);
-
-			resolve(domain);
+		}
+		return fetchDomain(this, nameOrTokenId, {
+			queryContractAddress: this.queryContractAddress
 		});
+	}
 
-	updateDomainById = (id: string) =>
-		new Promise<Domain>(async (resolve, reject) => {
-			const domain = await PackageDomain.syncById(
-				id,
-				await this.getContractDID()
-			);
-
-			if (domain == undefined) {
-				reject('not found domain');
-				return;
-			}
-
-			const [oldDomain] = this.allDomainCache.filter(
-				(d) => d.name == domain.name
-			);
-			for (const tagNew of domain.tags) {
-				for (const tagOld of oldDomain.tags) {
-					if (tagNew.name == tagOld.name) {
-						if (
-							tagNew.valueFormated == undefined &&
-							tagOld.valueFormated != undefined
-						) {
-							tagNew.valueFormated = tagOld.valueFormated;
-						}
-						if (
-							tagNew.valueSource == undefined &&
-							tagOld.valueSource != undefined
-						) {
-							tagNew.valueSource = tagOld.valueSource;
-						}
-						if (
-							tagNew.definition == undefined &&
-							tagOld.definition != undefined
-						) {
-							tagNew.definition = tagOld.definition;
-						}
-					}
-				}
-			}
-
-			this.allDomainCache = this.allDomainCache.filter(
-				(d) => d.name != domain.name
+	/**
+	 * Fetch multiple domains with pagination
+	 *
+	 * @param offset - Starting index
+	 * @param limit - Number of domains to fetch
+	 * @returns Array of domains in the specified range
+	 *
+	 * @example
+	 * const domains = await console.fetchDomains(0, 10);
+	 */
+	async fetchDomains(offset: number, limit: number) {
+		if (!this.queryContractAddress) {
+			throw new Error(
+				'Query contract address not configured for this network'
 			);
-			this.allDomainCache.push(domain);
-
-			this.treesCache = PackageDomain.buildTree(this.allDomainCache);
-
-			resolve(domain);
-		});
-
-	formatData = (doamin: Domain) =>
-		new Promise<StoreDomain>((resolve, reject) => {
-			resolve(doamin);
-		});
-
-	formatDatas = (doamins: Domain[]) =>
-		new Promise<StoreDomain[]>((resolve, reject) => {
-			resolve(doamins);
+		}
+		return fetchDomains(this, {
+			offset,
+			limit,
+			queryContractAddress: this.queryContractAddress
 		});
+	}
 
-	loadData = (data: StoreDomain) =>
-		new Promise<Domain>((resolve, reject) => {
-			resolve(data);
+	/**
+	 * Fetch all domains with flat structure
+	 *
+	 * @param options - Additional options (batchSize, onProgress)
+	 * @returns Array of all domains
+	 *
+	 * @example
+	 * const domains = await console.fetchAllFlat({
+	 *   batchSize: 100,
+	 *   onProgress: (current, total) => console.log(`${current}/${total}`)
+	 * });
+	 */
+	async fetchAllFlat(
+		options: {
+			batchSize?: number;
+			onProgress?: (current: number, total: number) => void;
+		} = {}
+	) {
+		if (!this.queryContractAddress) {
+			throw new Error(
+				'Query contract address not configured for this network'
+			);
+		}
+		return fetchAllFlat(this, {
+			queryContractAddress: this.queryContractAddress,
+			...options
 		});
+	}
 
-	loadDatas = (datas: StoreDomain[]) =>
-		new Promise<Domain[]>((resolve, reject) => {
-			this.treesCache = datas;
-			let arr = [];
-			arr.push(...this.treesCache);
-			for (const StoreDomain of this.treesCache) {
-				arr.push(...PackageDomain.getAllSubdoamin(StoreDomain));
-			}
-
-			this.allDomainCache = arr;
-
-			resolve(datas);
+	/**
+	 * Fetch multiple domains by their indices
+	 *
+	 * @param indices - Array of domain indices (e.g., [5, 6, 9, 10])
+	 * @returns Array of domains corresponding to the specified indices
+	 *
+	 * @example
+	 * const domains = await console.fetchDomainsByIndices([5, 6, 9, 10]);
+	 */
+	async fetchDomainsByIndices(indices: number[]) {
+		if (!this.queryContractAddress) {
+			throw new Error(
+				'Query contract address not configured for this network'
+			);
+		}
+		return fetchDomainsByIndices(this, indices, {
+			queryContractAddress: this.queryContractAddress
 		});
+	}
 
 	/**
 	 * Uses a chain-style operation design pattern, returning the operation context for the specified domain
@@ -596,7 +497,8 @@ namespace OlaresID {
 		contractRootResolver: string,
 		contractAbiType: string,
 		contractRootResolver2?: string,
-		supportSvcUrl?: string
+		supportSvcUrl?: string,
+		queryContractAddress?: string
 	): DIDConsole => {
 		return new DIDConsole(
 			rpcNode,
@@ -604,14 +506,15 @@ namespace OlaresID {
 			contractRootResolver,
 			contractAbiType,
 			contractRootResolver2,
-			supportSvcUrl
+			supportSvcUrl,
+			queryContractAddress
 		);
 	};
 
 	export const createMainnet = (): DIDConsole => {
 		const config = getNetworkConfig('mainnet');
 		if (!config) {
-			throw new Error('Mainnet configuration not found in config.json');
+			throw new Error('Mainnet configuration not found');
 		}
 
 		return createConsole(
@@ -620,14 +523,15 @@ namespace OlaresID {
 			config.contractRootResolver,
 			config.contractAbiType,
 			config.contractRootResolver2,
-			config.supportSvcUrl
+			config.supportSvcUrl,
+			config.queryContract
 		);
 	};
 
 	export const createTestnet = (): DIDConsole => {
 		const config = getNetworkConfig('sepolia');
 		if (!config) {
-			throw new Error('Sepolia configuration not found in config.json');
+			throw new Error('Sepolia configuration not found');
 		}
 
 		return createConsole(
@@ -636,15 +540,46 @@ namespace OlaresID {
 			config.contractRootResolver,
 			config.contractAbiType,
 			config.contractRootResolver2,
-			config.supportSvcUrl
+			config.supportSvcUrl,
+			config.queryContract
 		);
 	};
 
-	export import Domain = PackageDomain;
+	/**
+	 * Create a DIDConsole instance with custom RPC endpoint
+	 * Contract addresses are loaded from configuration based on network type
+	 *
+	 * @param rpc - Custom RPC endpoint URL
+	 * @param network - Network type: 'mainnet' or 'sepolia' (default: 'mainnet')
+	 * @returns DIDConsole instance
+	 *
+	 * @example
+	 * // Create mainnet instance with custom RPC
+	 * const console = OlaresID.createWithRpc('https://my-optimism-rpc.com');
+	 *
+	 * // Create sepolia instance with custom RPC
+	 * const console = OlaresID.createWithRpc('https://my-sepolia-rpc.com', 'sepolia');
+	 */
+	export const createWithRpc = (
+		rpc: string,
+		network: 'mainnet' | 'sepolia' = 'mainnet'
+	): DIDConsole => {
+		const config = getNetworkConfig(network);
 
-	export import Tag = DIDTag;
+		if (!config) {
+			throw new Error(`${network} configuration not found`);
+		}
 
-	export type StoreDomain = PackageDomain.DomainData;
+		return createConsole(
+			rpc, // Use custom RPC
+			config.contractDid,
+			config.contractRootResolver,
+			config.contractAbiType,
+			config.contractRootResolver2,
+			config.supportSvcUrl,
+			config.queryContract
+		);
+	};
 
 	export const ABI_DID = DID_ABI;
 
@@ -653,10 +588,89 @@ namespace OlaresID {
 
 export { debug } from './debug';
 
-// Export Tag utilities outside namespace
-export { TagTypeBuilder, TagAbiCodec };
+// Export Tag utilities
+export { TagTypeBuilder } from './utils/tag-type-builder';
+export { TagTypeParser } from './utils/tag-type-parser';
 
 // Export Olares ID utilities
 export { normalizeToDomain, normalizeToOlaresId } from './utils/olares-id';
 
+// Export event parser
+export { parseEvents } from './utils/event-parser';
+export type {
+	EthLog,
+	AnyParsedEvent,
+	ParsedEvent,
+	TerminusDIDEventName,
+	TerminusDIDEventArgsMap,
+	TransferArgs,
+	ApprovalArgs,
+	ApprovalForAllArgs,
+	InitializedArgs,
+	NewTagTypeArgs,
+	OffchainStringArrayArgs,
+	OwnershipTransferStartedArgs,
+	OwnershipTransferredArgs,
+	TagAddedArgs,
+	TagElemPoppedArgs,
+	TagElemPushedArgs,
+	TagElemUpdatedArgs,
+	TagRemovedArgs,
+	TransferByParentOwnerArgs,
+	TransferBySuperAdminArgs,
+	UpgradedArgs
+} from './utils/event-parser';
+export {
+	isTransferEvent,
+	isMintEvent,
+	isTagAddedEvent,
+	isTagRemovedEvent,
+	isTagElemUpdatedEvent,
+	isTagElemPushedEvent,
+	isTagElemPoppedEvent,
+	isNewTagTypeEvent
+} from './utils/event-parser';
+
+// Export new domain fetching functions and utilities
+export { QueryContractHelper } from './domain/core';
+export {
+	fetchDomain,
+	fetchDomains,
+	fetchDomainsByIndices,
+	fetchAllFlat,
+	FetchDomainOptions,
+	FetchDomainsOptions,
+	FetchDomainsByIndicesOptions
+} from './domain/index';
+export type {
+	Tag,
+	FlatDomainData,
+	RawDomainData,
+	RawTagData,
+	FetchAllOptions
+} from './domain/types';
+
+// Export config utilities
+export { getContractConfig } from './config';
+export type { ContractConfig } from './config';
+
+// Export DID utilities
+export type {
+	PublicJwk,
+	PrivateJwk,
+	VerificationMethod,
+	DIDDocument,
+	Service
+} from './utils/crypto-utils';
+export {
+	LDKeyType,
+	getPublicJWKFromX,
+	getPublicJWKFromDID,
+	getPrivateJWKFromD,
+	getIDFromEd25519Pubkey,
+	getPrivateJWKFromEd25519,
+	getFullyQualifiedVerificationMethodID,
+	resolveDID
+} from './utils/crypto-utils';
+
 export default OlaresID;