@beclab/olaresid 0.1.1 → 0.1.2

package/src/debug.ts

@@ -18,14 +18,29 @@ class DebugLogger {
 	}
 
 	private parseConfig(): DebugConfig {
-		// Check environment variables
+		// Check if running in Node.js environment
+		const isNode =
+			typeof process !== 'undefined' &&
+			process.versions &&
+			process.versions.node;
+
+		// Default config for browser
+		if (!isNode) {
+			return {
+				enabled: false,
+				level: 'debug',
+				prefix: '[DID-DEBUG]'
+			};
+		}
+
+		// Check environment variables (Node.js only)
 		const envDebug =
 			process.env.DEBUG === 'true' || process.env.DEBUG === '1';
 		const envLevel =
 			(process.env.DEBUG_LEVEL as DebugConfig['level']) || 'debug';
 		const envPrefix = process.env.DEBUG_PREFIX || '[DID-DEBUG]';
 
-		// Check command line arguments
+		// Check command line arguments (Node.js only)
 		const args = process.argv;
 		const hasDebugFlag = args.includes('--debug') || args.includes('-d');
 		const hasVerboseFlag =

package/src/index.ts

@@ -3,7 +3,62 @@ 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 {
+	DomainContext,
+	DomainMetaInfo,
+	DomainInfo,
+	TagInfo,
+	TransactionResult,
+	RSAPublicKeyData,
+	DIDKeyData,
+	UserType,
+	createRsaKeyPair,
+	pemToDer,
+	derToPem,
+	ipv4ToBytes4,
+	bytes4ToIpv4,
+	generateMnemonic,
+	getEthereumAddressFromMnemonic,
+	getEVMPrivateKeyFromMnemonic,
+	getDIDFromMnemonic,
+	generateDIDKeyData,
+	deriveDIDFromMnemonic
+} from './business';
+import { TagContext } from './business/tag-context';
+
+// Import Tag utilities
+import { TagTypeBuilder } from './utils/tag-type-builder';
+import { TagAbiCodec } from './utils/tag-abi-codec';
+
+export type {
+	DomainInfo,
+	DomainMetaInfo,
+	TagInfo,
+	TransactionResult,
+	RSAPublicKeyData,
+	DIDKeyData
+} from './business';
+
+export {
+	UserType,
+	DomainContext,
+	TagContext,
+	createRsaKeyPair,
+	pemToDer,
+	derToPem,
+	ipv4ToBytes4,
+	bytes4ToIpv4,
+	generateMnemonic,
+	getEthereumAddressFromMnemonic,
+	getEVMPrivateKeyFromMnemonic,
+	getDIDFromMnemonic,
+	generateDIDKeyData,
+	deriveDIDFromMnemonic
+} from './business';
 
 type Domain = PackageDomain.Domain;
 
@@ -14,26 +69,117 @@ export class DIDConsole implements DIDTag.ABITypeProviderHolder {
 	contractDid: string;
 	contractRootResolver: string;
 	contractAbiType: string;
+	contractRootResolver2?: string;
+	supportSvcUrl?: string;
+
+	signer?: ethers.Signer;
 
 	allDomainCache: Domain[] = [];
 	treesCache: Domain[] = [];
 
+	// caching contract instances
+	private _contractDID?: ethers.Contract;
+	private _signerContractDID?: ethers.Contract;
+	private _contractRootResolver?: ethers.Contract;
+	private _signerContractRootResolver?: ethers.Contract;
+	private _contractRootResolver2?: ethers.Contract;
+	private _signerContractRootResolver2?: ethers.Contract;
+
+	private _provider?: ethers.JsonRpcProvider;
+
 	constructor(
 		rpcNode: string,
 		contractDid: string,
 		contractRootResolver: string,
-		contractAbiType: string
+		contractAbiType: string,
+		contractRootResolver2?: string,
+		supportSvcUrl?: string
 	) {
 		this.rpcNode = rpcNode;
 		this.contractDid = contractDid;
 		this.contractRootResolver = contractRootResolver;
 		this.contractAbiType = contractAbiType;
+		this.contractRootResolver2 = contractRootResolver2;
+		this.supportSvcUrl = supportSvcUrl;
 	}
 
-	getProvider = () => new ethers.JsonRpcProvider(this.rpcNode);
+	getProvider = (): ethers.JsonRpcProvider => {
+		if (!this._provider) {
+			this._provider = new ethers.JsonRpcProvider(this.rpcNode);
+		}
+		return this._provider;
+	};
+
+	setSigner = async (
+		signerOrPrivateKeyOrMnemonic: ethers.Signer | string
+	) => {
+		if (typeof signerOrPrivateKeyOrMnemonic === 'string') {
+			// Check if it's a mnemonic (12-24 words) or private key (0x... hex)
+			const trimmed = signerOrPrivateKeyOrMnemonic.trim();
+			const wordCount = trimmed.split(/\s+/).length;
+
+			// If it's 12-24 words, treat it as a mnemonic
+			if (wordCount >= 12 && wordCount <= 24) {
+				// Import and use the mnemonic conversion function
+				const { getEVMPrivateKeyFromMnemonic } = await import(
+					'./utils/crypto-utils'
+				);
+				const privateKey = await getEVMPrivateKeyFromMnemonic(trimmed);
+				this.signer = new ethers.Wallet(privateKey, this.getProvider());
+			} else {
+				// Treat as private key
+				this.signer = new ethers.Wallet(
+					signerOrPrivateKeyOrMnemonic,
+					this.getProvider()
+				);
+			}
+		} else {
+			this.signer = signerOrPrivateKeyOrMnemonic;
+		}
+
+		// reset cached signer contracts
+		this._signerContractDID = undefined;
+		this._signerContractRootResolver = undefined;
+		this._signerContractRootResolver2 = undefined;
+	};
+
+	getSigner = (): ethers.Signer => {
+		if (!this.signer) {
+			throw new Error('No signer available.');
+		}
+		return this.signer;
+	};
+
+	clearSigner = () => {
+		this.signer = undefined;
 
-	getContractDID = () =>
-		new ethers.Contract(this.contractDid, DID_ABI.abi, this.getProvider());
+		// reset cached signer contracts
+		this._signerContractDID = undefined;
+		this._signerContractRootResolver = undefined;
+		this._signerContractRootResolver2 = undefined;
+	};
+
+	getContractDID = (): ethers.Contract => {
+		if (!this._contractDID) {
+			this._contractDID = new ethers.Contract(
+				this.contractDid,
+				DID_ABI.abi,
+				this.getProvider()
+			);
+		}
+		return this._contractDID;
+	};
+
+	getSignerContractDID = (): ethers.Contract => {
+		if (!this._signerContractDID) {
+			this._signerContractDID = new ethers.Contract(
+				this.contractDid,
+				DID_ABI.abi,
+				this.getSigner()
+			);
+		}
+		return this._signerContractDID;
+	};
 
 	getContractDIDByPrivateKey = (privateKey: string) => {
 		const wallet = new ethers.Wallet(privateKey, this.getProvider());
@@ -55,12 +201,57 @@ export class DIDConsole implements DIDTag.ABITypeProviderHolder {
 			await provider.getSigner()
 		);
 
-	getContractRootResolver = () =>
-		new ethers.Contract(
-			this.contractRootResolver,
-			RootResolverABI.abi,
-			this.getProvider()
-		);
+	getContractRootResolver = (): ethers.Contract => {
+		if (!this._contractRootResolver) {
+			this._contractRootResolver = new ethers.Contract(
+				this.contractRootResolver,
+				RootResolverABI.abi,
+				this.getProvider()
+			);
+		}
+		return this._contractRootResolver;
+	};
+
+	getSignerContractRootResolver = (): ethers.Contract => {
+		if (!this._signerContractRootResolver) {
+			this._signerContractRootResolver = new ethers.Contract(
+				this.contractRootResolver,
+				RootResolverABI.abi,
+				this.getSigner()
+			);
+		}
+		return this._signerContractRootResolver;
+	};
+
+	getContractRootResolver2 = (): ethers.Contract => {
+		if (!this.contractRootResolver2) {
+			throw new Error('No contractRootResolver2 provided.');
+		}
+
+		if (!this._contractRootResolver2) {
+			this._contractRootResolver2 = new ethers.Contract(
+				this.contractRootResolver2,
+				RootResolver2ABI.abi,
+				this.getProvider()
+			);
+		}
+		return this._contractRootResolver2;
+	};
+
+	getSignerContractRootResolver2 = (): ethers.Contract => {
+		if (!this.contractRootResolver2) {
+			throw new Error('No contractRootResolver2 provided.');
+		}
+
+		if (!this._signerContractRootResolver2) {
+			this._signerContractRootResolver2 = new ethers.Contract(
+				this.contractRootResolver2,
+				RootResolver2ABI.abi,
+				this.getSigner()
+			);
+		}
+		return this._signerContractRootResolver2;
+	};
 
 	getSignerContractRootResolverByProvider = async (
 		provider: ethers.JsonRpcApiProvider
@@ -252,6 +443,89 @@ export class DIDConsole implements DIDTag.ABITypeProviderHolder {
 
 			resolve(datas);
 		});
+
+	/**
+	 * Uses a chain-style operation design pattern, returning the operation context for the specified domain
+	 * For example: await console.domain('developer.olares.com').setRSAPublicKey(rsaKey);
+	 */
+	domain(name: string): DomainContext {
+		return new DomainContext(name, this);
+	}
+
+	/**
+	 * Set the operator address (super admin)
+	 * Only the contract owner can call this method
+	 */
+	async setOperator(newOperator: string): Promise<TransactionResult> {
+		try {
+			const contract = this.getSignerContractDID();
+			const tx = await contract.setOperator(newOperator);
+			const receipt = await tx.wait();
+
+			return {
+				success: true,
+				transactionHash: receipt.hash,
+				gasUsed: receipt.gasUsed,
+				blockNumber: receipt.blockNumber
+			};
+		} catch (error) {
+			const parsedError = parseContractError(error);
+
+			// Always throw network errors
+			if (parsedError.isNetworkError) {
+				throw new Error(`Network error: ${parsedError.message}`);
+			}
+
+			// Return friendly contract error
+			return {
+				success: false,
+				transactionHash: '',
+				error: parsedError.message
+			};
+		}
+	}
+
+	/**
+	 * Get the current operator address (super admin)
+	 * @returns The operator address
+	 */
+	async getOperator(): Promise<string> {
+		try {
+			const contract = this.getContractDID();
+			return await contract.operator();
+		} catch (error) {
+			const parsedError = parseContractError(error);
+			throw new Error(parsedError.message);
+		}
+	}
+
+	/**
+	 * Get contract owner address
+	 * @returns The contract owner address
+	 */
+	async getOwner(): Promise<string> {
+		try {
+			const contract = this.getContractDID();
+			return await contract.owner();
+		} catch (error) {
+			const parsedError = parseContractError(error);
+			throw new Error(parsedError.message);
+		}
+	}
+
+	/**
+	 * Get total supply of domains
+	 * @returns The total number of registered domains
+	 */
+	async getTotalSupply(): Promise<bigint> {
+		try {
+			const contract = this.getContractDID();
+			return await contract.totalSupply();
+		} catch (error) {
+			const parsedError = parseContractError(error);
+			throw new Error(parsedError.message);
+		}
+	}
 }
 
 namespace OlaresID {
@@ -259,13 +533,17 @@ namespace OlaresID {
 		rpcNode: string,
 		contractDid: string,
 		contractRootResolver: string,
-		contractAbiType: string
+		contractAbiType: string,
+		contractRootResolver2?: string,
+		supportSvcUrl?: string
 	): DIDConsole => {
 		return new DIDConsole(
 			rpcNode,
 			contractDid,
 			contractRootResolver,
-			contractAbiType
+			contractAbiType,
+			contractRootResolver2,
+			supportSvcUrl
 		);
 	};
 
@@ -274,7 +552,9 @@ namespace OlaresID {
 			'https://optimism-rpc.publicnode.com',
 			'0x5DA4Fa8E567d86e52Ef8Da860de1be8f54cae97D',
 			'0xE2EABA0979277A90511F8873ae1e8cA26B54E740',
-			'0x9ae3F16bD99294Af1784beB1a0A5C84bf2636365'
+			'0x9ae3F16bD99294Af1784beB1a0A5C84bf2636365',
+			'0x7e7961aB771cA942CE4DB6e79579e016a33Dc95B',
+			'https://api.olares.com/did/support'
 		);
 	};
 
@@ -283,7 +563,9 @@ namespace OlaresID {
 			'https://sepolia.optimism.io',
 			'0xe2D7c3a9013960E04d4E9F5F9B63fff37eEd97A8',
 			'0xeF727cb066Fee98F88Db84555830063b4A24ddfc',
-			'0x7386fCBae6Ad4CCE1499d9153D99bc950B589718'
+			'0x7386fCBae6Ad4CCE1499d9153D99bc950B589718',
+			'0xcbC02aa08c77a374eC0D5A0403E108b7573d96e8',
+			'https://api-test.olares.com/did/support'
 		);
 	};
 
@@ -299,4 +581,8 @@ namespace OlaresID {
 }
 
 export { debug } from './debug';
+
+// Export Tag utilities outside namespace
+export { TagTypeBuilder, TagAbiCodec };
+
 export default OlaresID;