@reown/appkit-core-react-native 0.0.0-develop-20250728153935 → 0.0.0-develop-20251008155354

package/src/controllers/LogController.ts

@@ -0,0 +1,250 @@
+import { proxy } from 'valtio';
+import { OptionsController } from './OptionsController';
+import { sanitizeString, sanitizeStackTrace, sanitizeValue, sanitizeData } from '../utils/LogUtils';
+import { CoreHelperUtil } from '../utils/CoreHelperUtil';
+
+// -- Types --------------------------------------------- //
+export type LogLevel = 'info' | 'warn' | 'error' | 'debug';
+
+export interface LogEntry {
+  id: string;
+  timestamp: number;
+  level: LogLevel;
+  message: string;
+  fileName?: string;
+  functionName?: string;
+  data?: Record<string, unknown>;
+}
+
+export interface LogControllerState {
+  logs: LogEntry[];
+}
+
+// -- Constants ----------------------------------------- //
+const MAX_LOGS_COUNT = 300; // Prevent memory issues
+
+// -- State --------------------------------------------- //
+const state = proxy<LogControllerState>({
+  logs: []
+});
+
+const generateLogId = (): string => {
+  return CoreHelperUtil.getUUID();
+};
+
+const logToConsole = (entry: LogEntry) => {
+  const { debug } = OptionsController.state;
+
+  if (!debug) {
+    return;
+  }
+
+  const location =
+    entry.fileName && entry.functionName
+      ? `[${entry.fileName}:${entry.functionName}]`
+      : entry.fileName
+      ? `[${entry.fileName}]`
+      : '';
+
+  const logMessage = `[AppKit] ${location} ${entry.message}`;
+
+  switch (entry.level) {
+    case 'error':
+      // eslint-disable-next-line no-console
+      console.error(logMessage);
+      break;
+    case 'warn':
+      console.warn(logMessage);
+      break;
+    case 'debug':
+      // eslint-disable-next-line no-console
+      console.debug(logMessage);
+      break;
+    case 'info':
+    default:
+      // eslint-disable-next-line no-console
+      console.log(logMessage);
+      break;
+  }
+};
+
+// -- Controller ---------------------------------------- //
+export const LogController = {
+  state,
+
+  /**
+   * Destroy the LogController (cleanup resources)
+   */
+  destroy() {
+    // Clear all logs
+    state.logs = [];
+  },
+
+  /**
+   * Send a general log entry
+   */
+  sendLog(
+    level: LogLevel,
+    message: string,
+    fileName?: string,
+    functionName?: string,
+    data?: Record<string, unknown>
+  ) {
+    if (!OptionsController.state.debug) {
+      return;
+    }
+    const entry: LogEntry = {
+      id: generateLogId(),
+      timestamp: Date.now(),
+      level,
+      message: sanitizeString(message),
+      fileName,
+      functionName,
+      data: sanitizeData(data)
+    };
+
+    state.logs.push(entry);
+
+    // Enforce maximum log count
+    if (state.logs.length > MAX_LOGS_COUNT) {
+      state.logs = state.logs.slice(-MAX_LOGS_COUNT);
+    }
+
+    logToConsole(entry);
+  },
+
+  /**
+   * Send an error log entry - convenience method for try/catch blocks
+   */
+  sendError(
+    error: Error | string | unknown,
+    fileName?: string,
+    functionName?: string,
+    additionalData?: Record<string, unknown>
+  ) {
+    let message: string;
+    let data: Record<string, unknown> = sanitizeData(additionalData) || {};
+
+    if (error instanceof Error) {
+      message = error.message || 'Error occurred';
+      // Sanitize stack trace to remove sensitive file paths
+      data['stack'] = error.stack ? sanitizeStackTrace(error.stack) : undefined;
+      data['name'] = error.name;
+
+      // Sanitize any additional properties on the error object
+      const errorProps: Record<string, unknown> = {};
+      Object.getOwnPropertyNames(error).forEach(prop => {
+        if (prop !== 'message' && prop !== 'stack' && prop !== 'name') {
+          errorProps[prop] = (error as any)[prop];
+        }
+      });
+
+      if (Object.keys(errorProps).length > 0) {
+        Object.assign(data, sanitizeValue(errorProps) as Record<string, unknown>);
+      }
+    } else if (typeof error === 'string') {
+      message = error;
+    } else if (error && typeof error === 'object' && 'message' in error) {
+      // Handle error-like objects (e.g., RPC errors, custom error objects)
+      message = String((error as any).message) || 'Error occurred';
+      // Include all properties of the error object
+      Object.assign(data, sanitizeValue(error) as Record<string, unknown>);
+    } else {
+      message = 'Unknown error occurred';
+      // Sanitize the original error object
+      data['originalError'] = sanitizeValue(error);
+    }
+
+    // Note: sanitization happens in sendLog method
+    this.sendLog('error', message, fileName, functionName, data);
+  },
+
+  /**
+   * Send an info log entry
+   */
+  sendInfo(
+    message: string,
+    fileName?: string,
+    functionName?: string,
+    data?: Record<string, unknown>
+  ) {
+    this.sendLog('info', message, fileName, functionName, data);
+  },
+
+  /**
+   * Send a warning log entry
+   */
+  sendWarn(
+    message: string,
+    fileName?: string,
+    functionName?: string,
+    data?: Record<string, unknown>
+  ) {
+    this.sendLog('warn', message, fileName, functionName, data);
+  },
+
+  /**
+   * Send a debug log entry
+   */
+  sendDebug(
+    message: string,
+    fileName?: string,
+    functionName?: string,
+    data?: Record<string, unknown>
+  ) {
+    this.sendLog('debug', message, fileName, functionName, data);
+  },
+
+  /**
+   * Get all logs
+   */
+  getLogs(): LogEntry[] {
+    return [...state.logs];
+  },
+
+  /**
+   * Get logs by level
+   */
+  getLogsByLevel(level: LogLevel): LogEntry[] {
+    return state.logs.filter(log => log.level === level);
+  },
+
+  /**
+   * Get recent logs (last N entries)
+   */
+  getRecentLogs(count: number = 100): LogEntry[] {
+    return state.logs.slice(-count);
+  },
+
+  /**
+   * Clear all logs
+   */
+  clearLogs() {
+    state.logs = [];
+  },
+
+  /**
+   * Export logs as JSON string for debugging
+   */
+  exportLogs(): string {
+    return JSON.stringify(state.logs, null, 2);
+  },
+
+  /**
+   * Get logs count by level
+   */
+  getLogsStats(): Record<LogLevel, number> {
+    const stats: Record<LogLevel, number> = {
+      info: 0,
+      warn: 0,
+      error: 0,
+      debug: 0
+    };
+
+    state.logs.forEach(log => {
+      stats[log.level]++;
+    });
+
+    return stats;
+  }
+};

