@beclab/olaresid 0.1.2 → 0.1.3

package/examples/olares-id-format.ts

@@ -0,0 +1,197 @@
+/**
+ * Example: Testing Olares ID Format Support
+ *
+ * This example demonstrates the new Olares ID format support.
+ * Olares ID uses @ instead of the first dot, making it look like an email address.
+ *
+ * Format conversion:
+ *   - Standard domain: alice.example.com
+ *   - Olares ID format: alice@example.com
+ *
+ * Both formats should work identically in the SDK and CLI.
+ */
+
+import OlaresID from '../src/index';
+import { normalizeToDomain, normalizeToOlaresId } from '../src/utils/olares-id';
+
+async function main() {
+	console.log('='.repeat(80));
+	console.log('Testing Olares ID Format Support');
+	console.log('='.repeat(80));
+
+	// Test 1: Utility Functions
+	console.log('\n📝 Test 1: Olares ID Utility Functions');
+	console.log('-'.repeat(80));
+
+	const testCases = [
+		{ input: 'alice@example.com', expected: 'alice.example.com' },
+		{ input: 'bob@sub.example.com', expected: 'bob.sub.example.com' },
+		{ input: 'charlie.example.com', expected: 'charlie.example.com' },
+		{ input: 'user@olares.com', expected: 'user.olares.com' }
+	];
+
+	console.log('Testing normalizeToDomain():');
+	for (const test of testCases) {
+		const result = normalizeToDomain(test.input);
+		const status = result === test.expected ? '✅' : '❌';
+		console.log(
+			`  ${status} normalizeToDomain('${test.input}') => '${result}' (expected: '${test.expected}')`
+		);
+	}
+
+	console.log('\nTesting normalizeToOlaresId():');
+	const domainToOlaresIdTests = [
+		{ input: 'alice.example.com', expected: 'alice@example.com' },
+		{ input: 'bob.sub.example.com', expected: 'bob@sub.example.com' }
+	];
+
+	for (const test of domainToOlaresIdTests) {
+		const result = normalizeToOlaresId(test.input);
+		const status = result === test.expected ? '✅' : '❌';
+		console.log(
+			`  ${status} normalizeToOlaresId('${test.input}') => '${result}' (expected: '${test.expected}')`
+		);
+	}
+
+	// Test 2: SDK with Olares ID Format
+	console.log('\n🔧 Test 2: SDK with Olares ID Format');
+	console.log('-'.repeat(80));
+
+	const didConsole = OlaresID.createTestnet();
+
+	// Use a real test domain (1.com is a common test domain on testnet)
+	const testDomainStandard = '1.com';
+	const testDomainOlaresId = '1@com'; // Olares ID format
+
+	console.log('\nTesting with standard domain format:', testDomainStandard);
+	try {
+		const domainStandard = didConsole.domain(testDomainStandard);
+		const metaStandard = await domainStandard.getMetaInfo();
+		console.log('✅ Standard format works:');
+		console.log('  Name:', metaStandard.name);
+		console.log('  DID:', metaStandard.did);
+		console.log('  Owner:', await domainStandard.getOwner());
+	} catch (error) {
+		console.error('❌ Standard format failed:', error);
+	}
+
+	console.log('\nTesting with Olares ID format:', testDomainOlaresId);
+	try {
+		const domainOlaresId = didConsole.domain(testDomainOlaresId);
+		const metaOlaresId = await domainOlaresId.getMetaInfo();
+		console.log('✅ Olares ID format works:');
+		console.log('  Name:', metaOlaresId.name);
+		console.log('  DID:', metaOlaresId.did);
+		console.log('  Owner:', await domainOlaresId.getOwner());
+	} catch (error) {
+		console.error('❌ Olares ID format failed:', error);
+	}
+
+	// Test 3: Verify Both Formats Return Same Data
+	console.log('\n🔍 Test 3: Verify Both Formats Return Same Data');
+	console.log('-'.repeat(80));
+
+	try {
+		const domainStandard = didConsole.domain(testDomainStandard);
+		const domainOlaresId = didConsole.domain(testDomainOlaresId);
+
+		const [metaStandard, metaOlaresId] = await Promise.all([
+			domainStandard.getMetaInfo(),
+			domainOlaresId.getMetaInfo()
+		]);
+
+		const ownerStandard = await domainStandard.getOwner();
+		const ownerOlaresId = await domainOlaresId.getOwner();
+
+		console.log('Comparing results:');
+		console.log(
+			`  Name match: ${
+				metaStandard.name === metaOlaresId.name ? '✅' : '❌'
+			} (${metaStandard.name} vs ${metaOlaresId.name})`
+		);
+		console.log(
+			`  DID match: ${
+				metaStandard.did === metaOlaresId.did ? '✅' : '❌'
+			}`
+		);
+		console.log(
+			`  Owner match: ${
+				ownerStandard === ownerOlaresId ? '✅' : '❌'
+			} (${ownerStandard} vs ${ownerOlaresId})`
+		);
+		console.log(
+			`  TokenId match: ${
+				domainStandard.getTokenId() === domainOlaresId.getTokenId()
+					? '✅'
+					: '❌'
+			}`
+		);
+	} catch (error) {
+		console.error('❌ Comparison failed:', error);
+	}
+
+	// Test 4: Multi-level Domain Support
+	console.log('\n🌳 Test 4: Multi-level Domain Support');
+	console.log('-'.repeat(80));
+
+	const multiLevelTests = [
+		{ standard: 'alice.example.com', olaresId: 'alice@example.com' },
+		{ standard: 'bob.sub.example.com', olaresId: 'bob@sub.example.com' },
+		{
+			standard: 'user.deep.nested.domain.com',
+			olaresId: 'user@deep.nested.domain.com'
+		}
+	];
+
+	for (const test of multiLevelTests) {
+		const normalized = normalizeToDomain(test.olaresId);
+		const matches = normalized === test.standard;
+		console.log(
+			`  ${matches ? '✅' : '❌'} ${
+				test.olaresId
+			} => ${normalized} (expected: ${test.standard})`
+		);
+	}
+
+	// Test 5: Edge Cases
+	console.log('\n⚠️  Test 5: Edge Cases');
+	console.log('-'.repeat(80));
+
+	const edgeCases = [
+		{ input: '', description: 'Empty string' },
+		{ input: 'nodot', description: 'No dot or @' },
+		{
+			input: 'multiple@at@signs.com',
+			description: 'Multiple @ signs (only first is converted)'
+		},
+		{ input: '.startswithdot', description: 'Starts with dot' },
+		{ input: '@startswithat', description: 'Starts with @' }
+	];
+
+	for (const test of edgeCases) {
+		try {
+			const result = normalizeToDomain(test.input);
+			console.log(
+				`  ℹ️  ${test.description}: '${test.input}' => '${result}'`
+			);
+		} catch (error) {
+			console.log(`  ℹ️  ${test.description}: Error - ${error}`);
+		}
+	}
+
+	console.log('\n' + '='.repeat(80));
+	console.log('✅ All Olares ID format tests completed!');
+	console.log('='.repeat(80));
+	console.log('\n💡 Key Takeaways:');
+	console.log(
+		'  • Both standard domain and Olares ID formats work identically'
+	);
+	console.log(
+		'  • Use alice@example.com instead of alice.example.com for a more intuitive format'
+	);
+	console.log('  • The conversion happens automatically in the SDK and CLI');
+	console.log('  • Only the first dot/@ is affected by the conversion');
+	console.log('='.repeat(80));
+}
+
+main().catch(console.error);

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@beclab/olaresid",
-    "version": "0.1.2",
+    "version": "0.1.3",
     "description": "DID Contract SDK with CLI tool",
     "main": "dist/index.js",
     "types": "dist/index.d.ts",

