@spacesops/wdk-react-native-core 1.0.0-beta.40

package/dist/utils/jsonUtils.js

@@ -0,0 +1,67 @@
+/**
+ * JSON Utilities
+ *
+ * Provides safe JSON stringification and validation utilities
+ * to prevent security issues and ensure data integrity.
+ */
+/**
+ * Validate that a value has a safe JSON structure
+ * Prevents prototype pollution and circular references
+ */
+export function validateJSONStructure(value) {
+    try {
+        // Check for circular references
+        const seen = new WeakSet();
+        function check(value) {
+            if (value === null || typeof value !== 'object') {
+                return true;
+            }
+            if (seen.has(value)) {
+                return false; // Circular reference
+            }
+            seen.add(value);
+            if (Array.isArray(value)) {
+                return value.every(check);
+            }
+            // Check for prototype pollution
+            const proto = Object.getPrototypeOf(value);
+            // Reject objects with non-standard prototypes (not null, Object.prototype, or Array.prototype)
+            // Note: Objects created with Object.create(Array.prototype) should be rejected
+            if (proto !== null && proto !== Object.prototype) {
+                // Allow Array.prototype only for actual arrays (checked above)
+                // Reject objects that inherit from Array.prototype but aren't arrays
+                return false;
+            }
+            return Object.values(value).every(check);
+        }
+        return check(value);
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Safe JSON stringify with validation
+ * Validates structure before stringifying to prevent security issues
+ *
+ * @param value - Value to stringify
+ * @param space - Optional spacing for pretty printing
+ * @returns JSON string
+ * @throws Error if value cannot be safely stringified
+ */
+export function safeStringify(value, space) {
+    // Validate structure first
+    if (!validateJSONStructure(value)) {
+        throw new Error('Value contains circular references or unsafe prototype properties');
+    }
+    try {
+        return JSON.stringify(value, null, space);
+    }
+    catch (error) {
+        if (error instanceof Error) {
+            throw new Error(`Failed to stringify value: ${error.message}`);
+        }
+        throw new Error('Failed to stringify value: Unknown error');
+    }
+}
+//# sourceMappingURL=jsonUtils.js.map

package/dist/utils/jsonUtils.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"jsonUtils.js","sourceRoot":"","sources":["../../src/utils/jsonUtils.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH;;;GAGG;AACH,MAAM,UAAU,qBAAqB,CAAC,KAAc;IAClD,IAAI,CAAC;QACH,gCAAgC;QAChC,MAAM,IAAI,GAAG,IAAI,OAAO,EAAE,CAAA;QAE1B,SAAS,KAAK,CAAC,KAAc;YAC3B,IAAI,KAAK,KAAK,IAAI,IAAI,OAAO,KAAK,KAAK,QAAQ,EAAE,CAAC;gBAChD,OAAO,IAAI,CAAA;YACb,CAAC;YAED,IAAI,IAAI,CAAC,GAAG,CAAC,KAAe,CAAC,EAAE,CAAC;gBAC9B,OAAO,KAAK,CAAA,CAAC,qBAAqB;YACpC,CAAC;YAED,IAAI,CAAC,GAAG,CAAC,KAAe,CAAC,CAAA;YAEzB,IAAI,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC,EAAE,CAAC;gBACzB,OAAO,KAAK,CAAC,KAAK,CAAC,KAAK,CAAC,CAAA;YAC3B,CAAC;YAED,gCAAgC;YAChC,MAAM,KAAK,GAAG,MAAM,CAAC,cAAc,CAAC,KAAK,CAAC,CAAA;YAC1C,+FAA+F;YAC/F,+EAA+E;YAC/E,IAAI,KAAK,KAAK,IAAI,IAAI,KAAK,KAAK,MAAM,CAAC,SAAS,EAAE,CAAC;gBACjD,+DAA+D;gBAC/D,qEAAqE;gBACrE,OAAO,KAAK,CAAA;YACd,CAAC;YAED,OAAO,MAAM,CAAC,MAAM,CAAC,KAAgC,CAAC,CAAC,KAAK,CAAC,KAAK,CAAC,CAAA;QACrE,CAAC;QAED,OAAO,KAAK,CAAC,KAAK,CAAC,CAAA;IACrB,CAAC;IAAC,MAAM,CAAC;QACP,OAAO,KAAK,CAAA;IACd,CAAC;AACH,CAAC;AAED;;;;;;;;GAQG;AACH,MAAM,UAAU,aAAa,CAAC,KAAc,EAAE,KAAc;IAC1D,2BAA2B;IAC3B,IAAI,CAAC,qBAAqB,CAAC,KAAK,CAAC,EAAE,CAAC;QAClC,MAAM,IAAI,KAAK,CAAC,mEAAmE,CAAC,CAAA;IACtF,CAAC;IAED,IAAI,CAAC;QACH,OAAO,IAAI,CAAC,SAAS,CAAC,KAAK,EAAE,IAAI,EAAE,KAAK,CAAC,CAAA;IAC3C,CAAC;IAAC,OAAO,KAAK,EAAE,CAAC;QACf,IAAI,KAAK,YAAY,KAAK,EAAE,CAAC;YAC3B,MAAM,IAAI,KAAK,CAAC,8BAA8B,KAAK,CAAC,OAAO,EAAE,CAAC,CAAA;QAChE,CAAC;QACD,MAAM,IAAI,KAAK,CAAC,0CAA0C,CAAC,CAAA;IAC7D,CAAC;AACH,CAAC"}

package/dist/utils/logger.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Logger utility for development and production
+ *
+ * Provides controlled logging that can be disabled in production
+ * to improve performance and prevent information leakage.
+ */
+/**
+ * Log a message (only in development)
+ *
+ * @param message - Message to log
+ * @param args - Additional arguments to log
+ */
+export declare function log(...args: unknown[]): void;
+/**
+ * Log an error (always logged, but sanitized in production)
+ *
+ * @param message - Error message
+ * @param error - Error object or additional data
+ */
+export declare function logError(message: string, error?: unknown): void;
+/**
+ * Log a warning (only in development)
+ *
+ * @param message - Warning message
+ * @param args - Additional arguments to log
+ */
+export declare function logWarn(...args: unknown[]): void;

package/dist/utils/logger.js

@@ -0,0 +1,50 @@
+/**
+ * Logger utility for development and production
+ *
+ * Provides controlled logging that can be disabled in production
+ * to improve performance and prevent information leakage.
+ */
+/**
+ * Check if we're in development mode
+ * React Native sets __DEV__ to true in development builds
+ */
+const isDevelopment = typeof __DEV__ !== 'undefined' ? __DEV__ : process.env.NODE_ENV !== 'production';
+/**
+ * Log a message (only in development)
+ *
+ * @param message - Message to log
+ * @param args - Additional arguments to log
+ */
+export function log(...args) {
+    if (isDevelopment) {
+        console.log(...args);
+    }
+}
+/**
+ * Log an error (always logged, but sanitized in production)
+ *
+ * @param message - Error message
+ * @param error - Error object or additional data
+ */
+export function logError(message, error) {
+    if (isDevelopment) {
+        console.error(message, error);
+    }
+    else {
+        // In production, log sanitized errors only
+        // This prevents information leakage while still allowing error tracking
+        console.error(message);
+    }
+}
+/**
+ * Log a warning (only in development)
+ *
+ * @param message - Warning message
+ * @param args - Additional arguments to log
+ */
+export function logWarn(...args) {
+    if (isDevelopment) {
+        console.warn(...args);
+    }
+}
+//# sourceMappingURL=logger.js.map

package/dist/utils/logger.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"logger.js","sourceRoot":"","sources":["../../src/utils/logger.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH;;;GAGG;AACH,MAAM,aAAa,GAAG,OAAO,OAAO,KAAK,WAAW,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,OAAO,CAAC,GAAG,CAAC,QAAQ,KAAK,YAAY,CAAA;AAEtG;;;;;GAKG;AACH,MAAM,UAAU,GAAG,CAAC,GAAG,IAAe;IACpC,IAAI,aAAa,EAAE,CAAC;QAClB,OAAO,CAAC,GAAG,CAAC,GAAG,IAAI,CAAC,CAAA;IACtB,CAAC;AACH,CAAC;AAED;;;;;GAKG;AACH,MAAM,UAAU,QAAQ,CAAC,OAAe,EAAE,KAAe;IACvD,IAAI,aAAa,EAAE,CAAC;QAClB,OAAO,CAAC,KAAK,CAAC,OAAO,EAAE,KAAK,CAAC,CAAA;IAC/B,CAAC;SAAM,CAAC;QACN,2CAA2C;QAC3C,wEAAwE;QACxE,OAAO,CAAC,KAAK,CAAC,OAAO,CAAC,CAAA;IACxB,CAAC;AACH,CAAC;AAED;;;;;GAKG;AACH,MAAM,UAAU,OAAO,CAAC,GAAG,IAAe;IACxC,IAAI,aAAa,EAAE,CAAC;QAClB,OAAO,CAAC,IAAI,CAAC,GAAG,IAAI,CAAC,CAAA;IACvB,CAAC;AACH,CAAC"}

package/dist/utils/mmkvKeyManager.d.ts

@@ -0,0 +1,57 @@
+/**
+ * MMKV Encryption Key Manager
+ *
+ * Manages encryption keys for MMKV storage on a per-account basis.
+ * Each account (identified by email/identifier) gets its own encryption key,
+ * allowing multiple accounts on the same device with isolated encrypted storage.
+ *
+ * SECURITY NOTE: MMKV stores NON-SENSITIVE data only (addresses, balances, metadata).
+ * Since the data is non-sensitive, we use DETERMINISTIC key derivation from account identifier.
+ * This allows the same account to access the same encrypted data across devices.
+ *
+ * IMPORTANT: For sensitive data (wallet seeds, encryption keys), use SecureStorage which
+ * uses randomly generated keys stored in the device keychain.
+ */
+/**
+ * Account identifier type (typically email or user ID)
+ */
+export type AccountIdentifier = string;
+/**
+ * Clear the key derivation cache
+ *
+ * Useful when switching accounts or when you want to free memory.
+ * Note: Keys will be re-derived on next access since derivation is deterministic.
+ *
+ * @example
+ * ```typescript
+ * // Clear cache when user logs out
+ * clearKeyCache()
+ * ```
+ */
+export declare function clearKeyCache(): void;
+/**
+ * Get MMKV encryption key for an account
+ *
+ * SECURITY: Since MMKV stores non-sensitive data, we use deterministic key derivation.
+ * The key is derived from the account identifier, allowing the same account to access
+ * the same encrypted data across devices.
+ *
+ * The key is NOT stored - it's derived on-demand from the account identifier.
+ * Results are cached since derivation is deterministic.
+ *
+ * This ensures:
+ * - Account data isolation (different accounts = different keys)
+ * - Cross-device compatibility (same account = same key)
+ * - No key storage needed (deterministic derivation)
+ *
+ * @param accountIdentifier - Account identifier (email or user ID)
+ * @returns Promise that resolves to encryption key (base64 string, 32 bytes)
+ * @throws Error if account identifier is invalid or key derivation fails
+ *
+ * @example
+ * ```typescript
+ * const key = await getMMKVKey('user@example.com')
+ * const mmkv = createMMKV({ encryptionKey: key })
+ * ```
+ */
+export declare function getMMKVKey(accountIdentifier: AccountIdentifier): Promise<string>;

package/dist/utils/mmkvKeyManager.js

@@ -0,0 +1,214 @@
+/**
+ * MMKV Encryption Key Manager
+ *
+ * Manages encryption keys for MMKV storage on a per-account basis.
+ * Each account (identified by email/identifier) gets its own encryption key,
+ * allowing multiple accounts on the same device with isolated encrypted storage.
+ *
+ * SECURITY NOTE: MMKV stores NON-SENSITIVE data only (addresses, balances, metadata).
+ * Since the data is non-sensitive, we use DETERMINISTIC key derivation from account identifier.
+ * This allows the same account to access the same encrypted data across devices.
+ *
+ * IMPORTANT: For sensitive data (wallet seeds, encryption keys), use SecureStorage which
+ * uses randomly generated keys stored in the device keychain.
+ */
+import * as Crypto from 'expo-crypto';
+/**
+ * Convert Uint8Array to base64 string using standard encoding
+ * This implementation follows RFC 4648 and handles all edge cases correctly
+ *
+ * @param bytes - Uint8Array to convert
+ * @returns Base64 encoded string
+ */
+function bytesToBase64(bytes) {
+    // Try to use Buffer if available (common in React Native with polyfills)
+    if (typeof Buffer !== 'undefined') {
+        return Buffer.from(bytes).toString('base64');
+    }
+    // Fallback to manual encoding for environments without Buffer
+    const base64Chars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/';
+    let result = '';
+    for (let i = 0; i < bytes.length; i += 3) {
+        const a = bytes[i] ?? 0;
+        const b = i + 1 < bytes.length ? (bytes[i + 1] ?? 0) : 0;
+        const c = i + 2 < bytes.length ? (bytes[i + 2] ?? 0) : 0;
+        const bitmap = (a << 16) | (b << 8) | c;
+        result += base64Chars.charAt((bitmap >> 18) & 63);
+        result += base64Chars.charAt((bitmap >> 12) & 63);
+        if (i + 1 < bytes.length) {
+            result += base64Chars.charAt((bitmap >> 6) & 63);
+        }
+        else {
+            result += '=';
+        }
+        if (i + 2 < bytes.length) {
+            result += base64Chars.charAt(bitmap & 63);
+        }
+        else {
+            result += '=';
+        }
+    }
+    return result;
+}
+/**
+ * Maximum number of keys to cache before evicting least recently used
+ * This prevents unbounded memory growth while maintaining performance
+ */
+const MAX_CACHE_SIZE = 100;
+/**
+ * Cache for derived keys to avoid repeated async operations
+ * Since key derivation is deterministic, we can cache the results
+ * Uses LRU (Least Recently Used) eviction policy to limit memory usage
+ */
+const keyCache = new Map();
+const keyAccessOrder = new Map();
+let accessCounter = 0;
+/**
+ * Evict least recently used key from cache when limit is reached
+ */
+function evictLRUKey() {
+    if (keyCache.size < MAX_CACHE_SIZE) {
+        return;
+    }
+    // Find the least recently used key
+    let oldestKey = null;
+    let oldestAccess = Infinity;
+    for (const [key, accessTime] of keyAccessOrder.entries()) {
+        if (accessTime < oldestAccess) {
+            oldestAccess = accessTime;
+            oldestKey = key;
+        }
+    }
+    // Remove the least recently used key
+    if (oldestKey !== null) {
+        keyCache.delete(oldestKey);
+        keyAccessOrder.delete(oldestKey);
+    }
+}
+async function deriveKeyFromAccount(accountIdentifier) {
+    // Check cache first
+    const cachedKey = keyCache.get(accountIdentifier);
+    if (cachedKey !== undefined) {
+        // Update access time for LRU tracking
+        accessCounter++;
+        keyAccessOrder.set(accountIdentifier, accessCounter);
+        return cachedKey;
+    }
+    // Use a constant salt for key derivation
+    // This salt is public and part of the derivation algorithm
+    const SALT = 'wdk-mmkv-encryption-salt-v1';
+    const input = `${SALT}:${accountIdentifier}`;
+    // Use expo-crypto for production-grade SHA-256 hashing
+    // This is a well-tested, battle-hardened implementation
+    const hashHex = await Crypto.digestStringAsync(Crypto.CryptoDigestAlgorithm.SHA256, input);
+    // Convert hex string to base64 using standard encoding
+    // SHA-256 produces 64 hex characters (32 bytes)
+    // Convert hex to bytes, then to base64
+    const hexBytes = hashHex.match(/.{1,2}/g);
+    if (!hexBytes || hashHex.length !== 64) {
+        throw new Error(`Invalid SHA-256 hash format: expected 64 hex characters, got ${hashHex.length}`);
+    }
+    const hashBytes = new Uint8Array(hexBytes.map((byte) => parseInt(byte, 16)));
+    // Convert bytes to base64 using standard encoding
+    // Use a well-tested base64 encoding implementation
+    const key = bytesToBase64(hashBytes);
+    // Evict LRU key if cache is full
+    evictLRUKey();
+    // Cache the result for future use
+    accessCounter++;
+    keyCache.set(accountIdentifier, key);
+    keyAccessOrder.set(accountIdentifier, accessCounter);
+    return key;
+}
+/**
+ * Maximum length for account identifiers to prevent DoS attacks
+ * 256 characters is reasonable for emails and user IDs
+ */
+const MAX_ACCOUNT_IDENTIFIER_LENGTH = 256;
+/**
+ * Validate account identifier input
+ *
+ * @param accountIdentifier - Account identifier to validate
+ * @throws Error if validation fails
+ */
+function validateAccountIdentifier(accountIdentifier) {
+    if (!accountIdentifier || typeof accountIdentifier !== 'string') {
+        throw new Error('Account identifier must be a non-empty string');
+    }
+    const trimmed = accountIdentifier.trim();
+    if (trimmed === '') {
+        throw new Error('Account identifier cannot be empty or whitespace only');
+    }
+    if (trimmed.length > MAX_ACCOUNT_IDENTIFIER_LENGTH) {
+        throw new Error(`Account identifier exceeds maximum length of ${MAX_ACCOUNT_IDENTIFIER_LENGTH} characters`);
+    }
+    // Check for valid UTF-8 encoding (basic check)
+    try {
+        // Ensure the string can be properly encoded
+        encodeURIComponent(trimmed);
+    }
+    catch (error) {
+        throw new Error('Account identifier contains invalid characters');
+    }
+}
+/**
+ * Clear the key derivation cache
+ *
+ * Useful when switching accounts or when you want to free memory.
+ * Note: Keys will be re-derived on next access since derivation is deterministic.
+ *
+ * @example
+ * ```typescript
+ * // Clear cache when user logs out
+ * clearKeyCache()
+ * ```
+ */
+export function clearKeyCache() {
+    keyCache.clear();
+    keyAccessOrder.clear();
+    accessCounter = 0;
+}
+/**
+ * Get MMKV encryption key for an account
+ *
+ * SECURITY: Since MMKV stores non-sensitive data, we use deterministic key derivation.
+ * The key is derived from the account identifier, allowing the same account to access
+ * the same encrypted data across devices.
+ *
+ * The key is NOT stored - it's derived on-demand from the account identifier.
+ * Results are cached since derivation is deterministic.
+ *
+ * This ensures:
+ * - Account data isolation (different accounts = different keys)
+ * - Cross-device compatibility (same account = same key)
+ * - No key storage needed (deterministic derivation)
+ *
+ * @param accountIdentifier - Account identifier (email or user ID)
+ * @returns Promise that resolves to encryption key (base64 string, 32 bytes)
+ * @throws Error if account identifier is invalid or key derivation fails
+ *
+ * @example
+ * ```typescript
+ * const key = await getMMKVKey('user@example.com')
+ * const mmkv = createMMKV({ encryptionKey: key })
+ * ```
+ */
+export async function getMMKVKey(accountIdentifier) {
+    // Validate input before processing
+    validateAccountIdentifier(accountIdentifier);
+    // Use trimmed identifier for consistency
+    const trimmedIdentifier = accountIdentifier.trim();
+    try {
+        // Derive key deterministically from account identifier
+        // No need to store it - same account identifier always produces same key
+        return await deriveKeyFromAccount(trimmedIdentifier);
+    }
+    catch (error) {
+        // Provide more context in error messages
+        if (error instanceof Error) {
+            throw new Error(`Failed to derive encryption key for account: ${error.message}`);
+        }
+        throw new Error(`Failed to derive encryption key for account: ${String(error)}`);
+    }
+}
+//# sourceMappingURL=mmkvKeyManager.js.map

package/dist/utils/mmkvKeyManager.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"mmkvKeyManager.js","sourceRoot":"","sources":["../../src/utils/mmkvKeyManager.ts"],"names":[],"mappings":"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"}

package/dist/utils/mnemonicUtils.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Mnemonic utility functions
+ */
+/**
+ * Validate a mnemonic phrase
+ *
+ * @param mnemonic - The mnemonic phrase to validate
+ * @returns true if the mnemonic is valid (12 or 24 words, all non-empty)
+ *
+ * @example
+ * ```ts
+ * validateMnemonic("word1 word2 ... word12") // true
+ * validateMnemonic("word1 word2 ... word24") // true
+ * validateMnemonic("word1 word2") // false (too few words)
+ * ```
+ */
+export declare function validateMnemonic(mnemonic: string): boolean;

package/dist/utils/mnemonicUtils.js

@@ -0,0 +1,28 @@
+/**
+ * Mnemonic utility functions
+ */
+/**
+ * Validate a mnemonic phrase
+ *
+ * @param mnemonic - The mnemonic phrase to validate
+ * @returns true if the mnemonic is valid (12 or 24 words, all non-empty)
+ *
+ * @example
+ * ```ts
+ * validateMnemonic("word1 word2 ... word12") // true
+ * validateMnemonic("word1 word2 ... word24") // true
+ * validateMnemonic("word1 word2") // false (too few words)
+ * ```
+ */
+export function validateMnemonic(mnemonic) {
+    const trimmed = mnemonic.trim();
+    // Normalize whitespace first (multiple spaces become single spaces)
+    // This handles cases like "word1  word2" where multiple spaces should be normalized
+    const normalized = trimmed.replace(/\s+/g, ' ');
+    // Split and validate
+    const words = normalized.split(' ');
+    const validLengths = [12, 24];
+    // Check word count and that all words are non-empty
+    return validLengths.includes(words.length) && words.every(word => word.length > 0);
+}
+//# sourceMappingURL=mnemonicUtils.js.map

package/dist/utils/mnemonicUtils.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"mnemonicUtils.js","sourceRoot":"","sources":["../../src/utils/mnemonicUtils.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH;;;;;;;;;;;;GAYG;AACH,MAAM,UAAU,gBAAgB,CAAC,QAAgB;IAC/C,MAAM,OAAO,GAAG,QAAQ,CAAC,IAAI,EAAE,CAAA;IAE/B,oEAAoE;IACpE,oFAAoF;IACpF,MAAM,UAAU,GAAG,OAAO,CAAC,OAAO,CAAC,MAAM,EAAE,GAAG,CAAC,CAAA;IAE/C,qBAAqB;IACrB,MAAM,KAAK,GAAG,UAAU,CAAC,KAAK,CAAC,GAAG,CAAC,CAAA;IACnC,MAAM,YAAY,GAAG,CAAC,EAAE,EAAE,EAAE,CAAC,CAAA;IAE7B,oDAAoD;IACpD,OAAO,YAAY,CAAC,QAAQ,CAAC,KAAK,CAAC,MAAM,CAAC,IAAI,KAAK,CAAC,KAAK,CAAC,IAAI,CAAC,EAAE,CAAC,IAAI,CAAC,MAAM,GAAG,CAAC,CAAC,CAAA;AACpF,CAAC"}

package/dist/utils/operationMutex.d.ts

@@ -0,0 +1,69 @@
+/**
+ * Operation Mutex - Prevents concurrent wallet operations
+ *
+ * This utility provides a mutex/lock mechanism to ensure only one wallet operation
+ * can execute at a time, preventing race conditions and state corruption.
+ */
+/**
+ * Operation mutex result
+ */
+export interface MutexResult {
+    /** Whether the operation was acquired */
+    acquired: boolean;
+    /** Current operation description if mutex is held */
+    currentOperation: string | null;
+    /** Release function to call when operation completes */
+    release: () => void;
+}
+/**
+ * Try to acquire operation mutex
+ *
+ * @param operationDescription - Description of the operation (for debugging)
+ * @returns MutexResult with acquired status and release function
+ *
+ * @example
+ * ```typescript
+ * const mutex = acquireOperationMutex('switchWallet')
+ * if (!mutex.acquired) {
+ *   throw new Error(`Operation in progress: ${mutex.currentOperation}`)
+ * }
+ * try {
+ *   // Perform operation
+ * } finally {
+ *   mutex.release()
+ * }
+ * ```
+ */
+export declare function acquireOperationMutex(operationDescription: string): MutexResult;
+/**
+ * Execute an operation with mutex protection
+ * Automatically acquires and releases mutex
+ * Includes timeout protection to prevent stuck operations
+ *
+ * @param operationDescription - Description of the operation
+ * @param operation - Async operation to execute
+ * @param timeoutMs - Optional timeout in milliseconds (default: 30000ms / 30 seconds)
+ * @returns Promise with operation result
+ * @throws Error if mutex cannot be acquired, operation fails, or timeout is exceeded
+ *
+ * @example
+ * ```typescript
+ * await withOperationMutex('switchWallet', async () => {
+ *   await WalletSwitchingService.switchToWallet(walletId)
+ * })
+ *
+ * // With custom timeout
+ * await withOperationMutex('longOperation', async () => {
+ *   await longRunningOperation()
+ * }, 60000) // 60 second timeout
+ * ```
+ */
+export declare function withOperationMutex<T>(operationDescription: string, operation: () => Promise<T>, timeoutMs?: number): Promise<T>;
+/**
+ * Check if an operation is currently in progress
+ */
+export declare function isOperationInProgress(): boolean;
+/**
+ * Get current operation description
+ */
+export declare function getCurrentOperation(): string | null;