@beclab/olaresid 0.1.6 → 0.1.8

package/src/index.ts

@@ -38,12 +38,7 @@ export {
 	getDIDFromMnemonic,
 	generateDIDKeyData,
 	deriveDIDFromMnemonic,
-	getEd25519JwkFromMnemonic,
-	// Cross-platform encoding utilities
-	base64ToUint8Array,
-	uint8ArrayToHex,
-	hexToUint8Array,
-	uint8ArrayToBase64
+	getEd25519JwkFromMnemonic
 } from './business';
 
 type Domain = PackageDomain.Domain;
@@ -518,6 +513,76 @@ export class DIDConsole implements DIDTag.ABITypeProviderHolder {
 			throw new Error(parsedError.message);
 		}
 	}
+
+	/**
+	 * Transfer contract ownership to a new owner
+	 * Only the current contract owner can call this method
+	 * The new owner must call acceptOwnership() to complete the transfer
+	 * @param newOwner The address of the new owner
+	 * @returns Transaction result
+	 */
+	async transferOwnership(newOwner: string): Promise<TransactionResult> {
+		try {
+			const contract = this.getSignerContractDID();
+			const tx = await contract.transferOwnership(newOwner);
+			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
+			};
+		}
+	}
+
+	/**
+	 * Accept ownership transfer
+	 * Must be called by the pending owner to complete the ownership transfer
+	 * @returns Transaction result
+	 */
+	async acceptOwnership(): Promise<TransactionResult> {
+		try {
+			const contract = this.getSignerContractDID();
+			const tx = await contract.acceptOwnership();
+			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
+			};
+		}
+	}
 }
 
 namespace OlaresID {

package/src/tag/tuple.ts

@@ -76,8 +76,8 @@ export class Tuple extends Box {
 				//     indexInBox = index
 				// }
 
-				tag.setFieldNames(names, indexInBox);
-				index++;
+				const nextIndex = tag.setFieldNames(names, index);
+				index = nextIndex;
 			}
 			// if (tag instanceof Box) {
 			//     // console.log(tag)

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,61 +26,6 @@ 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
 // ============================================================================
@@ -92,7 +37,6 @@ let loadingPromise: Promise<any> | null = null;
 /**
  * Load Trust Wallet Core (lazy loading)
  * Works in both Node.js and browser environments
- * Handles different module export formats (CommonJS vs ESM)
  */
 async function loadWalletCore(): Promise<any> {
 	// Return cached instance if already loaded
@@ -108,33 +52,18 @@ async function loadWalletCore(): Promise<any> {
 	// Start loading
 	loadingPromise = (async () => {
 		try {
-			// Dynamic import works in both Node.js ESM and browser ESM
-			const WalletCoreModule = await import('@trustwallet/wallet-core');
-
-			// Handle different export formats (CommonJS vs ESM)
-			let initWasmFunc: any;
-			if (WalletCoreModule.initWasm) {
-				// ESM named export
-				initWasmFunc = WalletCoreModule.initWasm;
-			} else if (
-				WalletCoreModule.default &&
-				(WalletCoreModule.default as any).initWasm
+			// Check if running in browser or Node.js
+			if (
+				typeof window !== 'undefined' &&
+				typeof require === 'undefined'
 			) {
-				// ESM default export with initWasm
-				initWasmFunc = (WalletCoreModule.default as any).initWasm;
-			} else if (WalletCoreModule.default) {
-				// Default export is the function itself
-				initWasmFunc = WalletCoreModule.default;
-			} else {
-				// Module itself is the function
-				initWasmFunc = WalletCoreModule as any;
-			}
-
-			// Call the init function
-			if (typeof initWasmFunc === 'function') {
-				walletCore = await initWasmFunc();
+				// Browser environment with ES modules
+				const { initWasm } = await import('@trustwallet/wallet-core');
+				walletCore = await initWasm();
 			} else {
-				throw new Error('initWasm is not a function');
+				// Node.js environment
+				const { initWasm } = require('@trustwallet/wallet-core');
+				walletCore = await initWasm();
 			}
 
 			walletCoreLoaded = true;
@@ -155,38 +84,23 @@ 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 using Trust Wallet Core
- * Works in both Node.js and browser environments
- *
+ * Generate a random BIP39 mnemonic phrase
  * @param wordCount Number of words (12, 15, 18, 21, or 24), default is 12
- * @returns A promise that resolves to a mnemonic phrase string
+ * @returns A mnemonic phrase string
  *
  * @example
  * ```typescript
- * const mnemonic = await generateMnemonic(12);
+ * const mnemonic = generateMnemonic(12);
  * console.log(mnemonic);
  * // Output: "abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon about"
  * ```
  */
-export async function generateMnemonic(
-	wordCount: number = 12
-): Promise<string> {
+export function generateMnemonic(wordCount: number = 12): string {
 	// Convert word count to entropy bits
 	// 12 words = 128 bits, 15 words = 160 bits, etc.
 	const strengthMap: Record<number, number> = {
@@ -204,14 +118,7 @@ export async function generateMnemonic(
 		);
 	}
 
-	// Ensure Wallet Core is loaded
-	const core = await loadWalletCore();
-	const { HDWallet } = core;
-
-	const wallet = HDWallet.create(strength, '');
-	const mnemonic = wallet.mnemonic();
-
-	return mnemonic;
+	return bip39.generateMnemonic(strength);
 }
 
 /**
@@ -231,10 +138,8 @@ export async function getEthereumAddressFromMnemonic(
 	mnemonic: string
 ): Promise<string> {
 	// Validate mnemonic
-	if (!validateMnemonic(mnemonic)) {
-		throw new Error(
-			'Invalid mnemonic phrase: must have 12, 15, 18, 21, or 24 words'
-		);
+	if (!bip39.validateMnemonic(mnemonic)) {
+		throw new Error('Invalid mnemonic phrase');
 	}
 
 	const core = await loadWalletCore();
@@ -262,10 +167,8 @@ export async function getEVMPrivateKeyFromMnemonic(
 	mnemonic: string
 ): Promise<string> {
 	// Validate mnemonic
-	if (!validateMnemonic(mnemonic)) {
-		throw new Error(
-			'Invalid mnemonic phrase: must have 12, 15, 18, 21, or 24 words'
-		);
+	if (!bip39.validateMnemonic(mnemonic)) {
+		throw new Error('Invalid mnemonic phrase');
 	}
 
 	const core = await loadWalletCore();
@@ -276,9 +179,9 @@ export async function getEVMPrivateKeyFromMnemonic(
 	// Get private key for Ethereum
 	const privateKeyData = wallet.getKeyForCoin(CoinType.ethereum);
 
-	// Convert to hex string with 0x prefix (cross-platform)
-	const privateKeyBytes = new Uint8Array(privateKeyData.data());
-	const privateKeyHex = '0x' + uint8ArrayToHex(privateKeyBytes);
+	// Convert to hex string with 0x prefix
+	const privateKeyHex =
+		'0x' + Buffer.from(privateKeyData.data()).toString('hex');
 
 	return privateKeyHex;
 }
@@ -327,10 +230,8 @@ async function getID(mnemonic: string): Promise<string> {
  */
 export async function getDIDFromMnemonic(mnemonic: string): Promise<string> {
 	// Validate mnemonic
-	if (!validateMnemonic(mnemonic)) {
-		throw new Error(
-			'Invalid mnemonic phrase: must have 12, 15, 18, 21, or 24 words'
-		);
+	if (!bip39.validateMnemonic(mnemonic)) {
+		throw new Error('Invalid mnemonic phrase');
 	}
 
 	const id = await getID(mnemonic);
@@ -377,10 +278,8 @@ export async function getEd25519JwkFromMnemonic(mnemonic: string): Promise<{
 	privateJwk: any;
 }> {
 	// Validate mnemonic
-	if (!validateMnemonic(mnemonic)) {
-		throw new Error(
-			'Invalid mnemonic phrase: must have 12, 15, 18, 21, or 24 words'
-		);
+	if (!bip39.validateMnemonic(mnemonic)) {
+		throw new Error('Invalid mnemonic phrase');
 	}
 
 	const core = await loadWalletCore();
@@ -443,10 +342,8 @@ export async function deriveDIDFromMnemonic(mnemonic: string): Promise<{
 	did: string;
 }> {
 	// Validate mnemonic once upfront
-	if (!validateMnemonic(mnemonic)) {
-		throw new Error(
-			'Invalid mnemonic phrase: must have 12, 15, 18, 21, or 24 words'
-		);
+	if (!bip39.validateMnemonic(mnemonic)) {
+		throw new Error('Invalid mnemonic phrase');
 	}
 
 	// Derive both in parallel for better performance
@@ -475,7 +372,7 @@ export async function deriveDIDFromMnemonic(mnemonic: string): Promise<{
 export async function generateDIDKeyData(
 	wordCount: number = 12
 ): Promise<DIDKeyData> {
-	const mnemonic = await generateMnemonic(wordCount);
+	const mnemonic = generateMnemonic(wordCount);
 	const { owner, did } = await deriveDIDFromMnemonic(mnemonic);
 
 	return {

package/examples/encoding-utils.ts

@@ -1,96 +0,0 @@
-/**
- * Test encoding utilities exported from olaresid
- */
-
-import {
-	base64ToUint8Array,
-	uint8ArrayToHex,
-	hexToUint8Array,
-	uint8ArrayToBase64
-} from '../src/index';
-
-async function main() {
-	console.log('============================================================');
-	console.log('Testing Cross-platform Encoding Utilities');
-	console.log(
-		'============================================================\n'
-	);
-
-	// Test data
-	const testString = 'Hello, Olares!';
-	const testBytes = new TextEncoder().encode(testString);
-
-	console.log('📝 Original text:', testString);
-	console.log('📦 Original bytes:', testBytes);
-	console.log('');
-
-	// Test 1: Uint8Array to Hex
-	console.log('🔄 Test 1: uint8ArrayToHex()');
-	console.log('------------------------------------------------------------');
-	const hexString = uint8ArrayToHex(testBytes);
-	console.log('✅ Hex string:', hexString);
-	console.log('');
-
-	// Test 2: Hex to Uint8Array
-	console.log('🔄 Test 2: hexToUint8Array()');
-	console.log('------------------------------------------------------------');
-	const bytesFromHex = hexToUint8Array(hexString);
-	console.log('✅ Bytes from hex:', bytesFromHex);
-	console.log(
-		'✅ Matches original:',
-		JSON.stringify(bytesFromHex) === JSON.stringify(testBytes)
-	);
-	console.log('');
-
-	// Test 3: Uint8Array to Base64
-	console.log('🔄 Test 3: uint8ArrayToBase64()');
-	console.log('------------------------------------------------------------');
-	const base64String = uint8ArrayToBase64(testBytes);
-	console.log('✅ Base64 string:', base64String);
-	console.log('');
-
-	// Test 4: Base64 to Uint8Array
-	console.log('🔄 Test 4: base64ToUint8Array()');
-	console.log('------------------------------------------------------------');
-	const bytesFromBase64 = base64ToUint8Array(base64String);
-	console.log('✅ Bytes from base64:', bytesFromBase64);
-	console.log(
-		'✅ Matches original:',
-		JSON.stringify(bytesFromBase64) === JSON.stringify(testBytes)
-	);
-	console.log('');
-
-	// Test 5: Round-trip conversion
-	console.log('🔄 Test 5: Round-trip conversion (hex)');
-	console.log('------------------------------------------------------------');
-	const hex1 = uint8ArrayToHex(testBytes);
-	const bytes1 = hexToUint8Array(hex1);
-	const hex2 = uint8ArrayToHex(bytes1);
-	console.log('✅ Round-trip hex successful:', hex1 === hex2);
-	console.log('');
-
-	console.log('🔄 Test 6: Round-trip conversion (base64)');
-	console.log('------------------------------------------------------------');
-	const b64_1 = uint8ArrayToBase64(testBytes);
-	const bytes2 = base64ToUint8Array(b64_1);
-	const b64_2 = uint8ArrayToBase64(bytes2);
-	console.log('✅ Round-trip base64 successful:', b64_1 === b64_2);
-	console.log('');
-
-	// Test 7: Hex with 0x prefix
-	console.log('🔄 Test 7: Hex with 0x prefix');
-	console.log('------------------------------------------------------------');
-	const hexWithPrefix = '0x' + hexString;
-	const bytesFromPrefixedHex = hexToUint8Array(hexWithPrefix);
-	console.log(
-		'✅ Can handle 0x prefix:',
-		JSON.stringify(bytesFromPrefixedHex) === JSON.stringify(testBytes)
-	);
-	console.log('');
-
-	console.log('============================================================');
-	console.log('✅ All encoding utility tests passed!');
-	console.log('============================================================');
-}
-
-main().catch(console.error);

package/examples/frontend-demo/.dockerignore

@@ -1,40 +0,0 @@
-# Dependencies
-node_modules
-npm-debug.log*
-yarn-debug.log*
-yarn-error.log*
-pnpm-debug.log*
-
-# Build output
-dist
-.vite
-
-# Environment files
-.env
-.env.local
-.env.*.local
-
-# IDE
-.vscode
-.idea
-*.swp
-*.swo
-*~
-
-# OS
-.DS_Store
-Thumbs.db
-
-# Git
-.git
-.gitignore
-.github
-
-# Documentation
-README.md
-QUICKSTART.md
-*.md
-
-# Logs
-logs
-*.log