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

package/dist/utils/operationMutex.js

@@ -0,0 +1,150 @@
+/**
+ * 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.
+ */
+import { getWalletStore } from '../store/walletStore';
+import { log, logWarn } from './logger';
+/**
+ * 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 function acquireOperationMutex(operationDescription) {
+    const walletStore = getWalletStore();
+    const state = walletStore.getState();
+    // Check if operation is already in progress
+    if (state.isOperationInProgress) {
+        logWarn(`[OperationMutex] Operation "${operationDescription}" blocked by: ${state.currentOperation}`);
+        return {
+            acquired: false,
+            currentOperation: state.currentOperation,
+            release: () => { }, // No-op release
+        };
+    }
+    // Acquire mutex
+    walletStore.setState({
+        isOperationInProgress: true,
+        currentOperation: operationDescription,
+    });
+    log(`[OperationMutex] Acquired mutex for: ${operationDescription}`);
+    // Return release function
+    return {
+        acquired: true,
+        currentOperation: null,
+        release: () => {
+            const currentState = walletStore.getState();
+            // Only release if we're still the current operation
+            if (currentState.currentOperation === operationDescription) {
+                walletStore.setState({
+                    isOperationInProgress: false,
+                    currentOperation: null,
+                });
+                log(`[OperationMutex] Released mutex for: ${operationDescription}`);
+            }
+            else {
+                logWarn(`[OperationMutex] Attempted to release mutex for "${operationDescription}" but current operation is "${currentState.currentOperation}"`);
+            }
+        },
+    };
+}
+/**
+ * Default timeout for operations (30 seconds)
+ * Operations that exceed this timeout will be automatically released
+ */
+const DEFAULT_OPERATION_TIMEOUT_MS = 30 * 1000;
+/**
+ * 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 async function withOperationMutex(operationDescription, operation, timeoutMs = DEFAULT_OPERATION_TIMEOUT_MS) {
+    const mutex = acquireOperationMutex(operationDescription);
+    if (!mutex.acquired) {
+        throw new Error(`Cannot execute "${operationDescription}": Another operation is in progress (${mutex.currentOperation})`);
+    }
+    // Set up timeout protection
+    let timeoutId = null;
+    let timeoutExceeded = false;
+    const timeoutPromise = new Promise((_, reject) => {
+        timeoutId = setTimeout(() => {
+            timeoutExceeded = true;
+            logWarn(`[OperationMutex] Operation "${operationDescription}" exceeded timeout of ${timeoutMs}ms`);
+            mutex.release();
+            reject(new Error(`Operation "${operationDescription}" exceeded timeout of ${timeoutMs}ms`));
+        }, timeoutMs);
+    });
+    try {
+        // Race between operation and timeout
+        return await Promise.race([
+            operation(),
+            timeoutPromise,
+        ]);
+    }
+    catch (error) {
+        // If timeout occurred, error is already handled
+        if (timeoutExceeded) {
+            throw error;
+        }
+        // Otherwise, re-throw the operation error
+        throw error;
+    }
+    finally {
+        // Clear timeout if operation completed before timeout
+        if (timeoutId) {
+            clearTimeout(timeoutId);
+        }
+        // Only release if timeout didn't already release it
+        if (!timeoutExceeded) {
+            mutex.release();
+        }
+    }
+}
+/**
+ * Check if an operation is currently in progress
+ */
+export function isOperationInProgress() {
+    const walletStore = getWalletStore();
+    return walletStore.getState().isOperationInProgress;
+}
+/**
+ * Get current operation description
+ */
+export function getCurrentOperation() {
+    const walletStore = getWalletStore();
+    return walletStore.getState().currentOperation;
+}
+//# sourceMappingURL=operationMutex.js.map

package/dist/utils/operationMutex.js.map

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

package/dist/utils/result.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Result Type for Error Handling
+ *
+ * Provides a consistent pattern for handling operations that can succeed or fail.
+ * This eliminates the need for try-catch blocks and provides type-safe error handling.
+ */
+/**
+ * Result type representing success or failure
+ */
+export type Result<T, E = Error> = {
+    success: true;
+    data: T;
+    error?: never;
+} | {
+    success: false;
+    error: E;
+    data?: never;
+};
+/**
+ * Create a success result
+ */
+export declare function ok<T>(data: T): Result<T, never>;
+/**
+ * Create an error result
+ */
+export declare function err<E>(error: E): Result<never, E>;
+/**
+ * Wrap an async function to return a Result instead of throwing
+ */
+export declare function toResult<T, E = Error>(fn: () => Promise<T>): Promise<Result<T, E>>;
+/**
+ * Wrap a synchronous function to return a Result instead of throwing
+ */
+export declare function toResultSync<T, E = Error>(fn: () => T): Result<T, E>;

package/dist/utils/result.js

