@beclab/olaresid 0.1.1

package/src/index.ts

@@ -0,0 +1,302 @@
+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 { debug } from './debug';
+
+type Domain = PackageDomain.Domain;
+
+type StoreDomain = PackageDomain.DomainData;
+
+export class DIDConsole implements DIDTag.ABITypeProviderHolder {
+	rpcNode: string;
+	contractDid: string;
+	contractRootResolver: string;
+	contractAbiType: string;
+
+	allDomainCache: Domain[] = [];
+	treesCache: Domain[] = [];
+
+	constructor(
+		rpcNode: string,
+		contractDid: string,
+		contractRootResolver: string,
+		contractAbiType: string
+	) {
+		this.rpcNode = rpcNode;
+		this.contractDid = contractDid;
+		this.contractRootResolver = contractRootResolver;
+		this.contractAbiType = contractAbiType;
+	}
+
+	getProvider = () => new ethers.JsonRpcProvider(this.rpcNode);
+
+	getContractDID = () =>
+		new ethers.Contract(this.contractDid, DID_ABI.abi, this.getProvider());
+
+	getContractDIDByPrivateKey = (privateKey: string) => {
+		const wallet = new ethers.Wallet(privateKey, this.getProvider());
+
+		const contract = new ethers.Contract(
+			this.contractDid,
+			DID_ABI.abi,
+			wallet
+		);
+		return contract;
+	};
+
+	getSignerContractDIDByProvider = async (
+		provider: ethers.JsonRpcApiProvider
+	) =>
+		new ethers.Contract(
+			this.contractDid,
+			DID_ABI.abi,
+			await provider.getSigner()
+		);
+
+	getContractRootResolver = () =>
+		new ethers.Contract(
+			this.contractRootResolver,
+			RootResolverABI.abi,
+			this.getProvider()
+		);
+
+	getSignerContractRootResolverByProvider = async (
+		provider: ethers.JsonRpcApiProvider
+	) =>
+		new ethers.Contract(
+			this.contractRootResolver,
+			RootResolverABI.abi,
+			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) => {
+			debug.group('fetchDomain');
+			const hasCache = this.allDomainCache.length > 0;
+			debug.info('fetchDomain--->hasCache', hasCache);
+
+			if (hasCache) {
+				const domain = PackageDomain.findASubtree(
+					name,
+					this.allDomainCache
+				);
+
+				debug.groupEnd();
+				resolve(domain);
+			} else {
+				const domain = await PackageDomain.syncByName(
+					name,
+					await this.getContractDID()
+				);
+
+				debug.groupEnd();
+				resolve(domain);
+			}
+		});
+
+	updateDomain = (name: string) =>
+		new Promise<Domain>(async (resolve, reject) => {
+			const domain = await PackageDomain.syncByName(
+				name,
+				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
+			);
+			this.allDomainCache.push(domain);
+
+			this.treesCache = PackageDomain.buildTree(this.allDomainCache);
+
+			resolve(domain);
+		});
+
+	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
+			);
+			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);
+		});
+
+	loadData = (data: StoreDomain) =>
+		new Promise<Domain>((resolve, reject) => {
+			resolve(data);
+		});
+
+	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);
+		});
+}
+
+namespace OlaresID {
+	export const createConsole = (
+		rpcNode: string,
+		contractDid: string,
+		contractRootResolver: string,
+		contractAbiType: string
+	): DIDConsole => {
+		return new DIDConsole(
+			rpcNode,
+			contractDid,
+			contractRootResolver,
+			contractAbiType
+		);
+	};
+
+	export const createMainnet = (): DIDConsole => {
+		return createConsole(
+			'https://optimism-rpc.publicnode.com',
+			'0x5DA4Fa8E567d86e52Ef8Da860de1be8f54cae97D',
+			'0xE2EABA0979277A90511F8873ae1e8cA26B54E740',
+			'0x9ae3F16bD99294Af1784beB1a0A5C84bf2636365'
+		);
+	};
+
+	export const createTestnet = (): DIDConsole => {
+		return createConsole(
+			'https://sepolia.optimism.io',
+			'0xe2D7c3a9013960E04d4E9F5F9B63fff37eEd97A8',
+			'0xeF727cb066Fee98F88Db84555830063b4A24ddfc',
+			'0x7386fCBae6Ad4CCE1499d9153D99bc950B589718'
+		);
+	};
+
+	export import Domain = PackageDomain;
+
+	export import Tag = DIDTag;
+
+	export type StoreDomain = PackageDomain.DomainData;
+
+	export const ABI_DID = DID_ABI;
+
+	export const ABI_ROOT_RESOLVER = RootResolverABI;
+}
+
+export { debug } from './debug';
+export default OlaresID;

package/src/tag/address.ts

