@reown/appkit-core-react-native 0.0.0-chore-spring-effect-20250909214820 → 0.0.0-chore-added-import-20251002170458

package/src/utils/LogUtils.ts

@@ -0,0 +1,179 @@
+// -- Constants ----------------------------------------- //
+const SENSITIVE_KEYS = [
+  'password',
+  'pass',
+  'pwd',
+  'secret',
+  'token',
+  'key',
+  'auth',
+  'authorization',
+  'bearer',
+  'credential',
+  'api_key',
+  'apikey',
+  'access_token',
+  'refresh_token',
+  'private_key',
+  'privatekey',
+  'mnemonic',
+  'seed',
+  'phrase',
+  'wallet',
+  'address',
+  'email',
+  'phone',
+  'ssn',
+  'social',
+  'credit',
+  'card',
+  'cvv',
+  'connection_string',
+  'connection',
+  'user_token'
+];
+
+const MAX_STRING_LENGTH = 480; // Maximum length for any string value (account for potential replacements)
+const MAX_STACK_LINES = 10; // Maximum lines in stack trace
+
+// -- Data Sanitization Functions ---------------------- //
+export const sanitizeString = (value: string): string => {
+  if (typeof value !== 'string') {
+    value = String(value);
+  }
+
+  if (value.length > MAX_STRING_LENGTH) {
+    return value.substring(0, MAX_STRING_LENGTH) + '... [truncated]';
+  }
+
+  return value;
+};
+
+export const sanitizeStackTrace = (stack: string): string => {
+  if (typeof stack !== 'string') {
+    stack = String(stack);
+  }
+
+  const lines = stack.split('\n');
+  const sanitizedLines = lines.slice(0, MAX_STACK_LINES).map(line => {
+    // Remove file paths that might contain sensitive info
+    return line.replace(/\/[^\s]*\//g, '/[path]/');
+  });
+
+  if (lines.length > MAX_STACK_LINES) {
+    sanitizedLines.push('... [stack trace truncated]');
+  }
+
+  return sanitizedLines.join('\n');
+};
+
+export const sanitizeUrl = (url: string): string => {
+  try {
+    const urlObj = new URL(url);
+    // Remove query parameters that might contain sensitive data
+    urlObj.search = '';
+    // Keep only the origin and pathname
+
+    return urlObj.origin + urlObj.pathname;
+  } catch {
+    // If URL parsing fails, just return sanitized string
+
+    return sanitizeString(url);
+  }
+};
+
+const isSensitiveKey = (key: string): boolean => {
+  const lowerKey = key.toLowerCase();
+
+  return SENSITIVE_KEYS.some(sensitiveKey => lowerKey.includes(sensitiveKey));
+};
+
+export const sanitizeValue = (value: unknown, visited = new WeakSet()): unknown => {
+  if (value === null || value === undefined) {
+    return value;
+  }
+
+  if (typeof value === 'string') {
+    // Check if it looks like a URL
+    if (value.startsWith('http://') || value.startsWith('https://')) {
+      return sanitizeUrl(value);
+    }
+
+    return sanitizeString(value);
+  }
+
+  if (typeof value === 'number' || typeof value === 'boolean') {
+    return value;
+  }
+
+  if (Array.isArray(value)) {
+    // Prevent circular references in arrays
+    if (visited.has(value)) {
+      return '[Circular Reference]';
+    }
+
+    visited.add(value);
+    const result = value.slice(0, 10).map(item => sanitizeValue(item, visited));
+    visited.delete(value);
+
+    return result;
+  }
+
+  if (typeof value === 'object') {
+    return sanitizeObject(value as Record<string, unknown>, visited);
+  }
+
+  // For other types, convert to string and sanitize
+  return sanitizeString(String(value));
+};
+
+export const sanitizeObject = (
+  obj: Record<string, unknown>,
+  visited = new WeakSet()
+): Record<string, unknown> => {
+  // Prevent circular references
+  if (visited.has(obj)) {
+    return { '[Circular Reference]': true };
+  }
+
+  visited.add(obj);
+
+  const sanitized: Record<string, unknown> = {};
+  const keys = Object.keys(obj).slice(0, 20); // Limit number of keys
+
+  for (const key of keys) {
+    if (isSensitiveKey(key)) {
+      sanitized[key] = '[REDACTED]';
+    } else {
+      sanitized[key] = sanitizeValue(obj[key], visited);
+    }
+  }
+
+  if (Object.keys(obj).length > 20) {
+    sanitized['...'] = '[additional properties truncated]';
+  }
+
+  visited.delete(obj);
+
+  return sanitized;
+};
+
+export const sanitizeData = (
+  data?: Record<string, unknown>
+): Record<string, unknown> | undefined => {
+  if (!data) {
+    return undefined;
+  }
+
+  return sanitizeObject(data);
+};
+
+// -- Utility Functions --------------------------------- //
+export const LogUtils = {
+  sanitizeString,
+  sanitizeStackTrace,
+  sanitizeUrl,
+  sanitizeValue,
+  sanitizeObject,
+  sanitizeData
+};

package/src/utils/StorageUtil.ts

@@ -10,33 +10,34 @@ import {
   type ConnectorType,
   type ChainNamespace,
   type WalletDeepLink,
-  ConstantsUtil
+  SafeStorageKeys
 } from '@reown/appkit-common-react-native';
 import { OptionsController } from '../controllers/OptionsController';
+import { LogController } from '../controllers/LogController';
 
 // -- Utility -----------------------------------------------------------------
 export const StorageUtil = {
   setWalletConnectDeepLink({ href, name }: WalletDeepLink) {
     try {
-      OptionsController.getStorage().setItem(ConstantsUtil.STORAGE_KEYS.WC_DEEPLINK, {
+      OptionsController.getStorage().setItem(SafeStorageKeys.WC_DEEPLINK, {
         href,
         name
       });
-    } catch {
-      console.info('Unable to set WalletConnect deep link');
+    } catch (error) {
+      LogController.sendError(error, 'StorageUtil.ts', 'setWalletConnectDeepLink');
     }
   },
 
   async getWalletConnectDeepLink() {
     try {
       const deepLink = await OptionsController.getStorage().getItem<WalletDeepLink>(
-        ConstantsUtil.STORAGE_KEYS.WC_DEEPLINK
+        SafeStorageKeys.WC_DEEPLINK
       );
       if (deepLink) {
         return deepLink;
       }
-    } catch {
-      console.info('Unable to get WalletConnect deep link');
+    } catch (error) {
+      LogController.sendError(error, 'StorageUtil.ts', 'getWalletConnectDeepLink');
     }
 
     return undefined;
@@ -44,9 +45,9 @@ export const StorageUtil = {
 
   async removeWalletConnectDeepLink() {
     try {
-      await OptionsController.getStorage().removeItem(ConstantsUtil.STORAGE_KEYS.WC_DEEPLINK);
-    } catch {
-      console.info('Unable to remove WalletConnect deep link');
+      await OptionsController.getStorage().removeItem(SafeStorageKeys.WC_DEEPLINK);
+    } catch (error) {
+      LogController.sendError(error, 'StorageUtil.ts', 'removeWalletConnectDeepLink');
     }
   },
 
@@ -63,14 +64,11 @@ export const StorageUtil = {
       if (recentWallets.length > 2) {
         recentWallets.pop();
       }
-      OptionsController.getStorage().setItem(
-        ConstantsUtil.STORAGE_KEYS.RECENT_WALLET,
-        recentWallets
-      );
+      OptionsController.getStorage().setItem(SafeStorageKeys.RECENT_WALLET, recentWallets);
 
       return recentWallets;
-    } catch {
-      console.info('Unable to set recent wallet');
+    } catch (error) {
+      LogController.sendError(error, 'StorageUtil.ts', 'addRecentWallet');
 
       return undefined;
     }
@@ -78,24 +76,19 @@ export const StorageUtil = {
 
   async setRecentWallets(wallets: WcWallet[]) {
     try {
-      await OptionsController.getStorage().setItem(
-        ConstantsUtil.STORAGE_KEYS.RECENT_WALLET,
-        wallets
-      );
-    } catch {
-      console.info('Unable to set recent wallets');
+      await OptionsController.getStorage().setItem(SafeStorageKeys.RECENT_WALLET, wallets);
+    } catch (error) {
+      LogController.sendError(error, 'StorageUtil.ts', 'setRecentWallets');
     }
   },
 
   async getRecentWallets(): Promise<WcWallet[]> {
     try {
-      const recent = await OptionsController.getStorage().getItem(
-        ConstantsUtil.STORAGE_KEYS.RECENT_WALLET
-      );
+      const recent = await OptionsController.getStorage().getItem(SafeStorageKeys.RECENT_WALLET);
 
       return recent ?? [];
-    } catch {
-      console.info('Unable to get recent wallets');
+    } catch (error) {
+      LogController.sendError(error, 'StorageUtil.ts', 'getRecentWallets');
     }
 
     return [];
@@ -114,12 +107,12 @@ export const StorageUtil = {
       if (!currentConnectors.some(c => c.type === type)) {
         const updatedConnectors = [...currentConnectors, { type, namespaces }];
         await OptionsController.getStorage().setItem(
-          ConstantsUtil.STORAGE_KEYS.CONNECTED_CONNECTORS,
+          SafeStorageKeys.CONNECTED_CONNECTORS,
           updatedConnectors
         );
       }
-    } catch {
-      console.info('Unable to set Connected Connector');
+    } catch (error) {
+      LogController.sendError(error, 'StorageUtil.ts', 'setConnectedConnectors');
     }
   },
 
@@ -127,11 +120,11 @@ export const StorageUtil = {
     try {
       const connectors = await OptionsController.getStorage().getItem<
         { type: ConnectorType; namespaces: string[] }[]
-      >(ConstantsUtil.STORAGE_KEYS.CONNECTED_CONNECTORS);
+      >(SafeStorageKeys.CONNECTED_CONNECTORS);
 
       return connectors ?? [];
     } catch (err) {
-      console.info('Unable to get Connected Connector');
+      LogController.sendError(err, 'StorageUtil.ts', 'getConnectedConnectors');
     }
 
     return [];
@@ -142,29 +135,29 @@ export const StorageUtil = {
       const currentConnectors = await StorageUtil.getConnectedConnectors();
       const updatedConnectors = currentConnectors.filter(c => c.type !== type);
       await OptionsController.getStorage().setItem(
-        ConstantsUtil.STORAGE_KEYS.CONNECTED_CONNECTORS,
+        SafeStorageKeys.CONNECTED_CONNECTORS,
         updatedConnectors
       );
-    } catch {
-      console.info('Unable to remove Connected Connector');
+    } catch (error) {
+      LogController.sendError(error, 'StorageUtil.ts', 'removeConnectedConnectors');
     }
   },
 
   async setOnRampPreferredCountry(country: OnRampCountry) {
     try {
       await OptionsController.getStorage().setItem(
-        ConstantsUtil.STORAGE_KEYS.ONRAMP_PREFERRED_COUNTRY,
+        SafeStorageKeys.ONRAMP_PREFERRED_COUNTRY,
         country
       );
-    } catch {
-      console.info('Unable to set OnRamp Preferred Country');
+    } catch (error) {
+      LogController.sendError(error, 'StorageUtil.ts', 'setOnRampPreferredCountry');
     }
   },
 
   async getOnRampPreferredCountry() {
     try {
       const country = await OptionsController.getStorage().getItem<OnRampCountry>(
-        ConstantsUtil.STORAGE_KEYS.ONRAMP_PREFERRED_COUNTRY
+        SafeStorageKeys.ONRAMP_PREFERRED_COUNTRY
       );
 
       return country ?? undefined;
@@ -178,23 +171,23 @@ export const StorageUtil = {
   async setOnRampPreferredFiatCurrency(currency: OnRampFiatCurrency) {
     try {
       await OptionsController.getStorage().setItem(
-        ConstantsUtil.STORAGE_KEYS.ONRAMP_PREFERRED_FIAT_CURRENCY,
+        SafeStorageKeys.ONRAMP_PREFERRED_FIAT_CURRENCY,
         currency
       );
-    } catch {
-      console.info('Unable to set OnRamp Preferred Fiat Currency');
+    } catch (error) {
+      LogController.sendError(error, 'StorageUtil.ts', 'setOnRampPreferredFiatCurrency');
     }
   },
 
   async getOnRampPreferredFiatCurrency() {
     try {
       const currency = await OptionsController.getStorage().getItem<OnRampFiatCurrency>(
-        ConstantsUtil.STORAGE_KEYS.ONRAMP_PREFERRED_FIAT_CURRENCY
+        SafeStorageKeys.ONRAMP_PREFERRED_FIAT_CURRENCY
       );
 
       return currency ?? undefined;
-    } catch {
-      console.info('Unable to get OnRamp Preferred Fiat Currency');
+    } catch (error) {
+      LogController.sendError(error, 'StorageUtil.ts', 'getOnRampPreferredFiatCurrency');
     }
 
     return undefined;
@@ -202,24 +195,21 @@ export const StorageUtil = {
 
   async setOnRampCountries(countries: OnRampCountry[]) {
     try {
-      await OptionsController.getStorage().setItem(
-        ConstantsUtil.STORAGE_KEYS.ONRAMP_COUNTRIES,
-        countries
-      );
-    } catch {
-      console.info('Unable to set OnRamp Countries');
+      await OptionsController.getStorage().setItem(SafeStorageKeys.ONRAMP_COUNTRIES, countries);
+    } catch (error) {
+      LogController.sendError(error, 'StorageUtil.ts', 'setOnRampCountries');
     }
   },
 
   async getOnRampCountries() {
     try {
       const countries = await OptionsController.getStorage().getItem<OnRampCountry[]>(
-        ConstantsUtil.STORAGE_KEYS.ONRAMP_COUNTRIES
+        SafeStorageKeys.ONRAMP_COUNTRIES
       );
 
       return countries ?? [];
-    } catch {
-      console.info('Unable to get OnRamp Countries');
+    } catch (error) {
+      LogController.sendError(error, 'StorageUtil.ts', 'getOnRampCountries');
     }
 
     return [];
@@ -229,19 +219,19 @@ export const StorageUtil = {
     try {
       const timestamp = Date.now();
 
-      await OptionsController.getStorage().setItem(
-        ConstantsUtil.STORAGE_KEYS.ONRAMP_COUNTRIES_DEFAULTS,
-        { data: countriesDefaults, timestamp }
-      );
-    } catch {
-      console.info('Unable to set OnRamp Countries Defaults');
+      await OptionsController.getStorage().setItem(SafeStorageKeys.ONRAMP_COUNTRIES_DEFAULTS, {
+        data: countriesDefaults,
+        timestamp
+      });
+    } catch (error) {
+      LogController.sendError(error, 'StorageUtil.ts', 'setOnRampCountriesDefaults');
     }
   },
 
   async getOnRampCountriesDefaults() {
     try {
       const result = await OptionsController.getStorage().getItem(
-        ConstantsUtil.STORAGE_KEYS.ONRAMP_COUNTRIES_DEFAULTS
+        SafeStorageKeys.ONRAMP_COUNTRIES_DEFAULTS
       );
 
       if (!result) {
@@ -256,8 +246,8 @@ export const StorageUtil = {
       }
 
       return (data as OnRampCountryDefaults[]) ?? [];
-    } catch {
-      console.info('Unable to get OnRamp Countries Defaults');
+    } catch (error) {
+      LogController.sendError(error, 'StorageUtil.ts', 'getOnRampCountriesDefaults');
     }
 
     return [];
@@ -267,19 +257,19 @@ export const StorageUtil = {
     try {
       const timestamp = Date.now();
 
-      await OptionsController.getStorage().setItem(
-        ConstantsUtil.STORAGE_KEYS.ONRAMP_SERVICE_PROVIDERS,
-        { data: serviceProviders, timestamp }
-      );
-    } catch {
-      console.info('Unable to set OnRamp Service Providers');
+      await OptionsController.getStorage().setItem(SafeStorageKeys.ONRAMP_SERVICE_PROVIDERS, {
+        data: serviceProviders,
+        timestamp
+      });
+    } catch (error) {
+      LogController.sendError(error, 'StorageUtil.ts', 'setOnRampServiceProviders');
     }
   },
 
   async getOnRampServiceProviders() {
     try {
       const result = await OptionsController.getStorage().getItem(
-        ConstantsUtil.STORAGE_KEYS.ONRAMP_SERVICE_PROVIDERS
+        SafeStorageKeys.ONRAMP_SERVICE_PROVIDERS
       );
 
       if (!result) {
@@ -295,8 +285,7 @@ export const StorageUtil = {
 
       return (data as OnRampServiceProvider[]) ?? [];
     } catch (err) {
-      console.error(err);
-      console.info('Unable to get OnRamp Service Providers');
+      LogController.sendError(err, 'StorageUtil.ts', 'getOnRampServiceProviders');
     }
 
     return [];
@@ -306,19 +295,19 @@ export const StorageUtil = {
     try {
       const timestamp = Date.now();
 
-      await OptionsController.getStorage().setItem(ConstantsUtil.STORAGE_KEYS.ONRAMP_FIAT_LIMITS, {
+      await OptionsController.getStorage().setItem(SafeStorageKeys.ONRAMP_FIAT_LIMITS, {
         data: fiatLimits,
         timestamp
       });
-    } catch {
-      console.info('Unable to set OnRamp Fiat Limits');
+    } catch (error) {
+      LogController.sendError(error, 'StorageUtil.ts', 'setOnRampFiatLimits');
     }
   },
 
   async getOnRampFiatLimits() {
     try {
       const result = await OptionsController.getStorage().getItem(
-        ConstantsUtil.STORAGE_KEYS.ONRAMP_FIAT_LIMITS
+        SafeStorageKeys.ONRAMP_FIAT_LIMITS
       );
 
       if (!result) {
@@ -333,8 +322,8 @@ export const StorageUtil = {
       }
 
       return (data as OnRampFiatLimit[]) ?? [];
-    } catch {
-      console.info('Unable to get OnRamp Fiat Limits');
+    } catch (error) {
+      LogController.sendError(error, 'StorageUtil.ts', 'getOnRampFiatLimits');
     }
 
     return [];
@@ -344,19 +333,19 @@ export const StorageUtil = {
     try {
       const timestamp = Date.now();
 
-      await OptionsController.getStorage().setItem(
-        ConstantsUtil.STORAGE_KEYS.ONRAMP_FIAT_CURRENCIES,
-        { data: fiatCurrencies, timestamp }
-      );
-    } catch {
-      console.info('Unable to set OnRamp Fiat Currencies');
+      await OptionsController.getStorage().setItem(SafeStorageKeys.ONRAMP_FIAT_CURRENCIES, {
+        data: fiatCurrencies,
+        timestamp
+      });
+    } catch (error) {
+      LogController.sendError(error, 'StorageUtil.ts', 'setOnRampFiatCurrencies');
     }
   },
 
   async getOnRampFiatCurrencies() {
     try {
       const result = await OptionsController.getStorage().getItem(
-        ConstantsUtil.STORAGE_KEYS.ONRAMP_FIAT_CURRENCIES
+        SafeStorageKeys.ONRAMP_FIAT_CURRENCIES
       );
 
       if (!result) {
@@ -371,8 +360,8 @@ export const StorageUtil = {
       }
 
       return (data as OnRampFiatCurrency[]) ?? [];
-    } catch {
-      console.info('Unable to get OnRamp Fiat Currencies');
+    } catch (error) {
+      LogController.sendError(error, 'StorageUtil.ts', 'getOnRampFiatCurrencies');
     }
 
     return [];
@@ -381,32 +370,26 @@ export const StorageUtil = {
   async setActiveNamespace(namespace?: ChainNamespace) {
     try {
       if (!namespace) {
-        await OptionsController.getStorage().removeItem(
-          ConstantsUtil.STORAGE_KEYS.ACTIVE_NAMESPACE
-        );
+        await OptionsController.getStorage().removeItem(SafeStorageKeys.ACTIVE_NAMESPACE);
 
         return;
       }
 
-      await OptionsController.getStorage().setItem(
-        ConstantsUtil.STORAGE_KEYS.ACTIVE_NAMESPACE,
-        namespace
-      );
-    } catch {
-      console.info('Unable to set Active Namespace');
+      await OptionsController.getStorage().setItem(SafeStorageKeys.ACTIVE_NAMESPACE, namespace);
+    } catch (error) {
+      LogController.sendError(error, 'StorageUtil.ts', 'setActiveNamespace');
     }
   },
 
   async getActiveNamespace() {
     try {
       const namespace = (await OptionsController.getStorage().getItem(
-        ConstantsUtil.STORAGE_KEYS.ACTIVE_NAMESPACE
+        SafeStorageKeys.ACTIVE_NAMESPACE
       )) as ChainNamespace;
 
       return namespace ?? undefined;
     } catch (err) {
-      console.error(err);
-      console.info('Unable to get Active Namespace');
+      LogController.sendError(err, 'StorageUtil.ts', 'getActiveNamespace');
     }
 
     return undefined;
@@ -414,9 +397,9 @@ export const StorageUtil = {
 
   async removeActiveNamespace() {
     try {
-      await OptionsController.getStorage().removeItem(ConstantsUtil.STORAGE_KEYS.ACTIVE_NAMESPACE);
-    } catch {
-      console.info('Unable to remove Active Namespace');
+      await OptionsController.getStorage().removeItem(SafeStorageKeys.ACTIVE_NAMESPACE);
+    } catch (error) {
+      LogController.sendError(error, 'StorageUtil.ts', 'removeActiveNamespace');
     }
   }
 };