@@ -0,0 +1,43 @@
+/**
+ * Result Type for Error Handling
+ *
+ * Provides a consistent pattern for handling operations that can succeed or fail.
+ * This eliminates the need for try-catch blocks and provides type-safe error handling.
+ */
+/**
+ * Create a success result
+ */
+export function ok(data) {
+    return { success: true, data };
+}
+/**
+ * Create an error result
+ */
+export function err(error) {
+    return { success: false, error };
+}
+/**
+ * Wrap an async function to return a Result instead of throwing
+ */
+export async function toResult(fn) {
+    try {
+        const data = await fn();
+        return ok(data);
+    }
+    catch (error) {
+        return err(error);
+    }
+}
+/**
+ * Wrap a synchronous function to return a Result instead of throwing
+ */
+export function toResultSync(fn) {
+    try {
+        const data = fn();
+        return ok(data);
+    }
+    catch (error) {
+        return err(error);
+    }
+}
+//# sourceMappingURL=result.js.map

package/dist/utils/result.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"result.js","sourceRoot":"","sources":["../../src/utils/result.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AASH;;GAEG;AACH,MAAM,UAAU,EAAE,CAAI,IAAO;IAC3B,OAAO,EAAE,OAAO,EAAE,IAAI,EAAE,IAAI,EAAE,CAAA;AAChC,CAAC;AAED;;GAEG;AACH,MAAM,UAAU,GAAG,CAAI,KAAQ;IAC7B,OAAO,EAAE,OAAO,EAAE,KAAK,EAAE,KAAK,EAAE,CAAA;AAClC,CAAC;AAED;;GAEG;AACH,MAAM,CAAC,KAAK,UAAU,QAAQ,CAC5B,EAAoB;IAEpB,IAAI,CAAC;QACH,MAAM,IAAI,GAAG,MAAM,EAAE,EAAE,CAAA;QACvB,OAAO,EAAE,CAAC,IAAI,CAAC,CAAA;IACjB,CAAC;IAAC,OAAO,KAAK,EAAE,CAAC;QACf,OAAO,GAAG,CAAC,KAAU,CAAC,CAAA;IACxB,CAAC;AACH,CAAC;AAED;;GAEG;AACH,MAAM,UAAU,YAAY,CAC1B,EAAW;IAEX,IAAI,CAAC;QACH,MAAM,IAAI,GAAG,EAAE,EAAE,CAAA;QACjB,OAAO,EAAE,CAAC,IAAI,CAAC,CAAA;IACjB,CAAC;IAAC,OAAO,KAAK,EAAE,CAAC;QACf,OAAO,GAAG,CAAC,KAAU,CAAC,CAAA;IACxB,CAAC;AACH,CAAC"}

package/dist/utils/schemas.d.ts

