@beclab/olaresid 0.1.1

package/src/cli.ts

@@ -0,0 +1,230 @@
+#!/usr/bin/env node
+
+import OlaresID from './index';
+import { debug } from './debug';
+
+// 预设的网络配置
+const NETWORKS = {
+	sepolia: {
+		rpc: 'https://sepolia.optimism.io',
+		contractDid: '0xe2D7c3a9013960E04d4E9F5F9B63fff37eEd97A8',
+		contractRootResolver: '0xeF727cb066Fee98F88Db84555830063b4A24ddfc',
+		contractAbiType: '0x7386fCBae6Ad4CCE1499d9153D99bc950B589718'
+	},
+	mainnet: {
+		rpc: 'https://optimism-rpc.publicnode.com',
+		contractDid: '0x5DA4Fa8E567d86e52Ef8Da860de1be8f54cae97D',
+		contractRootResolver: '0xE2EABA0979277A90511F8873ae1e8cA26B54E740',
+		contractAbiType: '0x9ae3F16bD99294Af1784beB1a0A5C84bf2636365'
+	}
+};
+
+interface CliOptions {
+	network: string;
+	rpc?: string;
+	contractDid?: string;
+	contractResolver?: string;
+	contractAbi?: string;
+	json: boolean;
+	verbose: boolean;
+	debug: boolean;
+	debugLevel: string;
+	help: boolean;
+}
+
+function parseArgs(): {
+	command: string;
+	domain?: string;
+	options: CliOptions;
+} {
+	const args = process.argv.slice(2);
+	const options: CliOptions = {
+		network: 'sepolia',
+		json: false,
+		verbose: false,
+		debug: false,
+		debugLevel: 'info',
+		help: false
+	};
+
+	let command = '';
+	let domain: string | undefined;
+
+	for (let i = 0; i < args.length; i++) {
+		const arg = args[i];
+
+		if (arg === '--help' || arg === '-h') {
+			options.help = true;
+		} else if (arg === '--version' || arg === '-V') {
+			console.log('0.1.0');
+			process.exit(0);
+		} else if (arg === '--network' || arg === '-n') {
+			options.network = args[++i] || 'sepolia';
+		} else if (arg === '--rpc') {
+			options.rpc = args[++i];
+		} else if (arg === '--contract-did') {
+			options.contractDid = args[++i];
+		} else if (arg === '--contract-resolver') {
+			options.contractResolver = args[++i];
+		} else if (arg === '--contract-abi') {
+			options.contractAbi = args[++i];
+		} else if (arg === '--json' || arg === '-j') {
+			options.json = true;
+		} else if (arg === '--verbose' || arg === '-v') {
+			options.verbose = true;
+		} else if (arg === '--debug') {
+			options.debug = true;
+		} else if (arg === '--debug-level') {
+			options.debugLevel = args[++i] || 'info';
+		} else if (!command) {
+			command = arg;
+		} else if (
+			!domain &&
+			(command === 'fetch' || command === 'fetch-domain')
+		) {
+			domain = arg;
+		}
+	}
+
+	return { command, domain, options };
+}
+
+function showHelp(): void {
+	console.log(`
+DID CLI Tool v0.1.0
+
+USAGE:
+  did-cli <command> [arguments] [options]
+
+COMMANDS:
+  fetch <domain>     Fetch domain information (alias: fetch-domain)
+  fetch-all          Fetch all domains from contract
+  config             Show network configurations
+  help               Show this help message
+
+ARGUMENTS:
+  <domain>           Domain name to fetch (e.g., example.olares.com)
+
+OPTIONS:
+  -n, --network <network>         Network to use (sepolia|mainnet) [default: sepolia]
+  --rpc <url>                     Custom RPC endpoint URL
+  --contract-did <address>        Custom DID contract address
+  --contract-resolver <address>   Custom RootResolver contract address
+  --contract-abi <address>        Custom ABIType contract address
+  -v, --verbose                   Enable verbose debug output
+  --debug                         Enable debug output
+  --debug-level <level>           Set debug level (debug|info|warn|error) [default: info]
+  -h, --help                      Show help message
+  -V, --version                   Show version number
+
+EXAMPLES:
+  did-cli fetch example.olares.com
+  did-cli fetch example.olares.com --network mainnet
+  did-cli fetch example.olares.com --json
+  did-cli fetch example.olares.com --debug
+  did-cli fetch-all --network sepolia
+  did-cli config
+`);
+}
+
+async function fetchDomain(domain: string, options: CliOptions): Promise<void> {
+	try {
+		// 设置调试选项
+		if (options.verbose || options.debug) {
+			debug.enable();
+			debug.setLevel(options.debugLevel as any);
+		}
+
+		// 确定网络配置
+		let config;
+		if (
+			options.rpc &&
+			options.contractDid &&
+			options.contractResolver &&
+			options.contractAbi
+		) {
+			// 使用自定义配置
+			config = {
+				rpc: options.rpc,
+				contractDid: options.contractDid,
+				contractRootResolver: options.contractResolver,
+				contractAbiType: options.contractAbi
+			};
+		} else if (NETWORKS[options.network as keyof typeof NETWORKS]) {
+			// 使用预设网络配置
+			config = NETWORKS[options.network as keyof typeof NETWORKS];
+		} else {
+			console.error(`❌ Unknown network: ${options.network}`);
+			console.error('Available networks: sepolia, mainnet');
+			process.exit(1);
+		}
+
+		if (debug.isEnabled()) {
+			debug.info(`🔍 Fetching domain: ${domain}`);
+			debug.info(`🌐 Network: ${options.network}`);
+			debug.info('Using configuration:', config);
+		}
+
+		// 创建DID控制台实例
+		const olaresId = OlaresID.createConsole(
+			config.rpc,
+			config.contractDid,
+			config.contractRootResolver,
+			config.contractAbiType
+		);
+
+		// 获取域名数据
+		const domainData = await olaresId.fetchDomain(domain);
+
+		if (!domainData) {
+			console.log(`❌ Domain not found: ${domain}`);
+			process.exit(1);
+		}
+
+		console.log(JSON.stringify(domainData, null, 2));
+	} catch (error) {
+		console.error(
+			'❌ Error fetching domain:',
+			error instanceof Error ? error.message : String(error)
+		);
+		if (debug.isEnabled()) {
+			debug.error('Full error details:', error);
+		}
+		process.exit(1);
+	}
+}
+
+async function main(): Promise<void> {
+	const { command, domain, options } = parseArgs();
+
+	if (options.help || !command || command === 'help') {
+		showHelp();
+		return;
+	}
+
+	switch (command) {
+		case 'fetch':
+		case 'fetch-domain':
+			if (!domain) {
+				console.error('❌ Error: Domain argument is required');
+				console.error('Usage: did-cli fetch <domain> [options]');
+				process.exit(1);
+			}
+			await fetchDomain(domain, options);
+			break;
+
+		default:
+			console.error(`❌ Unknown command: ${command}`);
+			console.error('Run "did-cli help" for usage information');
+			process.exit(1);
+	}
+}
+
+// 运行主函数
+main().catch((error) => {
+	console.error(
+		'❌ Unexpected error:',
+		error instanceof Error ? error.message : String(error)
+	);
+	process.exit(1);
+});