@@ -0,0 +1,48 @@
+import { Tag, TagBase, ProviderHolder } from './tag';
+import { ethers } from 'ethers';
+import ABITypeABI from '../abi/ABITypeABI';
+
+function isEthereumAddress(address: string): boolean {
+	const ethereumAddressRegex = /^(0x)?[0-9a-fA-F]{40}$/;
+	return ethereumAddressRegex.test(address);
+}
+
+export class Address extends TagBase {
+	name: string = 'address';
+
+	formatType(typeBytes: any, index: number): number {
+		this.name = 'address';
+		return index + 2;
+	}
+
+	getAbiTypeString(): string {
+		return 'address';
+	}
+
+	getAbiType = (providerHolder: ProviderHolder) =>
+		new Promise<void>(async (resolve, reject) => {
+			const c = new ethers.Contract(
+				providerHolder.contractAbiType,
+				ABITypeABI.abi,
+				providerHolder.getProvider()
+			);
+
+			const resp = await c.addressT();
+			// console.log('getAbiType', 'Address', resp);
+			resolve(resp);
+		});
+
+	getParamTypes(): string {
+		return 'address';
+	}
+
+	getParameters(data: any) {
+		if (!isEthereumAddress(data)) {
+			throw new Error(`${data} is not ethereum address`);
+		}
+
+		return data;
+	}
+}
+
+export default Address;

package/src/tag/array.ts

@@ -0,0 +1,80 @@
+import { Tag, TagBase, Box, ProviderHolder } from './tag';
+import { ethers } from 'ethers';
+import ABITypeABI from '../abi/ABITypeABI';
+export class Array extends Box {
+	setBuliderType(type: TagBase) {
+		this.boxData.arrayTag = type;
+	}
+
+	formatType(typeBytes: any, index: number): number {
+		let { cursor, tag } = this.formatChild(typeBytes, index + 2);
+		if (tag == undefined) {
+			throw new Error('formatType error in array');
+		}
+
+		this.boxData = {
+			arrayTag: tag
+		};
+		return cursor;
+	}
+
+	getAbiTypeString(): string {
+		return `${this.boxData.arrayTag.getAbiTypeString()}[]`;
+	}
+
+	setFieldNames(names: string[] | string[][], index: number): number {
+		if (this.boxData.arrayTag instanceof Box) {
+			return (this.boxData.arrayTag as Box).setFieldNames(names, index);
+		}
+		return index;
+	}
+
+	doHydration(d: any) {
+		let arr: any[] = [];
+		for (const item of d) {
+			arr.push(this.boxData.arrayTag.doHydration(item));
+		}
+
+		return arr;
+	}
+
+	getAbiType = (providerHolder: ProviderHolder) =>
+		new Promise<void>(async (resolve, reject) => {
+			const c = new ethers.Contract(
+				providerHolder.contractAbiType,
+				ABITypeABI.abi,
+				providerHolder.getProvider()
+			);
+
+			const arrAbi = await this.boxData.arrayTag.getAbiType(
+				providerHolder
+			);
+
+			const resp = await c.arrayT(arrAbi);
+			// console.log('getAbiType', 'array', resp);
+			resolve(resp);
+		});
+
+	getFieldName(): string[][] {
+		if (this.boxData.arrayTag instanceof Box) {
+			return this.boxData.arrayTag.getFieldName();
+		} else {
+			return [];
+		}
+	}
+
+	getParamTypes(): string {
+		return `${this.boxData.arrayTag.getAbiTypeString()}[]`;
+	}
+
+	getParameters(data: any) {
+		let arr = [];
+		for (const item of data) {
+			const value = this.boxData.arrayTag.getParameters(item);
+			arr.push(value);
+		}
+		return arr;
+	}
+}
+
+export default Array;

package/src/tag/bool.ts

@@ -0,0 +1,43 @@
+import { Tag, TagBase, ProviderHolder } from './tag';
+import { ethers } from 'ethers';
+import ABITypeABI from '../abi/ABITypeABI';
+export class Bool extends TagBase {
+	name: string = 'bool';
+
+	formatType(typeBytes: any, index: number): number {
+		this.name = 'bool';
+		return index + 2;
+	}
+
+	getAbiTypeString(): string {
+		return 'bool';
+	}
+
+	getAbiType = (providerHolder: ProviderHolder) =>
+		new Promise<void>(async (resolve, reject) => {
+			const c = new ethers.Contract(
+				providerHolder.contractAbiType,
+				ABITypeABI.abi,
+				providerHolder.getProvider()
+			);
+
+			const resp = await c.boolT();
+			// console.log('getAbiType', 'Bool', resp);
+			resolve(resp);
+		});
+
+	getParamTypes(): string {
+		return 'bool';
+	}
+
+	getParameters(data: any) {
+		// console.log('data', data);
+		if (data == true || data == false) {
+			return data;
+		} else {
+			throw new Error(`${data} is not a boolean`);
+		}
+	}
+}
+
+export default Bool;

package/src/tag/bytes.ts

