@beclab/olaresid 0.1.1

package/src/domain/index.ts

@@ -0,0 +1,659 @@
+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);
+	}
+	debug.info(arr);
+
+	let str = '';
+	for (let i = 0; i < arr.length; i++) {
+		const char = String.fromCharCode(arr[i]);
+		str += char;
+	}
+	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;
+	}
+	debug.info(hex);
+	return hex;
+};
+
+export namespace PackageDomain {
+	export interface Tag {
+		definition: any;
+		from: string;
+		to: string;
+		name: string;
+		valueFormated: any;
+		valueSource: any;
+	}
+
+	export interface DomainData {
+		id: string;
+		name: string;
+		did: string;
+		note: string;
+		allowSubdomain: boolean;
+		owner: string;
+		subdomains: DomainData[];
+		tags: Tag[];
+	}
+
+	export interface OfficialExtendedInformation {
+		ip: string;
+		rsaKey: string;
+		authenticateds: any[];
+		latestDID: string;
+	}
+
+	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;
+		}
+	}
+
+	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()
+			)
+		);
+		for (const d of allDomains) {
+			let subArr = findSubtreesByOwner(owner, d.subdomains);
+			arr.push(...subArr);
+		}
+
+		return arr;
+	};
+
+	export const findSubtreesByDid = (
+		did: string,
+		allDomains: Domain[]
+	): Domain[] => {
+		let arr: Domain[] = [];
+
+		arr.push(...allDomains.filter((d) => d.did.startsWith(did)));
+		for (const d of allDomains) {
+			let subArr = findSubtreesByDid(did, d.subdomains);
+			arr.push(...subArr);
+		}
+
+		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 });
+				}
+
+				tag.valueFormated = data;
+				debug.info(
+					`✅ Successfully fetched value for tag: ${tag.name}`
+				);
+
+				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()
+		);
+	};
+
+	export const getAllSubdoamin = (domain: Domain) => {
+		let arr: Domain[] = [];
+		for (const d of domain.subdomains) {
+			arr.push(...getAllSubdoamin(d));
+		}
+
+		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);
+				});
+		});
+}