package/src/debug.ts

@@ -0,0 +1,170 @@
+/**
+ * Debug utility for DID system
+ * Provides separate debug logging without affecting normal console output
+ * Supports environment variables and command line arguments
+ */
+
+interface DebugConfig {
+	enabled: boolean;
+	level: 'debug' | 'info' | 'warn' | 'error';
+	prefix: string;
+}
+
+class DebugLogger {
+	private config: DebugConfig;
+
+	constructor() {
+		this.config = this.parseConfig();
+	}
+
+	private parseConfig(): DebugConfig {
+		// Check environment variables
+		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
+		const args = process.argv;
+		const hasDebugFlag = args.includes('--debug') || args.includes('-d');
+		const hasVerboseFlag =
+			args.includes('--verbose') || args.includes('-v');
+
+		// Parse debug level from command line
+		let cmdLevel: DebugConfig['level'] = 'debug';
+		const levelIndex = args.findIndex((arg) =>
+			arg.startsWith('--debug-level=')
+		);
+		if (levelIndex !== -1) {
+			const level = args[levelIndex].split(
+				'='
+			)[1] as DebugConfig['level'];
+			if (['debug', 'info', 'warn', 'error'].includes(level)) {
+				cmdLevel = level;
+			}
+		}
+
+		// Parse prefix from command line
+		let cmdPrefix = '[DID-DEBUG]';
+		const prefixIndex = args.findIndex((arg) =>
+			arg.startsWith('--debug-prefix=')
+		);
+		if (prefixIndex !== -1) {
+			cmdPrefix = args[prefixIndex].split('=')[1];
+		}
+
+		return {
+			enabled: envDebug || hasDebugFlag || hasVerboseFlag,
+			level: cmdLevel || envLevel,
+			prefix: cmdPrefix || envPrefix
+		};
+	}
+
+	private shouldLog(level: DebugConfig['level']): boolean {
+		if (!this.config.enabled) return false;
+
+		const levels = ['debug', 'info', 'warn', 'error'];
+		const currentLevelIndex = levels.indexOf(this.config.level);
+		const messageLevelIndex = levels.indexOf(level);
+
+		return messageLevelIndex >= currentLevelIndex;
+	}
+
+	private formatMessage(level: string, ...args: any[]): any[] {
+		const timestamp = new Date().toISOString();
+		const prefix = `${
+			this.config.prefix
+		} [${level.toUpperCase()}] [${timestamp}]`;
+		return [prefix, ...args];
+	}
+
+	// Debug logging methods - these are separate from console
+	public debug(...args: any[]): void {
+		if (this.shouldLog('debug')) {
+			console.debug(...this.formatMessage('debug', ...args));
+		}
+	}
+
+	public info(...args: any[]): void {
+		if (this.shouldLog('info')) {
+			console.info(...this.formatMessage('info', ...args));
+		}
+	}
+
+	public warn(...args: any[]): void {
+		if (this.shouldLog('warn')) {
+			console.warn(...this.formatMessage('warn', ...args));
+		}
+	}
+
+	public error(...args: any[]): void {
+		if (this.shouldLog('error')) {
+			console.error(...this.formatMessage('error', ...args));
+		}
+	}
+
+	public group(...args: any[]): void {
+		if (this.shouldLog('info')) {
+			console.group(...this.formatMessage('group', ...args));
+		}
+	}
+
+	public groupCollapsed(...args: any[]): void {
+		if (this.shouldLog('info')) {
+			console.groupCollapsed(...this.formatMessage('group', ...args));
+		}
+	}
+
+	public groupEnd(): void {
+		if (this.shouldLog('info')) {
+			console.groupEnd();
+		}
+	}
+
+	// Public methods for configuration control
+	public enable(): void {
+		this.config.enabled = true;
+	}
+
+	public disable(): void {
+		this.config.enabled = false;
+	}
+
+	public setLevel(level: DebugConfig['level']): void {
+		this.config.level = level;
+	}
+
+	public getConfig(): DebugConfig {
+		return { ...this.config };
+	}
+
+	public isEnabled(): boolean {
+		return this.config.enabled;
+	}
+}
+
+// Create singleton instance
+const debugLogger = new DebugLogger();
+
+// Export the debug logger instance and utility functions
+export const debug = {
+	// Logging methods
+	debug: (...args: any[]) => debugLogger.debug(...args),
+	info: (...args: any[]) => debugLogger.info(...args),
+	warn: (...args: any[]) => debugLogger.warn(...args),
+	error: (...args: any[]) => debugLogger.error(...args),
+	group: (...args: any[]) => debugLogger.group(...args),
+	groupCollapsed: (...args: any[]) => debugLogger.groupCollapsed(...args),
+	groupEnd: () => debugLogger.groupEnd(),
+
+	// Configuration methods
+	enable: () => debugLogger.enable(),
+	disable: () => debugLogger.disable(),
+	setLevel: (level: 'debug' | 'info' | 'warn' | 'error') =>
+		debugLogger.setLevel(level),
+	getConfig: () => debugLogger.getConfig(),
+	isEnabled: () => debugLogger.isEnabled()
+};
+
+export default debugLogger;