@beclab/olaresid 0.1.4 → 0.1.5

package/src/business/index.ts

@@ -4,6 +4,12 @@ import { parseContractError } from '../utils/error-parser';
 import { TagContext } from './tag-context';
 import { TagTypeBuilder } from '../utils/tag-type-builder';
 import { normalizeToDomain } from '../utils/olares-id';
+import {
+	base64ToUint8Array,
+	uint8ArrayToHex,
+	hexToUint8Array,
+	uint8ArrayToBase64
+} from '../utils/crypto-utils';
 
 export interface TransactionResult<T = any> {
 	// Basic transaction information
@@ -48,7 +54,11 @@ export {
 	getDIDFromMnemonic,
 	generateDIDKeyData,
 	deriveDIDFromMnemonic,
-	getEd25519JwkFromMnemonic
+	getEd25519JwkFromMnemonic,
+	base64ToUint8Array,
+	uint8ArrayToHex,
+	hexToUint8Array,
+	uint8ArrayToBase64
 } from '../utils/crypto-utils';
 export type { RSAPublicKeyData, DIDKeyData } from '../utils/crypto-utils';
 
@@ -180,7 +190,7 @@ export class DomainContext {
 	 * ```typescript
 	 * // For parent domain "parent.com", register subdomain "child"
 	 * const parentDomain = olaresId.domain('parent.com');
-	 * const mnemonic = generateMnemonic(12);
+	 * const mnemonic = await generateMnemonic(12);
 	 *
 	 * const result = await parentDomain.registerSubdomain('child', mnemonic);
 	 * // This will register "child.parent.com"
@@ -266,7 +276,7 @@ export class DomainContext {
 	 *
 	 * @example
 	 * ```typescript
-	 * const mnemonic = generateMnemonic(12);
+	 * const mnemonic = await generateMnemonic(12);
 	 * const result = await domain.transfer(mnemonic);
 	 * if (result.success) {
 	 *   console.log('Domain transferred!');
@@ -846,18 +856,22 @@ export class DomainContext {
 			const { Keypair } = await import('@solana/web3.js');
 			const nacl = await import('tweetnacl');
 			const { decodeUTF8 } = await import('tweetnacl-util');
+			const { base58btc } = await import('multiformats/bases/base58');
 
 			// Parse Solana private key (support both base58 and base64)
 			let solanaWallet: any;
 			try {
 				// Try base58 first (most common format for Phantom)
-				const bs58 = await import('bs58');
-				const secretKey = bs58.default.decode(solanaPrivateKey);
+				// Solana uses plain base58, but multiformats requires 'z' prefix for multibase
+				const base58Key = solanaPrivateKey.startsWith('z')
+					? solanaPrivateKey
+					: 'z' + solanaPrivateKey;
+				const secretKey = base58btc.decode(base58Key);
 				solanaWallet = Keypair.fromSecretKey(secretKey);
 			} catch {
 				// Try base64
 				try {
-					const secretKey = Buffer.from(solanaPrivateKey, 'base64');
+					const secretKey = base64ToUint8Array(solanaPrivateKey);
 					solanaWallet = Keypair.fromSecretKey(secretKey);
 				} catch {
 					// Try as JSON array
@@ -868,9 +882,9 @@ export class DomainContext {
 				}
 			}
 
-			// Get Solana address as bytes32
+			// Get Solana address as bytes32 (cross-platform)
 			const solanaAddressBytes =
-				'0x' + solanaWallet.publicKey.toBuffer().toString('hex');
+				'0x' + uint8ArrayToHex(solanaWallet.publicKey.toBytes());
 
 			// Get current timestamp
 			const signAt = Math.floor(Date.now() / 1000) - 30 * 60; // 30 minutes ago
@@ -930,8 +944,8 @@ export class DomainContext {
 				decodeUTF8(solanaMsg),
 				solanaWallet.secretKey
 			);
-			const sigFromAuthAddrHex =
-				'0x' + Buffer.from(sigFromAuthAddr).toString('hex');
+			// Convert signature to hex (cross-platform)
+			const sigFromAuthAddrHex = '0x' + uint8ArrayToHex(sigFromAuthAddr);
 
 			// Call contract
 			const tx = await rootTagger.updateSolanaWallet(
@@ -979,18 +993,22 @@ export class DomainContext {
 		try {
 			// Import Solana libraries dynamically
 			const { Keypair } = await import('@solana/web3.js');
+			const { base58btc } = await import('multiformats/bases/base58');
 
 			// Parse Solana private key
 			let solanaWallet: any;
 			try {
 				// Try base58 first
-				const bs58 = await import('bs58');
-				const secretKey = bs58.default.decode(solanaPrivateKey);
+				// Solana uses plain base58, but multiformats requires 'z' prefix for multibase
+				const base58Key = solanaPrivateKey.startsWith('z')
+					? solanaPrivateKey
+					: 'z' + solanaPrivateKey;
+				const secretKey = base58btc.decode(base58Key);
 				solanaWallet = Keypair.fromSecretKey(secretKey);
 			} catch {
 				// Try base64
 				try {
-					const secretKey = Buffer.from(solanaPrivateKey, 'base64');
+					const secretKey = base64ToUint8Array(solanaPrivateKey);
 					solanaWallet = Keypair.fromSecretKey(secretKey);
 				} catch {
 					// Try as JSON array
@@ -1001,9 +1019,9 @@ export class DomainContext {
 				}
 			}
 
-			// Get Solana address as bytes32
+			// Get Solana address as bytes32 (cross-platform)
 			const solanaAddressBytes =
-				'0x' + solanaWallet.publicKey.toBuffer().toString('hex');
+				'0x' + uint8ArrayToHex(solanaWallet.publicKey.toBytes());
 
 			// Get current timestamp
 			const signAt = Math.floor(Date.now() / 1000) - 30 * 60; // 30 minutes ago
@@ -1104,11 +1122,8 @@ export class DomainContext {
 			// Extract addresses from the result and convert to base58
 			// Result is array of { algorithm, addr } where addr is bytes32
 			return result.map((item: any) => {
-				// Remove 0x prefix and convert hex to buffer
-				const hexStr = item.addr.startsWith('0x')
-					? item.addr.slice(2)
-					: item.addr;
-				const buffer = Buffer.from(hexStr, 'hex');
+				// Convert hex to Uint8Array (cross-platform)
+				const buffer = hexToUint8Array(item.addr);
 				// Convert to Solana public key and then to base58
 				return new PublicKey(buffer).toBase58();
 			});
@@ -1423,26 +1438,16 @@ export function bytes4ToIpv4(bytes4Hex: string): string {
  */
 export function pemToDer(pem: string): string {
 	// Remove PEM headers, footers, and whitespace
-	const base64 = pem
+	const base64Str = pem
 		.replace(/-----BEGIN.*?-----/g, '')
 		.replace(/-----END.*?-----/g, '')
 		.replace(/\s/g, '');
 
-	// Convert base64 to hex
-	let hexString: string;
-
-	// Check if running in Node.js or browser
-	if (typeof Buffer !== 'undefined') {
-		// Node.js environment
-		const derBuffer = Buffer.from(base64, 'base64');
-		hexString = derBuffer.toString('hex');
-	} else {
-		// Browser environment
-		const binaryString = atob(base64);
-		hexString = Array.from(binaryString, (char) =>
-			char.charCodeAt(0).toString(16).padStart(2, '0')
-		).join('');
-	}
+	// Convert base64 to Uint8Array using cross-platform method
+	const derBuffer = base64ToUint8Array(base64Str);
+
+	// Convert to hex string
+	const hexString = uint8ArrayToHex(derBuffer);
 
 	// Convert to hex string with 0x prefix
 	return '0x' + hexString;
@@ -1457,31 +1462,14 @@ export function derToPem(derHex: string): string {
 	// Remove '0x' prefix if present
 	const hexString = derHex.startsWith('0x') ? derHex.slice(2) : derHex;
 
-	// Convert hex to base64
-	let base64: string;
-
-	// Check if running in Node.js or browser
-	if (typeof Buffer !== 'undefined') {
-		// Node.js environment
-		const derBuffer = Buffer.from(hexString, 'hex');
-		base64 = derBuffer.toString('base64');
-	} else {
-		// Browser environment
-		// Convert hex string to byte array
-		const bytes = new Uint8Array(hexString.length / 2);
-		for (let i = 0; i < hexString.length; i += 2) {
-			bytes[i / 2] = parseInt(hexString.substr(i, 2), 16);
-		}
-		// Convert byte array to binary string
-		const binaryString = String.fromCharCode(...bytes);
-		// Convert to base64
-		base64 = btoa(binaryString);
-	}
+	// Convert hex to base64 using cross-platform methods
+	const bytes = hexToUint8Array(hexString);
+	const base64Str = uint8ArrayToBase64(bytes);
 
 	// Split base64 into 64-character lines for PEM format
 	const lines: string[] = [];
-	for (let i = 0; i < base64.length; i += 64) {
-		lines.push(base64.slice(i, i + 64));
+	for (let i = 0; i < base64Str.length; i += 64) {
+		lines.push(base64Str.slice(i, i + 64));
 	}
 
 	// Construct PEM format with headers and footers

package/src/cli.ts

@@ -1014,7 +1014,7 @@ async function registerSubdomain(
 				);
 				process.exit(1);
 			}
-			mnemonic = generateMnemonic(wordCount);
+			mnemonic = await generateMnemonic(wordCount);
 
 			// Save mnemonic to file
 			const mnemonicFile = './subdomain-mnemonic.txt';
@@ -1141,7 +1141,7 @@ async function transferDomain(
 				);
 				process.exit(1);
 			}
-			mnemonic = generateMnemonic(wordCount);
+			mnemonic = await generateMnemonic(wordCount);
 
 			// Save mnemonic to file
 			const mnemonicFile = './transfer-new-owner-mnemonic.txt';
@@ -1228,7 +1228,7 @@ async function cryptoGenerate(options: CliOptions): Promise<void> {
 			process.exit(1);
 		}
 
-		const mnemonic = generateMnemonic(wordCount);
+		const mnemonic = await generateMnemonic(wordCount);
 
 		// Save mnemonic to file
 		const outputFile = options.output || './mnemonic.txt';

package/src/index.ts

@@ -38,7 +38,12 @@ export {
 	getDIDFromMnemonic,
 	generateDIDKeyData,
 	deriveDIDFromMnemonic,
-	getEd25519JwkFromMnemonic
+	getEd25519JwkFromMnemonic,
+	// Cross-platform encoding utilities
+	base64ToUint8Array,
+	uint8ArrayToHex,
+	hexToUint8Array,
+	uint8ArrayToBase64
 } from './business';
 
 type Domain = PackageDomain.Domain;

package/src/utils/crypto-utils.ts

@@ -6,13 +6,13 @@
  * compatibility across the entire Olares ecosystem.
  */
 
-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 atob: (input: string) => string;
 declare const btoa: (input: string) => string;
 
 export interface RSAPublicKeyData {
@@ -26,6 +26,61 @@ export interface DIDKeyData {
 	mnemonic: string;
 }
 
+// ============================================================================
+// Cross-platform encoding utilities (Browser + Node.js compatible)
+// ============================================================================
+
+/**
+ * Convert base64 string to Uint8Array (cross-platform)
+ * Works in both browser and Node.js environments
+ * @param base64 base64 encoded string
+ * @returns Uint8Array
+ */
+export function base64ToUint8Array(base64: string): Uint8Array {
+	const binaryString = atob(base64);
+	const bytes = new Uint8Array(binaryString.length);
+	for (let i = 0; i < binaryString.length; i++) {
+		bytes[i] = binaryString.charCodeAt(i);
+	}
+	return bytes;
+}
+
+/**
+ * Convert Uint8Array to hex string (cross-platform)
+ * @param bytes Uint8Array to convert
+ * @returns hex string without '0x' prefix
+ */
+export function uint8ArrayToHex(bytes: Uint8Array): string {
+	return Array.from(bytes)
+		.map((b) => b.toString(16).padStart(2, '0'))
+		.join('');
+}
+
+/**
+ * Convert hex string to Uint8Array (cross-platform)
+ * @param hex hex string (with or without '0x' prefix)
+ * @returns Uint8Array
+ */
+export function hexToUint8Array(hex: string): Uint8Array {
+	const cleanHex = hex.startsWith('0x') ? hex.slice(2) : hex;
+	const bytes = new Uint8Array(cleanHex.length / 2);
+	for (let i = 0; i < cleanHex.length; i += 2) {
+		bytes[i / 2] = parseInt(cleanHex.slice(i, i + 2), 16);
+	}
+	return bytes;
+}
+
+/**
+ * Convert Uint8Array to base64 string (cross-platform)
+ * Works in both browser and Node.js environments
+ * @param bytes Uint8Array to convert
+ * @returns base64 encoded string
+ */
+export function uint8ArrayToBase64(bytes: Uint8Array): string {
+	const binaryString = String.fromCharCode(...bytes);
+	return btoa(binaryString);
+}
+
 // ============================================================================
 // Trust Wallet Core Management
 // ============================================================================
@@ -52,19 +107,9 @@ async function loadWalletCore(): Promise<any> {
 	// Start loading
 	loadingPromise = (async () => {
 		try {
-			// Check if running in browser or Node.js
-			if (
-				typeof window !== 'undefined' &&
-				typeof require === 'undefined'
-			) {
-				// Browser environment with ES modules
-				const { initWasm } = await import('@trustwallet/wallet-core');
-				walletCore = await initWasm();
-			} else {
-				// Node.js environment
-				const { initWasm } = require('@trustwallet/wallet-core');
-				walletCore = await initWasm();
-			}
+			// Dynamic import works in both Node.js ESM and browser ESM
+			const { initWasm } = await import('@trustwallet/wallet-core');
+			walletCore = await initWasm();
 
 			walletCoreLoaded = true;
 			return walletCore;
@@ -84,23 +129,38 @@ async function loadWalletCore(): Promise<any> {
 // multicodec code for Ed25519 keys (0xed)
 const ED25519_CODEC_ID = varint.encode(parseInt('0xed', 16));
 
+/**
+ * Simple mnemonic validation (checks word count)
+ * @param mnemonic BIP39 mnemonic phrase
+ * @returns true if mnemonic has valid word count (12, 15, 18, 21, or 24 words)
+ */
+function validateMnemonic(mnemonic: string): boolean {
+	const words = mnemonic.trim().split(/\s+/);
+	const validWordCounts = [12, 15, 18, 21, 24];
+	return validWordCounts.includes(words.length);
+}
+
 // ============================================================================
 // Mnemonic and Key Derivation Functions
 // ============================================================================
 
 /**
- * Generate a random BIP39 mnemonic phrase
+ * Generate a random BIP39 mnemonic phrase using Trust Wallet Core
+ * Works in both Node.js and browser environments
+ *
  * @param wordCount Number of words (12, 15, 18, 21, or 24), default is 12
- * @returns A mnemonic phrase string
+ * @returns A promise that resolves to a mnemonic phrase string
  *
  * @example
  * ```typescript
- * const mnemonic = generateMnemonic(12);
+ * const mnemonic = await generateMnemonic(12);
  * console.log(mnemonic);
  * // Output: "abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon about"
  * ```
  */
-export function generateMnemonic(wordCount: number = 12): string {
+export async function generateMnemonic(
+	wordCount: number = 12
+): Promise<string> {
 	// Convert word count to entropy bits
 	// 12 words = 128 bits, 15 words = 160 bits, etc.
 	const strengthMap: Record<number, number> = {
@@ -118,7 +178,14 @@ export function generateMnemonic(wordCount: number = 12): string {
 		);
 	}
 
-	return bip39.generateMnemonic(strength);
+	// Ensure Wallet Core is loaded
+	const core = await loadWalletCore();
+	const { HDWallet } = core;
+
+	const wallet = HDWallet.create(strength, '');
+	const mnemonic = wallet.mnemonic();
+
+	return mnemonic;
 }
 
 /**
@@ -138,8 +205,10 @@ export async function getEthereumAddressFromMnemonic(
 	mnemonic: string
 ): Promise<string> {
 	// Validate mnemonic
-	if (!bip39.validateMnemonic(mnemonic)) {
-		throw new Error('Invalid mnemonic phrase');
+	if (!validateMnemonic(mnemonic)) {
+		throw new Error(
+			'Invalid mnemonic phrase: must have 12, 15, 18, 21, or 24 words'
+		);
 	}
 
 	const core = await loadWalletCore();
@@ -167,8 +236,10 @@ export async function getEVMPrivateKeyFromMnemonic(
 	mnemonic: string
 ): Promise<string> {
 	// Validate mnemonic
-	if (!bip39.validateMnemonic(mnemonic)) {
-		throw new Error('Invalid mnemonic phrase');
+	if (!validateMnemonic(mnemonic)) {
+		throw new Error(
+			'Invalid mnemonic phrase: must have 12, 15, 18, 21, or 24 words'
+		);
 	}
 
 	const core = await loadWalletCore();
@@ -179,9 +250,9 @@ export async function getEVMPrivateKeyFromMnemonic(
 	// Get private key for Ethereum
 	const privateKeyData = wallet.getKeyForCoin(CoinType.ethereum);
 
-	// Convert to hex string with 0x prefix
-	const privateKeyHex =
-		'0x' + Buffer.from(privateKeyData.data()).toString('hex');
+	// Convert to hex string with 0x prefix (cross-platform)
+	const privateKeyBytes = new Uint8Array(privateKeyData.data());
+	const privateKeyHex = '0x' + uint8ArrayToHex(privateKeyBytes);
 
 	return privateKeyHex;
 }
@@ -230,8 +301,10 @@ async function getID(mnemonic: string): Promise<string> {
  */
 export async function getDIDFromMnemonic(mnemonic: string): Promise<string> {
 	// Validate mnemonic
-	if (!bip39.validateMnemonic(mnemonic)) {
-		throw new Error('Invalid mnemonic phrase');
+	if (!validateMnemonic(mnemonic)) {
+		throw new Error(
+			'Invalid mnemonic phrase: must have 12, 15, 18, 21, or 24 words'
+		);
 	}
 
 	const id = await getID(mnemonic);
@@ -278,8 +351,10 @@ export async function getEd25519JwkFromMnemonic(mnemonic: string): Promise<{
 	privateJwk: any;
 }> {
 	// Validate mnemonic
-	if (!bip39.validateMnemonic(mnemonic)) {
-		throw new Error('Invalid mnemonic phrase');
+	if (!validateMnemonic(mnemonic)) {
+		throw new Error(
+			'Invalid mnemonic phrase: must have 12, 15, 18, 21, or 24 words'
+		);
 	}
 
 	const core = await loadWalletCore();
@@ -343,8 +418,10 @@ export async function deriveDIDFromMnemonic(mnemonic: string): Promise<{
 	did: string;
 }> {
 	// Validate mnemonic once upfront
-	if (!bip39.validateMnemonic(mnemonic)) {
-		throw new Error('Invalid mnemonic phrase');
+	if (!validateMnemonic(mnemonic)) {
+		throw new Error(
+			'Invalid mnemonic phrase: must have 12, 15, 18, 21, or 24 words'
+		);
 	}
 
 	// Derive both in parallel for better performance
@@ -373,7 +450,7 @@ export async function deriveDIDFromMnemonic(mnemonic: string): Promise<{
 export async function generateDIDKeyData(
 	wordCount: number = 12
 ): Promise<DIDKeyData> {
-	const mnemonic = generateMnemonic(wordCount);
+	const mnemonic = await generateMnemonic(wordCount);
 	const { owner, did } = await deriveDIDFromMnemonic(mnemonic);
 
 	return {