@@ -0,0 +1,38 @@
+import { Tag, TagBase, ProviderHolder } from './tag';
+import { ethers } from 'ethers';
+import ABITypeABI from '../abi/ABITypeABI';
+export class Bytes extends TagBase {
+	name: string = 'bytes';
+
+	formatType(typeBytes: any, index: number): number {
+		this.name = 'bytes';
+		return index + 2;
+	}
+
+	getAbiTypeString(): string {
+		return 'bytes';
+	}
+
+	getAbiType = (providerHolder: ProviderHolder) =>
+		new Promise<void>(async (resolve, reject) => {
+			const c = new ethers.Contract(
+				providerHolder.contractAbiType,
+				ABITypeABI.abi,
+				providerHolder.getProvider()
+			);
+
+			const resp = await c.bytesT();
+			// console.log('getAbiType', 'bytes', resp);
+			resolve(resp);
+		});
+
+	getParamTypes(): string {
+		return 'bytes';
+	}
+
+	getParameters(data: any) {
+		return data;
+	}
+}
+
+export default Bytes;

package/src/tag/flarray.ts

@@ -0,0 +1,99 @@
+import { Tag, TagBase, Box, read2Byte, ProviderHolder } from './tag';
+import { ethers } from 'ethers';
+import ABITypeABI from '../abi/ABITypeABI';
+export class FixedLengthArray extends Box {
+	setBuliderType(type: TagBase) {
+		this.boxData.arrayTag = type;
+	}
+
+	formatType(typeBytes: any, index: number): number {
+		let la = read2Byte(typeBytes, index + 2);
+		let length = parseInt(la, 16);
+
+		let { cursor, tag } = this.formatChild(typeBytes, index + 6);
+		if (tag == undefined) {
+			throw new Error('formatType error in array');
+		}
+
+		this.boxData = {
+			arrayTag: tag,
+			length: length
+		};
+		return cursor;
+	}
+
+	getAbiTypeString(): string {
+		return `${this.boxData.arrayTag.getAbiTypeString()}[${
+			this.boxData.length
+		}]`;
+	}
+
+	setFieldNames(names: string[] | string[][], index: number): number {
+		if (this.boxData.arrayTag instanceof Box) {
+			return (this.boxData.arrayTag as Box).setFieldNames(names, index);
+		}
+		return index;
+	}
+
+	doHydration(d: any) {
+		let arr: any[] = [];
+		for (const item of d) {
+			arr.push(this.boxData.arrayTag.doHydration(item));
+		}
+
+		return arr;
+	}
+
+	setSize = (size: number) => {
+		this.boxData.length = size;
+	};
+
+	getAbiType = (providerHolder: ProviderHolder) =>
+		new Promise<void>(async (resolve, reject) => {
+			const c = new ethers.Contract(
+				providerHolder.contractAbiType,
+				ABITypeABI.abiHaveCount,
+				providerHolder.getProvider()
+			);
+
+			const arrAbi = await this.boxData.arrayTag.getAbiType(
+				providerHolder
+			);
+
+			const resp = await c.arrayT(arrAbi, this.boxData.length);
+			// console.log('getAbiType', 'Address', resp);
+			resolve(resp);
+		});
+
+	getFieldName(): string[][] {
+		if (this.boxData.arrayTag instanceof Box) {
+			return this.boxData.arrayTag.getFieldName();
+		} else {
+			return [];
+		}
+	}
+
+	getParamTypes(): string {
+		return `${this.boxData.arrayTag.getAbiTypeString()}[${
+			this.boxData.length
+		}]`;
+	}
+
+	getParameters(data: any) {
+		if (data.length != this.boxData.length) {
+			throw new Error(
+				`${this.fieldName} muse be length ${this.boxData.length}, but input data is length ${data.length}`
+			);
+		}
+
+		const arr = [];
+		for (const item of data) {
+			const value = this.boxData.arrayTag.getParameters(item);
+			arr.push(value);
+		}
+
+		return arr;
+	}
+}
+
+export default FixedLengthArray;

package/src/tag/flbytes.ts

@@ -0,0 +1,48 @@
+import { Tag, TagBase, readByte, ProviderHolder } from './tag';
+import { ethers } from 'ethers';
+import ABITypeABI from '../abi/ABITypeABI';
+export class FixedLengthBytes extends TagBase {
+	// length: number = 0
+	formatType(typeBytes: any, index: number): number {
+		let b = readByte(typeBytes, index + 2);
+		let length = parseInt(b, 16);
+		if (length < 1 || length > 32) {
+			throw new Error(`input is not a valid bytes type`);
+		}
+		this.boxData = {
+			length: length
+		};
+		return index + 4;
+	}
+
+	getAbiTypeString(): string {
+		return `bytes${this.boxData.length}`;
+	}
+
+	setSize = (size: number) => {
+		this.boxData.length = size;
+	};
+
+	getAbiType = (providerHolder: ProviderHolder) =>
+		new Promise<void>(async (resolve, reject) => {
+			const c = new ethers.Contract(
+				providerHolder.contractAbiType,
+				ABITypeABI.abiHaveCount,
+				providerHolder.getProvider()
+			);
+
+			const resp = await c.bytesT(this.boxData.length);
+			// console.log('getAbiType', 'uint', resp);
+			resolve(resp);
+		});
+
+	getParamTypes(): string {
+		return `bytes${this.boxData.length}`;
+	}
+
+	getParameters(data: any) {
+		return data;
+	}
+}
+
+export default FixedLengthBytes;