package/src/controllers/ModalController.ts

@@ -1,10 +1,9 @@
 import { proxy } from 'valtio';
-import { AccountController } from './AccountController';
 import { RouterController, type RouterControllerState } from './RouterController';
 import { PublicStateController } from './PublicStateController';
 import { EventsController } from './EventsController';
 import { ApiController } from './ApiController';
-import { ConnectorController } from './ConnectorController';
+import { ConnectionsController } from './ConnectionsController';
 
 // -- Types --------------------------------------------- //
 export interface ModalControllerState {
@@ -30,11 +29,15 @@ export const ModalController = {
 
   async open(options?: ModalControllerArguments['open']) {
     await ApiController.state.prefetchPromise;
-    const connected = AccountController.state.isConnected;
+    const isConnected = ConnectionsController.state.isConnected;
+    const isUniversalWallet = !!ConnectionsController.state.connection?.properties?.provider;
     if (options?.view) {
+      if (options.view === 'Account' && !isUniversalWallet) {
+        options.view = 'AccountDefault';
+      }
+
       RouterController.reset(options.view);
-    } else if (AccountController.state.isConnected) {
-      const isUniversalWallet = ConnectorController.state.connectedConnector === 'AUTH';
+    } else if (isConnected) {
       RouterController.reset(isUniversalWallet ? 'Account' : 'AccountDefault');
     } else {
       RouterController.reset('Connect');
@@ -44,12 +47,12 @@ export const ModalController = {
     EventsController.sendEvent({
       type: 'track',
       event: 'MODAL_OPEN',
-      properties: { connected }
+      properties: { connected: isConnected }
     });
   },
 
   close() {
-    const connected = AccountController.state.isConnected;
+    const connected = ConnectionsController.state.isConnected;
     state.open = false;
     PublicStateController.set({ open: false });
     EventsController.sendEvent({

package/src/controllers/OnRampController.ts

@@ -1,5 +1,5 @@
-import { subscribeKey as subKey } from 'valtio/vanilla/utils';
-import { proxy, subscribe as sub } from 'valtio/vanilla';
+import { subscribeKey as subKey } from 'valtio/utils';
+import { proxy, subscribe as sub } from 'valtio';
 import {
   type OnRampPaymentMethod,
   type OnRampCountry,
@@ -12,17 +12,17 @@ import {
   type OnRampErrorTypeValues,
   type OnRampCountryDefaults,
   BlockchainOnRampError
-} from '../utils/TypeUtil';
+} from '@reown/appkit-common-react-native';
 
 import { CoreHelperUtil } from '../utils/CoreHelperUtil';
-import { NetworkController } from './NetworkController';
-import { AccountController } from './AccountController';
 import { OptionsController } from './OptionsController';
 import { ConstantsUtil, OnRampErrorType } from '../utils/ConstantsUtil';
 import { StorageUtil } from '../utils/StorageUtil';
 import { SnackController } from './SnackController';
+import { LogController } from './LogController';
 import { EventsController } from './EventsController';
 import { BlockchainApiController, EXCLUDED_ONRAMP_PROVIDERS } from './BlockchainApiController';
+import { ConnectionsController } from './ConnectionsController';
 
 // -- Helpers ------------------------------------------- //
 
@@ -125,7 +125,11 @@ export const OnRampController = {
           state.countriesDefaults?.find(d => d.countryCode === country.countryCode)
             ?.defaultCurrencyCode || 'USD';
 
-        const currency = state.paymentCurrencies?.find(c => c.currencyCode === currencyCode);
+        let currency = state.paymentCurrencies?.find(c => c.currencyCode === currencyCode);
+
+        if (!currency) {
+          currency = state.paymentCurrencies?.find(c => c.currencyCode === 'USD');
+        }
 
         if (currency) {
           this.setPaymentCurrency(currency);
@@ -139,6 +143,7 @@ export const OnRampController = {
 
       StorageUtil.setOnRampPreferredCountry(country);
     } catch (error) {
+      LogController.sendError(error, 'OnRampController.ts', 'setSelectedCountry');
       state.loading = false;
       state.error = {
         type: OnRampErrorType.FAILED_TO_LOAD_COUNTRIES,
@@ -188,16 +193,16 @@ export const OnRampController = {
 
   updateSelectedPurchaseCurrency() {
     let selectedCurrency;
-    if (NetworkController.state.caipNetwork?.id) {
+    if (ConnectionsController.state.activeNetwork?.caipNetworkId) {
       const defaultCurrency =
         ConstantsUtil.NETWORK_DEFAULT_CURRENCIES[
-          NetworkController.state.caipNetwork
-            ?.id as keyof typeof ConstantsUtil.NETWORK_DEFAULT_CURRENCIES
+          ConnectionsController.state.activeNetwork
+            ?.caipNetworkId as keyof typeof ConstantsUtil.NETWORK_DEFAULT_CURRENCIES
         ];
       selectedCurrency = state.purchaseCurrencies?.find(c => c.currencyCode === defaultCurrency);
     }
 
-    state.purchaseCurrency = selectedCurrency ?? state.purchaseCurrencies?.[0] ?? undefined;
+    state.purchaseCurrency = selectedCurrency ?? undefined;
   },
 
   getServiceProviderImage(serviceProviderName?: string) {
@@ -237,6 +242,7 @@ export const OnRampController = {
           countries.find(c => c.countryCode === countryCode) || countries[0] || undefined;
       }
     } catch (error) {
+      LogController.sendError(error, 'OnRampController.ts', 'fetchCountries');
       state.error = {
         type: OnRampErrorType.FAILED_TO_LOAD_COUNTRIES,
         message: 'Failed to load countries'
@@ -258,6 +264,7 @@ export const OnRampController = {
 
       state.countriesDefaults = countriesDefaults;
     } catch (error) {
+      LogController.sendError(error, 'OnRampController.ts', 'fetchCountriesDefaults');
       state.error = {
         type: OnRampErrorType.FAILED_TO_LOAD_COUNTRIES,
         message: 'Failed to load countries defaults'
@@ -279,6 +286,7 @@ export const OnRampController = {
 
       state.serviceProviders = serviceProviders || [];
     } catch (error) {
+      LogController.sendError(error, 'OnRampController.ts', 'fetchServiceProviders');
       state.error = {
         type: OnRampErrorType.FAILED_TO_LOAD_PROVIDERS,
         message: 'Failed to load service providers'
@@ -310,6 +318,7 @@ export const OnRampController = {
 
       state.selectedPaymentMethod = state.paymentMethods[0];
     } catch (error) {
+      LogController.sendError(error, 'OnRampController.ts', 'fetchPaymentMethods');
       state.error = {
         type: OnRampErrorType.FAILED_TO_LOAD_METHODS,
         message: 'Failed to load payment methods'
@@ -328,17 +337,18 @@ export const OnRampController = {
       state.purchaseCurrencies = cryptoCurrencies || [];
 
       let selectedCurrency;
-      if (NetworkController.state.caipNetwork?.id) {
+      if (ConnectionsController.state.activeNetwork?.caipNetworkId) {
         const defaultCurrency =
           ConstantsUtil.NETWORK_DEFAULT_CURRENCIES[
-            NetworkController.state.caipNetwork
-              ?.id as keyof typeof ConstantsUtil.NETWORK_DEFAULT_CURRENCIES
-          ] || 'ETH';
+            ConnectionsController.state.activeNetwork
+              ?.caipNetworkId as keyof typeof ConstantsUtil.NETWORK_DEFAULT_CURRENCIES
+          ];
         selectedCurrency = state.purchaseCurrencies?.find(c => c.currencyCode === defaultCurrency);
       }
 
-      state.purchaseCurrency = selectedCurrency || cryptoCurrencies?.[0] || undefined;
+      state.purchaseCurrency = selectedCurrency || undefined;
     } catch (error) {
+      LogController.sendError(error, 'OnRampController.ts', 'fetchCryptoCurrencies');
       state.error = {
         type: OnRampErrorType.FAILED_TO_LOAD_CURRENCIES,
         message: 'Failed to load crypto currencies'
@@ -382,6 +392,7 @@ export const OnRampController = {
         this.setPaymentCurrency(defaultCurrency);
       }
     } catch (error) {
+      LogController.sendError(error, 'OnRampController.ts', 'fetchFiatCurrencies');
       state.error = {
         type: OnRampErrorType.FAILED_TO_LOAD_CURRENCIES,
         message: 'Failed to load fiat currencies'
@@ -420,7 +431,7 @@ export const OnRampController = {
         !state.selectedCountry?.countryCode ||
         !state.purchaseCurrency?.currencyCode ||
         !state.paymentCurrency?.currencyCode ||
-        !AccountController.state.address
+        !ConnectionsController.state.activeAddress
       ) {
         throw new BlockchainOnRampError(OnRampErrorType.UNKNOWN, 'Invalid quote parameters');
       }
@@ -430,12 +441,20 @@ export const OnRampController = {
       state.selectedServiceProvider = undefined;
       state.error = undefined;
 
+      const plainAddress = CoreHelperUtil.getPlainAddress(
+        ConnectionsController.state.activeAddress
+      );
+
+      if (!plainAddress) {
+        throw new Error('Invalid address');
+      }
+
       const body = {
         countryCode: state.selectedCountry.countryCode,
         destinationCurrencyCode: state.purchaseCurrency.currencyCode,
         sourceAmount: state.paymentAmount!,
         sourceCurrencyCode: state.paymentCurrency.currencyCode,
-        walletAddress: AccountController.state.address,
+        walletAddress: plainAddress,
         excludeProviders: EXCLUDED_ONRAMP_PROVIDERS
       };
 
@@ -492,6 +511,7 @@ export const OnRampController = {
         sp => sp.serviceProvider === state.selectedQuote?.serviceProvider
       );
     } catch (error: any) {
+      LogController.sendError(error, 'OnRampController.ts', 'getQuotes');
       if (error.name === 'AbortError') {
         // Do nothing, another request was made
         return;
@@ -524,7 +544,7 @@ export const OnRampController = {
       state.paymentCurrency?.currencyCode &&
       state.selectedCountry &&
       !state.loading &&
-      AccountController.state.address
+      ConnectionsController.state.activeAddress
     );
   },
 
@@ -542,6 +562,7 @@ export const OnRampController = {
 
       state.paymentCurrenciesLimits = limits;
     } catch (error) {
+      LogController.sendError(error, 'OnRampController.ts', 'fetchFiatLimits');
       state.error = {
         type: OnRampErrorType.FAILED_TO_LOAD_LIMITS,
         message: 'Failed to load fiat limits'
@@ -551,6 +572,10 @@ export const OnRampController = {
   },
 
   async generateWidget({ quote }: { quote: OnRampQuote }) {
+    if (!ConnectionsController.state.activeAddress) {
+      throw new Error('No active address');
+    }
+
     const metadata = OptionsController.state.metadata;
     const eventProperties = {
       asset: quote.destinationCurrencyCode,
@@ -567,6 +592,14 @@ export const OnRampController = {
         throw new Error('Invalid quote');
       }
 
+      const plainAddress = CoreHelperUtil.getPlainAddress(
+        ConnectionsController.state.activeAddress
+      );
+
+      if (!plainAddress) {
+        throw new Error('Invalid address');
+      }
+
       const body = {
         countryCode: quote.countryCode,
         destinationCurrencyCode: quote.destinationCurrencyCode,
@@ -574,7 +607,7 @@ export const OnRampController = {
         serviceProvider: quote.serviceProvider,
         sourceAmount: quote.sourceAmount,
         sourceCurrencyCode: quote.sourceCurrencyCode,
-        walletAddress: AccountController.state.address!,
+        walletAddress: plainAddress,
         redirectUrl: metadata?.redirect?.universal ?? metadata?.redirect?.native
       };
 
@@ -594,6 +627,7 @@ export const OnRampController = {
 
       return widget;
     } catch (e: any) {
+      LogController.sendError(e, 'OnRampController.ts', 'generateWidget', { quote });
       EventsController.sendEvent({
         type: 'track',
         event: 'BUY_FAIL',
@@ -639,6 +673,7 @@ export const OnRampController = {
         this.fetchFiatCurrencies()
       ]);
     } catch (error) {
+      LogController.sendError(error, 'OnRampController.ts', 'loadOnRampData');
       if (!state.error) {
         state.error = {
           type: OnRampErrorType.FAILED_TO_LOAD,

package/src/controllers/OptionsController.ts

@@ -1,13 +1,16 @@
 import { proxy, ref } from 'valtio';
 import type {
+  Storage,
+  Metadata,
+  AppKitNetwork,
   CustomWallet,
   Features,
-  Metadata,
   ProjectId,
   SdkType,
   SdkVersion,
-  Tokens
-} from '../utils/TypeUtil';
+  SIWXConfig
+} from '@reown/appkit-common-react-native';
+
 import { ConstantsUtil } from '../utils/ConstantsUtil';
 
 // -- Types --------------------------------------------- //
@@ -17,28 +20,31 @@ export interface ClipboardClient {
 
 export interface OptionsControllerState {
   projectId: ProjectId;
-  _clipboardClient?: ClipboardClient;
+  clipboardClient?: ClipboardClient;
+  storage?: Storage;
   includeWalletIds?: string[];
   excludeWalletIds?: string[];
   featuredWalletIds?: string[];
   customWallets?: CustomWallet[];
-  tokens?: Tokens;
   enableAnalytics?: boolean;
   sdkType: SdkType;
   sdkVersion: SdkVersion;
   metadata?: Metadata;
-  isSiweEnabled?: boolean;
+  siwx?: SIWXConfig;
   isOnRampEnabled?: boolean;
   features?: Features;
   debug?: boolean;
+  defaultNetwork?: AppKitNetwork;
+  requestedNetworks?: AppKitNetwork[];
 }
 
 // -- State --------------------------------------------- //
 const state = proxy<OptionsControllerState>({
   projectId: '',
   sdkType: 'appkit',
-  sdkVersion: 'react-native-wagmi-undefined',
+  sdkVersion: 'react-native-undefined-undefined',
   features: ConstantsUtil.DEFAULT_FEATURES,
+  customWallets: [],
   debug: false
 });
 
@@ -47,7 +53,7 @@ export const OptionsController = {
   state,
 
   setClipboardClient(client: ClipboardClient) {
-    state._clipboardClient = ref(client);
+    state.clipboardClient = ref(client);
   },
 
   setProjectId(projectId: OptionsControllerState['projectId']) {
@@ -66,10 +72,6 @@ export const OptionsController = {
     state.featuredWalletIds = featuredWalletIds;
   },
 
-  setTokens(tokens: OptionsControllerState['tokens']) {
-    state.tokens = tokens;
-  },
-
   setCustomWallets(customWallets: OptionsControllerState['customWallets']) {
     state.customWallets = customWallets;
   },
@@ -86,10 +88,6 @@ export const OptionsController = {
     state.metadata = metadata;
   },
 
-  setIsSiweEnabled(isSiweEnabled: OptionsControllerState['isSiweEnabled']) {
-    state.isSiweEnabled = isSiweEnabled;
-  },
-
   setFeatures(features: OptionsControllerState['features']) {
     state.features = { ...ConstantsUtil.DEFAULT_FEATURES, ...features };
   },
@@ -102,12 +100,42 @@ export const OptionsController = {
     state.isOnRampEnabled = isOnRampEnabled;
   },
 
+  setStorage(storage?: OptionsControllerState['storage']) {
+    if (storage) {
+      state.storage = ref(storage);
+    }
+  },
+
+  setDefaultNetwork(defaultNetwork?: OptionsControllerState['defaultNetwork']) {
+    state.defaultNetwork = defaultNetwork;
+  },
+
+  setRequestedNetworks(requestedNetworks?: OptionsControllerState['requestedNetworks']) {
+    state.requestedNetworks = requestedNetworks;
+  },
+
+  setSiwx(siwx?: OptionsControllerState['siwx']) {
+    if (siwx && (siwx?.signOutOnDisconnect === undefined || siwx?.signOutOnDisconnect === null)) {
+      siwx.signOutOnDisconnect = true;
+    }
+
+    state.siwx = siwx;
+  },
+
   isClipboardAvailable() {
-    return !!state._clipboardClient;
+    return !!state.clipboardClient;
+  },
+
+  getStorage() {
+    if (!state.storage) {
+      throw new Error('AppKit: Storage is not set');
+    }
+
+    return state.storage;
   },
 
   copyToClipboard(value: string) {
-    const client = state._clipboardClient;
+    const client = state.clipboardClient;
     if (client) {
       client?.setString(value);
     }

package/src/controllers/PublicStateController.ts

@@ -1,6 +1,6 @@
 import { proxy, subscribe as sub } from 'valtio';
 import { subscribeKey as subKey } from 'valtio/utils';
-import type { CaipNetworkId } from '../utils/TypeUtil.js';
+import type { CaipNetworkId } from '@reown/appkit-common-react-native';
 
 // -- Types --------------------------------------------- //
 export interface PublicStateControllerState {