@beclab/olaresid 0.1.2 → 0.1.4

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,29 +6,9 @@ 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,
-	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 { DomainContext, TransactionResult } from './business';
 
 // Import Tag utilities
 import { TagTypeBuilder } from './utils/tag-type-builder';
@@ -57,7 +37,8 @@ export {
 	getEVMPrivateKeyFromMnemonic,
 	getDIDFromMnemonic,
 	generateDIDKeyData,
-	deriveDIDFromMnemonic
+	deriveDIDFromMnemonic,
+	getEd25519JwkFromMnemonic
 } from './business';
 
 type Domain = PackageDomain.Domain;
@@ -289,13 +270,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 +287,7 @@ export class DIDConsole implements DIDTag.ABITypeProviderHolder {
 				resolve(domain);
 			} else {
 				const domain = await PackageDomain.syncByName(
-					name,
+					normalizedName,
 					await this.getContractDID()
 				);
 
@@ -314,8 +298,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 +572,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/crypto-utils.ts

@@ -8,43 +8,13 @@
 
 import * as bip39 from 'bip39';
 import * as varint from 'varint';
+import { base58btc } from 'multiformats/bases/base58';
+import { base64url } from 'multiformats/bases/base64';
 
 // Browser globals type declaration
 declare const window: any;
 declare const btoa: (input: string) => string;
 
-// Base58 Bitcoin alphabet
-const BASE58_ALPHABET =
-	'123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz';
-
-/**
- * Encode bytes to base58btc format
- * This is a pure implementation compatible with multiformats/bases/base58
- */
-function base58Encode(bytes: Uint8Array): string {
-	// Convert bytes to bigint
-	let num = 0n;
-	for (let i = 0; i < bytes.length; i++) {
-		num = num * 256n + BigInt(bytes[i]);
-	}
-
-	// Convert to base58
-	let encoded = '';
-	while (num > 0n) {
-		const remainder = Number(num % 58n);
-		encoded = BASE58_ALPHABET[remainder] + encoded;
-		num = num / 58n;
-	}
-
-	// Add leading '1's for leading zero bytes
-	for (let i = 0; i < bytes.length && bytes[i] === 0; i++) {
-		encoded = '1' + encoded;
-	}
-
-	// Add 'z' prefix for base58btc multibase
-	return 'z' + encoded;
-}
-
 export interface RSAPublicKeyData {
 	rsaPublicKey: string;
 	rsaPrivateKey: string;
@@ -239,7 +209,7 @@ async function getID(mnemonic: string): Promise<string> {
 	idBytes.set(publicKey.data(), ED25519_CODEC_ID.length);
 
 	// Encode to base58btc
-	const id = base58Encode(idBytes);
+	const id = base58btc.encode(idBytes);
 	return id;
 }
 
@@ -268,6 +238,93 @@ export async function getDIDFromMnemonic(mnemonic: string): Promise<string> {
 	return `did:key:${id}`;
 }
 
+/**
+ * Generate Ed25519 JWK (JSON Web Key) from BIP39 mnemonic phrase
+ * Uses Trust Wallet Core for key derivation, ensuring compatibility with TermiPass
+ *
+ * @param mnemonic BIP39 mnemonic phrase (12, 15, 18, 21, or 24 words)
+ * @returns Object containing publicJwk and privateJwk in RFC 7517 format
+ *
+ * @example
+ * ```typescript
+ * const { publicJwk, privateJwk } = await getEd25519JwkFromMnemonic(mnemonic);
+ *
+ * // Public JWK (safe to share)
+ * console.log(publicJwk);
+ * // {
+ * //   "kty": "OKP",
+ * //   "crv": "Ed25519",
+ * //   "alg": "EdDSA",
+ * //   "use": "sig",
+ * //   "kid": "did:key:z6Mk...#z6Mk...",
+ * //   "x": "base64url-encoded-public-key"
+ * // }
+ *
+ * // Private JWK (keep secure!)
+ * console.log(privateJwk);
+ * // {
+ * //   "kty": "OKP",
+ * //   "crv": "Ed25519",
+ * //   "alg": "EdDSA",
+ * //   "use": "sig",
+ * //   "kid": "did:key:z6Mk...#z6Mk...",
+ * //   "x": "base64url-encoded-public-key",
+ * //   "d": "base64url-encoded-private-key"
+ * // }
+ * ```
+ */
+export async function getEd25519JwkFromMnemonic(mnemonic: string): Promise<{
+	publicJwk: any;
+	privateJwk: any;
+}> {
+	// Validate mnemonic
+	if (!bip39.validateMnemonic(mnemonic)) {
+		throw new Error('Invalid mnemonic phrase');
+	}
+
+	const core = await loadWalletCore();
+	const { HDWallet, Curve } = core;
+
+	const wallet = HDWallet.createWithMnemonic(mnemonic, '');
+	const privateKey = wallet.getMasterKey(Curve.ed25519);
+	const publicKey = privateKey.getPublicKeyEd25519();
+
+	// Get key data
+	const publicKeyBytes = publicKey.data();
+	const privateKeyBytes = privateKey.data();
+
+	const idBytes = new Uint8Array(
+		publicKeyBytes.length + ED25519_CODEC_ID.length
+	);
+	idBytes.set(ED25519_CODEC_ID, 0);
+	idBytes.set(publicKeyBytes, ED25519_CODEC_ID.length);
+	const id = base58btc.encode(idBytes);
+	const did = `did:key:${id}`;
+	const keyId = `${did}#${id}`;
+
+	// Base64url encode the keys
+	const x = base64url.baseEncode(publicKeyBytes);
+	const d = base64url.baseEncode(privateKeyBytes);
+
+	// Public JWK (contains only public key material)
+	const publicJwk = {
+		kty: 'OKP', // Key Type: Octet Key Pair
+		crv: 'Ed25519', // Curve: Ed25519
+		alg: 'EdDSA', // Algorithm: EdDSA
+		use: 'sig', // Use: signature
+		kid: keyId, // Key ID
+		x: x // Public key parameter
+	};
+
+	// Private JWK (contains both public and private key material)
+	const privateJwk = {
+		...publicJwk,
+		d: d // Private key parameter
+	};
+
+	return { publicJwk, privateJwk };
+}
+
 /**
  * Derive both owner (Ethereum address) and DID from existing mnemonic
  *

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('.', '@');
+}