@@ -0,0 +1,365 @@
+/**
+ * Zod Schemas for Runtime Validation
+ *
+ * Provides Zod schemas for all WDK types to replace manual if/else type guards.
+ * These schemas provide better error messages and are easier to maintain.
+ */
+import { z } from 'zod';
+/**
+ * Ethereum address schema (0x followed by 40 hex characters)
+ */
+export declare const ethereumAddressSchema: z.ZodString;
+/**
+ * Spark address schema (Bech32 format: spark1/sparkt1/sparkrt1 followed by base32 characters)
+ */
+export declare const sparkAddressSchema: z.ZodString;
+/**
+ * Address schema (Ethereum or Spark)
+ */
+export declare const addressSchema: z.ZodUnion<[z.ZodString, z.ZodString]>;
+/**
+ * Network configuration schema
+ */
+export declare const networkConfigSchema: z.ZodObject<{
+    chainId: z.ZodNumber;
+    blockchain: z.ZodString;
+    provider: z.ZodOptional<z.ZodString>;
+    bundlerUrl: z.ZodOptional<z.ZodString>;
+    paymasterUrl: z.ZodOptional<z.ZodString>;
+    paymasterAddress: z.ZodOptional<z.ZodString>;
+    entryPointAddress: z.ZodOptional<z.ZodString>;
+    transferMaxFee: z.ZodOptional<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    chainId: number;
+    blockchain: string;
+    provider?: string | undefined;
+    bundlerUrl?: string | undefined;
+    paymasterUrl?: string | undefined;
+    paymasterAddress?: string | undefined;
+    entryPointAddress?: string | undefined;
+    transferMaxFee?: number | undefined;
+}, {
+    chainId: number;
+    blockchain: string;
+    provider?: string | undefined;
+    bundlerUrl?: string | undefined;
+    paymasterUrl?: string | undefined;
+    paymasterAddress?: string | undefined;
+    entryPointAddress?: string | undefined;
+    transferMaxFee?: number | undefined;
+}>;
+/**
+ * Network configurations schema
+ */
+export declare const networkConfigsSchema: z.ZodEffects<z.ZodRecord<z.ZodString, z.ZodObject<{
+    chainId: z.ZodNumber;
+    blockchain: z.ZodString;
+    provider: z.ZodOptional<z.ZodString>;
+    bundlerUrl: z.ZodOptional<z.ZodString>;
+    paymasterUrl: z.ZodOptional<z.ZodString>;
+    paymasterAddress: z.ZodOptional<z.ZodString>;
+    entryPointAddress: z.ZodOptional<z.ZodString>;
+    transferMaxFee: z.ZodOptional<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    chainId: number;
+    blockchain: string;
+    provider?: string | undefined;
+    bundlerUrl?: string | undefined;
+    paymasterUrl?: string | undefined;
+    paymasterAddress?: string | undefined;
+    entryPointAddress?: string | undefined;
+    transferMaxFee?: number | undefined;
+}, {
+    chainId: number;
+    blockchain: string;
+    provider?: string | undefined;
+    bundlerUrl?: string | undefined;
+    paymasterUrl?: string | undefined;
+    paymasterAddress?: string | undefined;
+    entryPointAddress?: string | undefined;
+    transferMaxFee?: number | undefined;
+}>>, Record<string, {
+    chainId: number;
+    blockchain: string;
+    provider?: string | undefined;
+    bundlerUrl?: string | undefined;
+    paymasterUrl?: string | undefined;
+    paymasterAddress?: string | undefined;
+    entryPointAddress?: string | undefined;
+    transferMaxFee?: number | undefined;
+}>, Record<string, {
+    chainId: number;
+    blockchain: string;
+    provider?: string | undefined;
+    bundlerUrl?: string | undefined;
+    paymasterUrl?: string | undefined;
+    paymasterAddress?: string | undefined;
+    entryPointAddress?: string | undefined;
+    transferMaxFee?: number | undefined;
+}>>;
+/**
+ * Token configuration schema
+ */
+export declare const tokenConfigSchema: z.ZodObject<{
+    symbol: z.ZodString;
+    name: z.ZodString;
+    decimals: z.ZodNumber;
+    address: z.ZodUnion<[z.ZodString, z.ZodNull]>;
+}, "strip", z.ZodTypeAny, {
+    symbol: string;
+    name: string;
+    decimals: number;
+    address: string | null;
+}, {
+    symbol: string;
+    name: string;
+    decimals: number;
+    address: string | null;
+}>;
+/**
+ * Network tokens schema
+ */
+export declare const networkTokensSchema: z.ZodObject<{
+    native: z.ZodObject<{
+        symbol: z.ZodString;
+        name: z.ZodString;
+        decimals: z.ZodNumber;
+        address: z.ZodUnion<[z.ZodString, z.ZodNull]>;
+    }, "strip", z.ZodTypeAny, {
+        symbol: string;
+        name: string;
+        decimals: number;
+        address: string | null;
+    }, {
+        symbol: string;
+        name: string;
+        decimals: number;
+        address: string | null;
+    }>;
+    tokens: z.ZodArray<z.ZodObject<{
+        symbol: z.ZodString;
+        name: z.ZodString;
+        decimals: z.ZodNumber;
+        address: z.ZodUnion<[z.ZodString, z.ZodNull]>;
+    }, "strip", z.ZodTypeAny, {
+        symbol: string;
+        name: string;
+        decimals: number;
+        address: string | null;
+    }, {
+        symbol: string;
+        name: string;
+        decimals: number;
+        address: string | null;
+    }>, "many">;
+}, "strip", z.ZodTypeAny, {
+    native: {
+        symbol: string;
+        name: string;
+        decimals: number;
+        address: string | null;
+    };
+    tokens: {
+        symbol: string;
+        name: string;
+        decimals: number;
+        address: string | null;
+    }[];
+}, {
+    native: {
+        symbol: string;
+        name: string;
+        decimals: number;
+        address: string | null;
+    };
+    tokens: {
+        symbol: string;
+        name: string;
+        decimals: number;
+        address: string | null;
+    }[];
+}>;
+/**
+ * Token configurations schema
+ */
+export declare const tokenConfigsSchema: z.ZodEffects<z.ZodRecord<z.ZodString, z.ZodObject<{
+    native: z.ZodObject<{
+        symbol: z.ZodString;
+        name: z.ZodString;
+        decimals: z.ZodNumber;
+        address: z.ZodUnion<[z.ZodString, z.ZodNull]>;
+    }, "strip", z.ZodTypeAny, {
+        symbol: string;
+        name: string;
+        decimals: number;
+        address: string | null;
+    }, {
+        symbol: string;
+        name: string;
+        decimals: number;
+        address: string | null;
+    }>;
+    tokens: z.ZodArray<z.ZodObject<{
+        symbol: z.ZodString;
+        name: z.ZodString;
+        decimals: z.ZodNumber;
+        address: z.ZodUnion<[z.ZodString, z.ZodNull]>;
+    }, "strip", z.ZodTypeAny, {
+        symbol: string;
+        name: string;
+        decimals: number;
+        address: string | null;
+    }, {
+        symbol: string;
+        name: string;
+        decimals: number;
+        address: string | null;
+    }>, "many">;
+}, "strip", z.ZodTypeAny, {
+    native: {
+        symbol: string;
+        name: string;
+        decimals: number;
+        address: string | null;
+    };
+    tokens: {
+        symbol: string;
+        name: string;
+        decimals: number;
+        address: string | null;
+    }[];
+}, {
+    native: {
+        symbol: string;
+        name: string;
+        decimals: number;
+        address: string | null;
+    };
+    tokens: {
+        symbol: string;
+        name: string;
+        decimals: number;
+        address: string | null;
+    }[];
+}>>, Record<string, {
+    native: {
+        symbol: string;
+        name: string;
+        decimals: number;
+        address: string | null;
+    };
+    tokens: {
+        symbol: string;
+        name: string;
+        decimals: number;
+        address: string | null;
+    }[];
+}>, Record<string, {
+    native: {
+        symbol: string;
+        name: string;
+        decimals: number;
+        address: string | null;
+    };
+    tokens: {
+        symbol: string;
+        name: string;
+        decimals: number;
+        address: string | null;
+    }[];
+}>>;
+/**
+ * Account index schema
+ */
+export declare const accountIndexSchema: z.ZodNumber;
+/**
+ * Network name schema
+ */
+export declare const networkNameSchema: z.ZodString;
+/**
+ * Balance string schema (valid number string)
+ */
+export declare const balanceStringSchema: z.ZodString;
+/**
+ * Wallet addresses schema
+ * Maps network -> accountIndex -> address
+ */
+export declare const walletAddressesSchema: z.ZodRecord<z.ZodString, z.ZodRecord<z.ZodEffects<z.ZodString, number, string>, z.ZodUnion<[z.ZodString, z.ZodString]>>>;
+/**
+ * Wallet balances schema
+ * Maps network -> accountIndex -> tokenAddress -> balance
+ */
+export declare const walletBalancesSchema: z.ZodRecord<z.ZodString, z.ZodRecord<z.ZodEffects<z.ZodString, number, string>, z.ZodRecord<z.ZodString, z.ZodString>>>;
+/**
+ * Balance loading states schema
+ * Maps "network-accountIndex-tokenAddress" -> boolean
+ */
+export declare const balanceLoadingStatesSchema: z.ZodRecord<z.ZodString, z.ZodBoolean>;
+/**
+ * Balance fetch result schema
+ */
+export declare const balanceFetchResultSchema: z.ZodObject<{
+    success: z.ZodBoolean;
+    network: z.ZodString;
+    accountIndex: z.ZodNumber;
+    tokenAddress: z.ZodUnion<[z.ZodString, z.ZodNull]>;
+    balance: z.ZodUnion<[z.ZodString, z.ZodNull]>;
+    error: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    success: boolean;
+    network: string;
+    accountIndex: number;
+    tokenAddress: string | null;
+    balance: string | null;
+    error?: string | undefined;
+}, {
+    success: boolean;
+    network: string;
+    accountIndex: number;
+    tokenAddress: string | null;
+    balance: string | null;
+    error?: string | undefined;
+}>;
+/**
+ * Wallet schema
+ */
+export declare const walletSchema: z.ZodObject<{
+    accountIndex: z.ZodNumber;
+    identifier: z.ZodString;
+    name: z.ZodString;
+    createdAt: z.ZodNumber;
+    updatedAt: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    name: string;
+    identifier: string;
+    accountIndex: number;
+    createdAt: number;
+    updatedAt: number;
+}, {
+    name: string;
+    identifier: string;
+    accountIndex: number;
+    createdAt: number;
+    updatedAt: number;
+}>;
+/**
+ * Worklet response schemas for runtime validation
+ */
+export declare const workletResponseSchema: z.ZodObject<{
+    result: z.ZodString;
+    error: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    result: string;
+    error?: string | undefined;
+}, {
+    result: string;
+    error?: string | undefined;
+}>;
+/**
+ * Balance response schema (numeric string)
+ */
+export declare const balanceResponseSchema: z.ZodString;
+/**
+ * Account method response schema (union of possible return types)
+ */
+export declare const accountMethodResponseSchema: z.ZodUnion<[z.ZodString, z.ZodString, z.ZodObject<{}, "passthrough", z.ZodTypeAny, z.objectOutputType<{}, z.ZodTypeAny, "passthrough">, z.objectInputType<{}, z.ZodTypeAny, "passthrough">>]>;