@beclab/olaresid 0.1.13 → 0.2.1

package/src/domain/index.ts

@@ -1,662 +1,292 @@
-import { ethers } from 'ethers';
-import DIDTag from '../tag/index';
-import { debug } from '../debug';
-
-const getBase64 = (data: any) => {
-	const hex = data;
-	const arr = [];
-	for (let i = 0; i < hex.length; i += 2) {
-		const code = parseInt(hex.slice(i, i + 2), 16);
-		arr.push(code);
+/**
+ * Domain fetching functions
+ *
+ * This module provides three main functions for fetching domain data:
+ * 1. fetchDomain - Fetch a single domain by name or tokenId
+ * 2. fetchDomains - Fetch multiple domains with pagination
+ * 3. fetchAllFlat - Fetch all domains with flat structure
+ */
+
+import {
+	QueryContractHelper,
+	collectFieldNameHashes,
+	batchFetchFieldNames,
+	parseDomain,
+	parseAllDomains
+} from './core';
+import { FlatDomainData, FetchAllOptions } from './types';
+import type { DIDConsole } from '../index';
+
+/**
+ * Options for fetchDomain
+ */
+export interface FetchDomainOptions {
+	queryContractAddress?: string;
+}
+
+/**
+ * Options for fetchDomains (paginated query)
+ */
+export interface FetchDomainsOptions {
+	queryContractAddress?: string;
+	offset: number;
+	limit: number;
+}
+
+/**
+ * Fetch a single domain by name or tokenId
+ *
+ * @param console - DIDConsole instance
+ * @param nameOrTokenId - Domain name (e.g., "alice.olares.com") or tokenId (hex string or bigint)
+ * @param options - Fetch options
+ * @returns Domain data or null if not found
+ *
+ * @example
+ * // Fetch by domain name
+ * const domain = await fetchDomain(console, "alice.olares.com", { queryContractAddress });
+ *
+ * // Fetch by tokenId
+ * const domain = await fetchDomain(console, "0x123...", { queryContractAddress });
+ */
+export async function fetchDomain(
+	console: DIDConsole,
+	nameOrTokenId: string | bigint,
+	options: FetchDomainOptions = {}
+): Promise<FlatDomainData | null> {
+	const { queryContractAddress } = options;
+
+	if (!queryContractAddress) {
+		throw new Error('queryContractAddress is required');
 	}
-	debug.info(arr);
 
-	let str = '';
-	for (let i = 0; i < arr.length; i++) {
-		const char = String.fromCharCode(arr[i]);
-		str += char;
+	// Step 1: Create query helper
+	const helper = new QueryContractHelper(
+		queryContractAddress,
+		console.getProvider()
+	);
+
+	// Step 2: Fetch single domain (supports both name and tokenId)
+	const rawDomain = await helper.getDomain(nameOrTokenId);
+
+	if (!rawDomain) {
+		return null;
 	}
-	debug.info(str);
-	const base64 = btoa(str);
-	debug.info(base64);
-
-	return base64;
-};
-
-const getHex = (data: any) => {
-	let hex = '';
-	for (let i = 0; i < data.length; i++) {
-		const code = data.charCodeAt(i);
-		let hexCode = code.toString(16);
-		if (hexCode.length < 2) {
-			hexCode = '0' + hexCode;
-		}
-		hex += hexCode;
+
+	// Step 3: Collect field name hashes from this domain's tags
+	const fieldNameHashes = collectFieldNameHashes([rawDomain]);
+
+	// Step 4: Batch fetch field names
+	const contract = console.getContractDID();
+	const fieldNamesMap = await batchFetchFieldNames(contract, fieldNameHashes);
+
+	// Step 5: Parse domain (no parentId calculation for single domain)
+	const domain = parseDomain(rawDomain, fieldNamesMap);
+
+	return domain;
+}
+
+/**
+ * Fetch multiple domains with pagination
+ * Allows you to fetch a specific range of domains with offset and limit
+ *
+ * @param console - DIDConsole instance
+ * @param options - Fetch options including offset and limit
+ * @returns Array of domains in the specified range
+ *
+ * @example
+ * // Fetch first 10 domains
+ * const domains = await fetchDomains(console, {
+ *   queryContractAddress: "0x...",
+ *   offset: 0,
+ *   limit: 10
+ * });
+ *
+ * // Fetch next 10 domains
+ * const nextDomains = await fetchDomains(console, {
+ *   queryContractAddress: "0x...",
+ *   offset: 10,
+ *   limit: 10
+ * });
+ */
+export async function fetchDomains(
+	console: DIDConsole,
+	options: FetchDomainsOptions
+): Promise<FlatDomainData[]> {
+	const { queryContractAddress, offset, limit } = options;
+
+	if (!queryContractAddress) {
+		throw new Error('queryContractAddress is required');
 	}
-	debug.info(hex);
-	return hex;
-};
-
-export namespace PackageDomain {
-	export interface Tag {
-		definition: any;
-		from: string;
-		to: string;
-		name: string;
-		valueFormated: any;
-		valueSource: any;
+
+	if (offset < 0) {
+		throw new Error('offset must be >= 0');
 	}
 
-	export interface DomainData {
-		id: string;
-		name: string;
-		did: string;
-		note: string;
-		allowSubdomain: boolean;
-		owner: string;
-		subdomains: DomainData[];
-		tags: Tag[];
+	if (limit <= 0) {
+		throw new Error('limit must be > 0');
 	}
 
-	export interface OfficialExtendedInformation {
-		ip: string;
-		rsaKey: string;
-		authenticateds: any[];
-		latestDID: string;
+	// Step 1: Create query helper
+	const helper = new QueryContractHelper(
+		queryContractAddress,
+		console.getProvider()
+	);
+
+	// Step 2: Fetch domains in the specified range
+	const rawDomains = await helper.getAllDomains(offset, limit);
+
+	// Return empty array if no domains found
+	if (rawDomains.length === 0) {
+		return [];
 	}
 
-	export class Domain implements DomainData {
-		id: string;
-		name: string;
-		did: string;
-		note: string;
-		allowSubdomain: boolean;
-		owner: string;
-		subdomains: DomainData[];
-		tags: Tag[];
-
-		constructor(
-			id: string,
-			name: string,
-			did: string,
-			note: string,
-			allowSubdomain: boolean,
-			owner: string,
-			subdomains: Domain[],
-			tags: Tag[]
-		) {
-			this.id = id;
-			this.name = name;
-			this.did = did;
-			this.note = note;
-			this.allowSubdomain = allowSubdomain;
-			this.owner = owner;
-			this.subdomains = subdomains;
-			this.tags = tags;
-		}
+	// Step 3: Collect field name hashes
+	const fieldNameHashes = collectFieldNameHashes(rawDomains);
+
+	// Step 4: Batch fetch field names
+	const contract = console.getContractDID();
+	const fieldNamesMap = await batchFetchFieldNames(contract, fieldNameHashes);
+
+	// Step 5: Parse domains (with parentId calculation)
+	const flatDomains = parseAllDomains(rawDomains, fieldNamesMap);
+
+	return flatDomains;
+}
+
+/**
+ * Options for fetchDomainsByIndices
+ */
+export interface FetchDomainsByIndicesOptions {
+	queryContractAddress?: string;
+}
+
+/**
+ * Fetch multiple domains by their indices
+ * Useful for fetching specific domains when you know their positions
+ *
+ * @param console - DIDConsole instance
+ * @param indices - Array of domain indices (e.g., [5, 6, 9, 10])
+ * @param options - Fetch options
+ * @returns Array of domains corresponding to the specified indices
+ *
+ * @example
+ * // Fetch domains at specific indices
+ * const domains = await fetchDomainsByIndices(console, [5, 6, 9, 10], {
+ *   queryContractAddress: "0x..."
+ * });
+ *
+ * // Result will contain domains at positions 5, 6, 9, and 10
+ * // indices[0] -> domains[0], indices[1] -> domains[1], etc.
+ */
+export async function fetchDomainsByIndices(
+	console: DIDConsole,
+	indices: number[],
+	options: FetchDomainsByIndicesOptions = {}
+): Promise<FlatDomainData[]> {
+	const { queryContractAddress } = options;
+
+	if (!queryContractAddress) {
+		throw new Error('queryContractAddress is required');
 	}
 
-	export const syncById = (tokenId: string, contract: ethers.Contract) =>
-		new Promise<Domain>(async (resolve, reject) => {
-			let meta: any | undefined = undefined;
-			let owner: string | undefined = undefined;
-			let times = 0;
-			while (
-				tokenId == undefined ||
-				meta == undefined ||
-				owner == undefined
-			) {
-				try {
-					meta = await contract.getMetadata(tokenId);
-					owner = await contract.ownerOf(tokenId);
-				} catch (error) {
-					times++;
-					if (times >= 5) {
-						throw new Error('network error');
-					}
-				}
-			}
-			// debug.info('meta', meta);
-			const domain = {
-				id: ethers.toBeHex(tokenId),
-				name: meta['0'],
-				did: meta['1'],
-				note: meta['2'],
-				allowSubdomain: meta['3'],
-				subdomains: [],
-				owner: owner,
-				tags: []
-			} as Domain;
-
-			const tags = await fetchAllTagType(domain, contract);
-			domain.tags = tags;
-
-			await fetchAllTagValue(domain, contract);
-
-			resolve(domain);
-		});
-
-	export const syncByName = (name: string, contract: ethers.Contract) =>
-		new Promise<Domain | undefined>(async (resolve, reject) => {
-			let tokenId: string | undefined = await contract.tokenIdOf(name);
-			debug.info('syncByName', name, tokenId);
-			if (tokenId == undefined) {
-				resolve(undefined);
-			} else {
-				resolve(await syncById(tokenId, contract));
-			}
-		});
-
-	export const syncByIndex = (index: number, contract: ethers.Contract) =>
-		new Promise<Domain>(async (resolve, reject) => {
-			let tokenId: string | undefined = undefined;
-
-			let times = 0;
-			while (tokenId == undefined) {
-				try {
-					tokenId = await contract.tokenByIndex(index);
-				} catch (error) {
-					times++;
-					if (times >= 5) {
-						throw new Error('network error');
-					}
-				}
-			}
-			resolve(await syncById(tokenId, contract));
-		});
-
-	export const buildTree = (allDomains: Domain[]): Domain[] => {
-		allDomains.forEach((item) => {
-			const domains = findSubdomain(item, allDomains);
-			item.subdomains = domains;
-		});
-		return allDomains.filter((item) => item.name.split('.').length == 1);
-	};
-
-	export const findSubdomain = (domain: Domain, allDomains: Domain[]) => {
-		const arr: Domain[] = [];
-		allDomains.forEach((item) => {
-			if (
-				item.name.endsWith('.' + domain.name) &&
-				domain.name.split('.').length + 1 == item.name.split('.').length
-			) {
-				const subdomains = findSubdomain(item, allDomains);
-
-				item.subdomains = subdomains;
-				arr.push(item);
-			}
-		});
-		return arr;
-	};
-
-	export const findASubtree = (
-		name: string,
-		allDomains: Domain[]
-	): Domain | undefined => {
-		for (const domain of allDomains) {
-			if (domain.name == name) {
-				return domain;
-			}
-		}
-		return undefined;
-	};
-
-	export const findSubtreesByOwner = (
-		owner: string,
-		allDomains: Domain[]
-	): Domain[] => {
-		let arr: Domain[] = [];
-
-		arr.push(
-			...allDomains.filter(
-				(d) => d.owner.toLocaleLowerCase() == owner.toLocaleLowerCase()
-			)
+	if (!Array.isArray(indices) || indices.length === 0) {
+		throw new Error('indices must be a non-empty array');
+	}
+
+	if (indices.length > 100) {
+		throw new Error(
+			`Too many indices: ${indices.length}. Maximum is 100. Please split into multiple calls.`
 		);
-		for (const d of allDomains) {
-			let subArr = findSubtreesByOwner(owner, d.subdomains);
-			arr.push(...subArr);
+	}
+
+	// Validate all indices are non-negative
+	for (const index of indices) {
+		if (index < 0 || !Number.isInteger(index)) {
+			throw new Error(
+				`Invalid index: ${index}. All indices must be non-negative integers`
+			);
 		}
+	}
 
-		return arr;
-	};
+	// Step 1: Create query helper
+	const helper = new QueryContractHelper(
+		queryContractAddress,
+		console.getProvider()
+	);
 
-	export const findSubtreesByDid = (
-		did: string,
-		allDomains: Domain[]
-	): Domain[] => {
-		let arr: Domain[] = [];
+	// Step 2: Fetch domains by indices (single RPC call)
+	const rawDomains = await helper.getDomainsByIndices(indices);
 
-		arr.push(...allDomains.filter((d) => d.did.startsWith(did)));
-		for (const d of allDomains) {
-			let subArr = findSubtreesByDid(did, d.subdomains);
-			arr.push(...subArr);
-		}
+	if (rawDomains.length === 0) {
+		return [];
+	}
 
-		return arr;
-	};
-
-	export const fetchAllTagType = (
-		domain: Domain,
-		contract: ethers.Contract
-	) =>
-		new Promise<Tag[]>(async (resolve, reject) => {
-			// debug.info('fetchAllTagType', domain);
-
-			let d = domain.name.split('.');
-			let fromArr = [''];
-			for (let index = 1; index <= d.length; index++) {
-				fromArr.push(d.slice(d.length - index).join('.'));
-			}
-			debug.info('fromArr', fromArr);
-
-			let arr: Tag[] = [];
-			for (const from of fromArr) {
-				debug.group(from);
-				let count = await contract.getDefinedTagCount(from);
-				debug.info('count', count);
-
-				for (let i = 0; i < count; i++) {
-					let name = await contract.getDefinedTagNameByIndex(from, i);
-					debug.info('name', name);
-
-					arr.push({
-						from: from,
-						to: domain.name,
-						name: name,
-						valueFormated: undefined,
-						valueSource: undefined
-					} as Tag);
-				}
-				debug.groupEnd();
-			}
-			domain.tags = arr;
-			resolve(domain.tags);
-		});
-
-	export const fetchTagStructure = (tag: Tag, contract: ethers.Contract) =>
-		new Promise<DIDTag.TagParser>(async (resolve, reject) => {
-			debug.info('fetchTagStructure', tag.from, tag.to, tag.name);
-
-			const tagRawType = await contract.getTagABIType(tag.from, tag.name);
-			// debug.info(`tag type raw bytes:`);
-			// debug.info(tagRawType);
-
-			const tagType = DIDTag.doFormatType(tagRawType);
-			// debug.info(`tag type:`);
-			// debug.info(tagType);
-
-			if (
-				(tagType as DIDTag.TagParserBase)
-					.getAbiTypeString()
-					.includes('tuple')
-			) {
-				let [_, fieldNamesHashs] = await contract.getTagType(
-					tag.from,
-					tag.name
-				);
-				let fieldNames: any[] = [];
-				for (let hash of fieldNamesHashs) {
-					let blockNum = await contract.getFieldNamesEventBlock(hash);
-					// debug.info(`field name hash: ${hash}`);
-					// debug.info(`block num: ${blockNum}`);
-					const events = await contract.queryFilter(
-						'OffchainStringArray',
-						Number(blockNum),
-						Number(blockNum)
-					);
-					for (let event of events) {
-						// debug.info('event', event);
-						if (hash == (event as any).args.hash) {
-							fieldNames.push((event as any).args.value);
-						}
-					}
-				}
-				// debug.info(`found field names:`);
-				// debug.info(fieldNames);
-
-				(tagType as DIDTag.TagParserBox).setFieldNames(fieldNames, 0);
-			}
-
-			resolve(tagType);
-		});
-
-	export const fetchTagValue = (tag: Tag, contract: ethers.Contract) =>
-		new Promise<any>(async (resolve, reject) => {
-			try {
-				debug.info('fetchTagValue', tag.from, tag.to, tag.name);
-
-				const tagRawType = await contract.getTagABIType(
-					tag.from,
-					tag.name
-				);
-				// debug.info(`tag type raw bytes:`);
-				// debug.info(tagRawType);
-
-				const tagType = DIDTag.doFormatType(tagRawType);
-				// debug.info(`tag type:`);
-				// debug.info(tagType);
-
-				const rawData = await contract.getTagElem(
-					tag.from,
-					tag.to,
-					tag.name,
-					[]
-				);
-				// debug.info(`tag raw value:`);
-				// debug.info(rawData);
-				tag.valueSource = rawData;
-
-				let data = tagType.parseValue(rawData);
-				data = data[0];
-				debug.info('tag value:');
-				debug.info(data);
-
-				if (
-					(tagType as DIDTag.TagParserBase)
-						.getAbiTypeString()
-						.includes('tuple')
-				) {
-					let [_, fieldNamesHashs] = await contract.getTagType(
-						tag.from,
-						tag.name
-					);
-					let fieldNames: any[] = [];
-					for (let hash of fieldNamesHashs) {
-						let blockNum = await contract.getFieldNamesEventBlock(
-							hash
-						);
-						// debug.info(`field name hash: ${hash}`);
-						// debug.info(`block num: ${blockNum}`);
-						const events = await contract.queryFilter(
-							'OffchainStringArray',
-							Number(blockNum),
-							Number(blockNum)
-						);
-						for (let event of events) {
-							// debug.info('event', event);
-							if (hash == (event as any).args.hash) {
-								fieldNames.push((event as any).args.value);
-							}
-						}
-					}
-					// debug.info(`found field names:`);
-					// debug.info(fieldNames);
-
-					(tagType as DIDTag.TagParserBox).setFieldNames(
-						fieldNames,
-						0
-					);
-
-					data = (tagType as DIDTag.TagParserBase).hydration(rawData);
-
-					// data = data[0];
-					// debug.info('tag value with field names:');
-					// console.dir(data, { depth: null });
-				}
-				let strData = data;
-				if (data !== null && data !== undefined && typeof data !== 'string') {
-					strData = JSON.stringify(data);
-				}
-				tag.valueFormated = strData;
-				debug.info(
-					`✅ Successfully fetched value for tag: ${tag.name}`
-				);
-				debug.info('✅ Updated tag data:', tag);
-				resolve(tag);
-			} catch (error) {
-				debug.error(
-					`❌ Failed to fetch value for tag "${tag.name}" (${
-						tag.from
-					} -> ${tag.to}): ${
-						error instanceof Error ? error.message : String(error)
-					}`
-				);
-
-				tag.valueFormated = null;
-				tag.valueSource = null;
-
-				resolve(tag);
-			}
-		});
-
-	export const fetchAllTagValue = (
-		domain: Domain,
-		contract: ethers.Contract
-	) =>
-		new Promise<Tag[]>(async (resolve, reject) => {
-			for (const tag of domain.tags) {
-				await fetchTagValue(tag, contract);
-			}
-
-			resolve(domain.tags);
-		});
-
-	export const defineTag = async (
-		domain: Domain | undefined,
-		tagName: string,
-		value: DIDTag.TagParserBase,
-		contract: any,
-		providerHolder: DIDTag.ABITypeProviderHolder
-	) => {
-		debug.info('abitype', await value.getAbiType(providerHolder));
-		debug.info('field', await value.getFieldNames());
-
-		await contract.defineTag(
-			domain?.name,
-			tagName,
-			await value.getAbiType(providerHolder),
-			await value.getFieldNames()
-		);
-	};
+	// Step 3: Collect field name hashes
+	const fieldNameHashes = collectFieldNameHashes(rawDomains);
 
-	export const getAllSubdoamin = (domain: Domain) => {
-		let arr: Domain[] = [];
-		for (const d of domain.subdomains) {
-			arr.push(...getAllSubdoamin(d));
-		}
+	// Step 4: Batch fetch field names
+	const contract = console.getContractDID();
+	const fieldNamesMap = await batchFetchFieldNames(contract, fieldNameHashes);
+
+	// Step 5: Parse all domains
+	const domains = parseAllDomains(rawDomains, fieldNamesMap);
+
+	return domains;
+}
+
+/**
+ * Fetch all domains with flat structure using query contract
+ * Much more efficient than the old fetchAll method
+ *
+ * @param console - DIDConsole instance
+ * @param options - Fetch options
+ * @returns Array of all domains in flat structure
+ *
+ * @example
+ * const domains = await fetchAllFlat(console, {
+ *   queryContractAddress: "0x...",
+ *   batchSize: 100,
+ *   onProgress: (current, total) => console.log(`${current}/${total}`)
+ * });
+ */
+export async function fetchAllFlat(
+	console: DIDConsole,
+	options: FetchAllOptions = {}
+): Promise<FlatDomainData[]> {
+	const { queryContractAddress, batchSize = 100, onProgress } = options;
+
+	if (!queryContractAddress) {
+		throw new Error('queryContractAddress is required');
+	}
+
+	// Step 1: Create query helper
+	const helper = new QueryContractHelper(
+		queryContractAddress,
+		console.getProvider()
+	);
+
+	// Step 2: Get total supply
+	const totalSupply = await helper.getTotalSupply();
+	onProgress?.(0, totalSupply);
+
+	// Step 3: Fetch all domains in batches
+	const allRawDomains = [];
+	for (let offset = 0; offset < totalSupply; offset += batchSize) {
+		const limit = Math.min(batchSize, totalSupply - offset);
+		const batch = await helper.getAllDomains(offset, limit);
+		allRawDomains.push(...batch);
+		onProgress?.(Math.min(offset + batchSize, totalSupply), totalSupply);
+	}
+
+	// Step 4: Collect all field name hashes
+	const fieldNameHashes = collectFieldNameHashes(allRawDomains);
+
+	// Step 5: Batch fetch field names
+	const contract = console.getContractDID();
+	const fieldNamesMap = await batchFetchFieldNames(contract, fieldNameHashes);
+
+	// Step 6: Parse all domains (with parentId calculation)
+	const flatDomains = parseAllDomains(allRawDomains, fieldNamesMap);
 
-		arr.push(...domain.subdomains);
-
-		return arr;
-	};
-
-	export const fetchOfficialExtendedInformation = (
-		domain: Domain,
-		contract: ethers.Contract
-	) =>
-		new Promise<OfficialExtendedInformation>(async (resolve, reject) => {
-			let ip: string | undefined = undefined;
-			let ipStr = '';
-			try {
-				ip = (await contract.getDnsARecord(domain.name)) as string;
-				ipStr = `${parseInt(ip.substring(2, 4), 16)}.${parseInt(
-					ip.substring(4, 6),
-					16
-				)}.${parseInt(ip.substring(6, 8), 16)}.${parseInt(
-					ip.substring(8, 10),
-					16
-				)}`;
-			} catch (error) {
-				debug.info(
-					error instanceof Error ? error.message : String(error)
-				);
-			}
-
-			let rsaKey: any | undefined = undefined;
-			try {
-				rsaKey = (await contract.getRsaPubKey(domain.name)) as string;
-			} catch (error) {
-				debug.info(
-					error instanceof Error ? error.message : String(error)
-				);
-			}
-
-			let pubKey = '';
-			try {
-				if (rsaKey != '0x' && rsaKey != undefined) {
-					// debug.info('rsaKey:');
-					const str = String.fromCharCode(
-						...rsaKey
-							.match(/.{1,2}/g)
-							.map((byte: any) => parseInt(byte, 16))
-					);
-					const encoded = btoa(str);
-					const base64 = getBase64(rsaKey.replaceAll('0x', ''));
-
-					// debug.info(encoded);
-					// debug.info(base64);
-					pubKey = `-----BEGIN RSA PUBLIC KEY-----
-                        ${base64}
-                        -----END RSA PUBLIC KEY-----`;
-				}
-			} catch (error) {
-				debug.error(
-					error instanceof Error ? error.message : String(error)
-				);
-			}
-
-			let authenticatedAddress: any[] = [];
-			try {
-				authenticatedAddress =
-					await contract.getAuthenticationAddresses(domain.name);
-			} catch (error) {
-				debug.error(
-					error instanceof Error ? error.message : String(error)
-				);
-			}
-
-			// debug.info('authenticatedAddress:');
-			// debug.info(authenticatedAddress);
-
-			let latestDID = '';
-			try {
-				latestDID = await contract.getLatestDID(domain.name);
-			} catch (error) {
-				debug.info(
-					error instanceof Error ? error.message : String(error)
-				);
-			}
-			// debug.info('latestDID:', latestDID);
-
-			const officialExt = {
-				ip: ipStr,
-				rsaKey: pubKey,
-				authenticateds: authenticatedAddress,
-				latestDID: latestDID
-			};
-			debug.info('officialExt: ', officialExt);
-
-			resolve(officialExt);
-		});
-
-	export const updateIp = (
-		domain: Domain,
-		ipStr: string,
-		contract: ethers.Contract
-	) =>
-		new Promise<string>(async (resolve, reject) => {
-			debug.info('updateIp', ipStr);
-
-			const v2 =
-				'((\\d{1,2})|(1\\d{2})|(2[0-4]\\d)|(25[0-5]))\\.((\\d{1,2})|(1\\d{2})|(2[0-4]\\d)|(25[0-5]))\\.((\\d{1,2})|(1\\d{2})|(2[0-4]\\d)|(25[0-5]))\\.((\\d{1,2})|(1\\d{2})|(2[0-4]\\d)|(25[0-5]))';
-			const v3 =
-				'((\\d{1,2})|(1\\d{2})|(2[0-4]\\d)|(25[0-5]))\\.((\\d{1,2})|(1\\d{2})|(2[0-4]\\d)|(25[0-5]))\\.((\\d{1,2})|(1\\d{2})|(2[0-4]\\d)|(25[0-5])).((d{1,2})|(1d{2})|(2[0-4]d)|(25[0-5]))';
-			const reg = new RegExp(v3, 'g');
-			const reg2 = new RegExp(v2, 'g');
-
-			const isIp = ipStr.match(reg);
-			const isIp2 = ipStr.match(reg2);
-
-			if (isIp != null || isIp2 != null) {
-				const ipArr = ipStr.split('.');
-
-				const add0 = (str: string) =>
-					str.length == 1 ? '0' + str : str;
-				const ipBytes = `0x${add0(
-					parseInt(ipArr[0]).toString(16)
-				)}${add0(parseInt(ipArr[1]).toString(16))}${add0(
-					parseInt(ipArr[2]).toString(16)
-				)}${add0(parseInt(ipArr[3]).toString(16))}`;
-
-				debug.info(ethers.getBytes(ipBytes));
-				debug.info(ipBytes);
-				debug.info(domain.name);
-
-				await contract
-					.setDnsARecord(domain.name, ipBytes)
-					.then((resp) => {
-						resolve('sumbit succeed');
-					})
-					.catch((error) => {
-						debug.info('error1:');
-						debug.info(error);
-
-						reject(error.message);
-					});
-			} else {
-				reject('ip format error');
-			}
-		});
-
-	export const updateRSAPublicKey = (
-		domain: Domain,
-		rsaPublicKey: string,
-		contract: ethers.Contract
-	) =>
-		new Promise<string>(async (resolve, reject) => {
-			const regex1 = new RegExp('-----BEGIN PUBLIC KEY-----', 'g');
-			const regex2 = new RegExp('-----END PUBLIC KEY-----', 'g');
-			const regex3 = new RegExp('\n', 'g');
-
-			const keyBase64 = rsaPublicKey
-				.replace(regex1, '')
-				.replace(regex2, '')
-				.replace(regex3, '');
-
-			const keyHex = getHex(atob(rsaPublicKey));
-
-			debug.info('keyHex:');
-			debug.info(keyHex);
-			debug.info(keyBase64);
-			debug.info(rsaPublicKey);
-
-			await contract
-				.setRsaPubKey(domain.name, `0x${keyHex}`)
-				.then((resp) => {
-					resolve('sumbit succeed');
-				})
-				.catch((error) => {
-					reject(error.message);
-				});
-		});
-
-	export const setValue = (tag: Tag, data: any, contract: ethers.Contract) =>
-		new Promise<string>(async (resolve, reject) => {
-			await contract
-				.addTag(tag.from, tag.to, tag.name, data)
-				.then((resp) => {
-					debug.info(resp);
-					resolve('sumbit succeed');
-				})
-				.catch((error) => {
-					reject(error.message);
-				});
-		});
-
-	export const setTagger = (
-		tag: Tag,
-		tagger: string,
-		contract: ethers.Contract
-	) =>
-		new Promise<string>(async (resolve, reject) => {
-			await contract
-				.setTagger(tag.from, tag.name, tagger)
-				.then((resp) => {
-					debug.info(resp);
-					resolve('sumbit succeed');
-				})
-				.catch((error) => {
-					reject(error.message);
-				});
-		});
+	return flatDomains;
 }