package/src/business/index.ts

@@ -3,6 +3,7 @@ import { ethers } from 'ethers';
 import { parseContractError } from '../utils/error-parser';
 import { TagContext } from './tag-context';
 import { TagTypeBuilder } from '../utils/tag-type-builder';
+import { normalizeToDomain } from '../utils/olares-id';
 
 export interface TransactionResult<T = any> {
 	// Basic transaction information
@@ -71,7 +72,8 @@ export class DomainContext {
 	private tokenId?: string;
 
 	constructor(domainName: string, console: DIDConsole) {
-		this.domainName = domainName;
+		// Support Olares ID format (user@domain.com) by converting to standard domain format
+		this.domainName = normalizeToDomain(domainName);
 		this.console = console;
 	}
 

package/src/business/tag-context.ts

@@ -3,13 +3,17 @@ import { TransactionResult } from './index';
 import { parseContractError } from '../utils/error-parser';
 import { TagTypeBuilder } from '../utils/tag-type-builder';
 import { TagAbiCodec } from '../utils/tag-abi-codec';
+import { normalizeToDomain } from '../utils/olares-id';
 
 /**
  * Tag Operation Context
  * Provides complete Tag management functionality
  */
 export class TagContext {
-	constructor(private console: DIDConsole, private fromDomain: string) {}
+	constructor(private console: DIDConsole, private fromDomain: string) {
+		// Support Olares ID format (user@domain.com)
+		this.fromDomain = normalizeToDomain(fromDomain);
+	}
 
 	// ========================================
 	// 1. Tag Type Definition Management
@@ -214,6 +218,9 @@ export class TagContext {
 		tagName: string,
 		value: any
 	): Promise<TransactionResult> {
+		// Support Olares ID format
+		toDomain = normalizeToDomain(toDomain);
+
 		const contract = this.console.getSignerContractDID();
 
 		// Get tag type
@@ -285,6 +292,9 @@ export class TagContext {
 	 * @returns Tag value, or null if not found
 	 */
 	async getTag(toDomain: string, tagName: string): Promise<any | null> {
+		// Support Olares ID format
+		toDomain = normalizeToDomain(toDomain);
+
 		try {
 			const contract = this.console.getContractDID();
 
@@ -332,6 +342,9 @@ export class TagContext {
 		toDomain: string,
 		tagName: string
 	): Promise<TransactionResult> {
+		// Support Olares ID format
+		toDomain = normalizeToDomain(toDomain);
+
 		try {
 			const contract = this.console.getSignerContractDID();
 			const tx = await contract.removeTag(
@@ -363,6 +376,9 @@ export class TagContext {
 	 * @returns Whether the tag exists
 	 */
 	async hasTag(toDomain: string, tagName: string): Promise<boolean> {
+		// Support Olares ID format
+		toDomain = normalizeToDomain(toDomain);
+
 		const contract = this.console.getContractDID();
 		return await contract.hasTag(this.fromDomain, toDomain, tagName);
 	}
@@ -373,6 +389,9 @@ export class TagContext {
 	 * @returns Array of Tag names
 	 */
 	async getTagNames(toDomain: string): Promise<string[]> {
+		// Support Olares ID format
+		toDomain = normalizeToDomain(toDomain);
+
 		const contract = this.console.getContractDID();
 		const count = await contract.getTagCount(this.fromDomain, toDomain);
 		const names: string[] = [];
@@ -433,6 +452,9 @@ export class TagContext {
 		value: any,
 		elemPath: number[] = []
 	): Promise<TransactionResult> {
+		// Support Olares ID format
+		toDomain = normalizeToDomain(toDomain);
+
 		const contract = this.console.getSignerContractDID();
 
 		// Get tag type and encode element
@@ -490,6 +512,9 @@ export class TagContext {
 		tagName: string,
 		elemPath: number[] = []
 	): Promise<TransactionResult> {
+		// Support Olares ID format
+		toDomain = normalizeToDomain(toDomain);
+
 		try {
 			const contract = this.console.getSignerContractDID();
 			const tx = await contract.popTagElem(
@@ -536,6 +561,9 @@ export class TagContext {
 		elemPath: number[],
 		value: any
 	): Promise<TransactionResult> {
+		// Support Olares ID format
+		toDomain = normalizeToDomain(toDomain);
+
 		const contract = this.console.getSignerContractDID();
 
 		const tagTypeInfo = await this.getTagType(tagName);
@@ -592,6 +620,9 @@ export class TagContext {
 		tagName: string,
 		elemPath: number[] = []
 	): Promise<number> {
+		// Support Olares ID format
+		toDomain = normalizeToDomain(toDomain);
+
 		const contract = this.console.getContractDID();
 		const length = await contract.getTagElemLength(
 			this.fromDomain,
@@ -621,6 +652,9 @@ export class TagContext {
 		tagName: string,
 		elemPath: number[]
 	): Promise<any | null> {
+		// Support Olares ID format
+		toDomain = normalizeToDomain(toDomain);
+
 		try {
 			const contract = this.console.getContractDID();
 

package/src/cli.ts

@@ -15,6 +15,7 @@ import OlaresID, {
 	TagTypeBuilder
 } from './index';
 import { debug } from './debug';
+import { normalizeToDomain } from './utils/olares-id';
 import * as fs from 'fs';
 import * as path from 'path';
 
@@ -155,6 +156,11 @@ DID CLI Tool v${CLI_VERSION}
 USAGE:
   did-cli <command> [subcommand] [arguments] [options]
 
+NOTE:
+  Olares ID Format: You can use @ instead of the first dot in domain names.
+  Example: alice@example.com is equivalent to alice.example.com
+  Both formats work identically in all commands!
+
 COMMANDS:
   Query Commands:
     info <domain>              Get domain metadata
@@ -261,6 +267,14 @@ EXAMPLES:
   export PRIVATE_KEY_OR_MNEMONIC=0xYOUR_PRIVATE_KEY
   did-cli is-owner example.olares.com
   
+  # Olares ID format (use @ instead of first dot - like email addresses!)
+  # Both formats work identically: alice.example.com = alice@example.com
+  did-cli info alice@example.com
+  did-cli owner bob@sub.example.com
+  did-cli rsa get user@domain.com
+  did-cli ip set alice@example.com 192.168.1.100
+  did-cli tag get alice@example.com email
+  
   # RSA key management
   did-cli rsa generate --output ./my-key.pem --key-length 4096
   did-cli rsa get example.olares.com
@@ -2266,7 +2280,10 @@ async function tagGetTagger(
 }
 
 async function main(): Promise<void> {
-	const { command, subCommand, domain, value, options } = parseArgs();
+	const parsed = parseArgs();
+	const { command, subCommand, value, options } = parsed;
+	// Support Olares ID format (user@domain.com) by converting to standard domain format
+	const domain = parsed.domain ? normalizeToDomain(parsed.domain) : undefined;
 
 	if (options.help || !command || command === 'help') {
 		showHelp();

package/src/index.ts

@@ -6,6 +6,7 @@ import RootResolverABI from './abi/RootResolverABI';
 import RootResolver2ABI from './abi/RootResolver2ABI';
 import { debug } from './debug';
 import { parseContractError } from './utils/error-parser';
+import { normalizeToDomain } from './utils/olares-id';
 
 import {
 	DomainContext,
@@ -289,13 +290,16 @@ export class DIDConsole implements DIDTag.ABITypeProviderHolder {
 
 	fetchDomain = (name: string) =>
 		new Promise<Domain | undefined>(async (resolve, reject) => {
+			// Support Olares ID format (user@domain.com)
+			const normalizedName = normalizeToDomain(name);
+
 			debug.group('fetchDomain');
 			const hasCache = this.allDomainCache.length > 0;
 			debug.info('fetchDomain--->hasCache', hasCache);
 
 			if (hasCache) {
 				const domain = PackageDomain.findASubtree(
-					name,
+					normalizedName,
 					this.allDomainCache
 				);
 
@@ -303,7 +307,7 @@ export class DIDConsole implements DIDTag.ABITypeProviderHolder {
 				resolve(domain);
 			} else {
 				const domain = await PackageDomain.syncByName(
-					name,
+					normalizedName,
 					await this.getContractDID()
 				);
 
@@ -314,8 +318,11 @@ export class DIDConsole implements DIDTag.ABITypeProviderHolder {
 
 	updateDomain = (name: string) =>
 		new Promise<Domain>(async (resolve, reject) => {
+			// Support Olares ID format (user@domain.com)
+			const normalizedName = normalizeToDomain(name);
+
 			const domain = await PackageDomain.syncByName(
-				name,
+				normalizedName,
 				await this.getContractDID()
 			);
 
@@ -585,4 +592,7 @@ export { debug } from './debug';
 // Export Tag utilities outside namespace
 export { TagTypeBuilder, TagAbiCodec };
 
+// Export Olares ID utilities
+export { normalizeToDomain, normalizeToOlaresId } from './utils/olares-id';
+
 export default OlaresID;

package/src/utils/olares-id.ts

@@ -0,0 +1,49 @@
+/**
+ * Olares ID Utilities
+ *
+ * Olares ID is a new format that looks like email addresses: user@domain.com
+ * It's essentially a domain name where the first dot (.) is replaced with an at sign (@)
+ *
+ * Examples:
+ *   - alice.example.com → alice@example.com (Olares ID)
+ *   - bob.sub.example.com → bob@sub.example.com (Olares ID)
+ */
+
+/**
+ * Convert Olares ID format to standard domain format
+ * Replaces the first @ with a dot (.)
+ *
+ * @param input The input string (can be either Olares ID or domain format)
+ * @returns The normalized domain format
+ *
+ * @example
+ * normalizeToDomain('alice@example.com') // returns 'alice.example.com'
+ * normalizeToDomain('alice.example.com') // returns 'alice.example.com' (no change)
+ * normalizeToDomain('bob@sub.example.com') // returns 'bob.sub.example.com'
+ */
+export function normalizeToDomain(input: string): string {
+	if (!input) {
+		return input;
+	}
+	// Replace the first @ with a dot
+	return input.replace('@', '.');
+}
+
+/**
+ * Convert standard domain format to Olares ID format
+ * Replaces the first dot (.) with an at sign (@)
+ *
+ * @param domain The domain name
+ * @returns The Olares ID format
+ *
+ * @example
+ * normalizeToOlaresId('alice.example.com') // returns 'alice@example.com'
+ * normalizeToOlaresId('bob.sub.example.com') // returns 'bob@sub.example.com'
+ */
+export function normalizeToOlaresId(domain: string): string {
+	if (!domain) {
+		return domain;
+	}
+	// Replace the first dot with @
+	return domain.replace('.', '@');
+}