@reown/appkit-core-react-native 0.0.0-feat-multichain-20250925192219 → 0.0.0-feat-multichain-20250930155416

package/src/controllers/OnRampController.ts

@@ -19,6 +19,7 @@ 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';
@@ -142,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,
@@ -240,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'
@@ -261,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'
@@ -282,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'
@@ -313,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'
@@ -342,6 +348,7 @@ export const OnRampController = {
 
       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'
@@ -385,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'
@@ -503,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;
@@ -553,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'
@@ -617,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',
@@ -662,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/SendController.ts

@@ -9,6 +9,7 @@ import { RouterController } from './RouterController';
 import { ConnectionsController } from './ConnectionsController';
 import { SwapController } from './SwapController';
 import { ConstantsUtil as CoreConstantsUtil } from '../utils/ConstantsUtil';
+import { LogController } from './LogController';
 
 // -- Types --------------------------------------------- //
 export interface TxParams {
@@ -120,6 +121,7 @@ export const SendController = {
       RouterController.reset(isAuth ? 'Account' : 'AccountDefault');
       this.resetState();
     } catch (error: any) {
+      LogController.sendError(error, 'SendController.ts', 'sendToken');
       EventsController.sendEvent({
         type: 'track',
         event: 'SEND_ERROR',

package/src/controllers/SwapController.ts

@@ -14,6 +14,7 @@ import { BlockchainApiController } from './BlockchainApiController';
 import { OptionsController } from './OptionsController';
 import { SwapCalculationUtil } from '../utils/SwapCalculationUtil';
 import { SnackController } from './SnackController';
+import { LogController } from './LogController';
 import { RouterController } from './RouterController';
 import { CoreHelperUtil } from '../utils/CoreHelperUtil';
 import { TransactionsController } from './TransactionsController';
@@ -249,6 +250,7 @@ export const SwapController = {
         this.setSourceTokenAmount('1');
       }
     } catch (error) {
+      LogController.sendError(error, 'SwapController.ts', 'initializeState');
       SnackController.showError('Failed to initialize swap');
       RouterController.goBack();
     } finally {
@@ -491,6 +493,7 @@ export const SwapController = {
         this.setTransactionDetails();
       }
     } catch (error) {
+      LogController.sendError(error, 'SwapController.ts', 'getQuote');
       SnackController.showError('Failed to get swap quote');
     } finally {
       state.loadingQuote = false;
@@ -750,6 +753,11 @@ export const SwapController = {
       return transactionHash;
     } catch (err) {
       const error = err as TransactionError;
+      LogController.sendError(error, 'SwapController.ts', 'sendTransactionForSwap', {
+        sourceToken: this.state.sourceToken?.symbol,
+        toToken: this.state.toToken?.symbol,
+        amount: this.state.sourceTokenAmount
+      });
       state.transactionError = error?.shortMessage;
       state.loadingTransaction = false;
       SnackController.showError(error?.shortMessage ?? 'Transaction error');

package/src/controllers/TransactionsController.ts

@@ -5,6 +5,7 @@ import { EventsController } from './EventsController';
 import { SnackController } from './SnackController';
 import { BlockchainApiController } from './BlockchainApiController';
 import { ConnectionsController } from './ConnectionsController';
+import { LogController } from './LogController';
 
 // -- Types --------------------------------------------- //
 type TransactionByMonthMap = Record<string, Transaction[]>;
@@ -74,6 +75,7 @@ export const TransactionsController = {
       state.empty = nonSpamTransactions.length === 0;
       state.next = response?.next ? response.next : undefined;
     } catch (error) {
+      LogController.sendError(error, 'TransactionsController.ts', 'fetchTransactions');
       EventsController.sendEvent({
         type: 'track',
         event: 'ERROR_FETCH_TRANSACTIONS',

package/src/features/reown-authentication/ReownAuthentication.ts

@@ -16,6 +16,8 @@ import { ConnectionsController } from '../../controllers/ConnectionsController';
 import { CoreHelperUtil } from '../../utils/CoreHelperUtil';
 import { OptionsController } from '../../controllers/OptionsController';
 import { FetchUtil } from '../../utils/FetchUtil';
+import { ApiUtil } from '../../utils/ApiUtil';
+import { LogController } from '../../controllers/LogController';
 
 /**
  * This is the configuration for using SIWX with Reown Authentication service.
@@ -108,7 +110,9 @@ export class ReownAuthentication implements SIWXConfig {
       this.emit('sessionChanged', session);
 
       return [session];
-    } catch {
+    } catch (error) {
+      LogController.sendError(error, 'ReownAuthentication.ts', 'getSessions');
+
       return [];
     }
   }
@@ -299,13 +303,14 @@ export class ReownAuthentication implements SIWXConfig {
   }
 
   private getSDKProperties(): { projectId: string; st: string; sv: string; domain: string } {
-    const headers = ApiController._getApiHeaders();
+    const { projectId, st, sv } = ApiController._getApiParams();
+    const domain = ApiUtil.getOrigin();
 
     return {
-      projectId: headers['x-project-id'],
-      st: headers['x-sdk-type'],
-      sv: headers['x-sdk-version'],
-      domain: headers['origin']
+      projectId,
+      st,
+      sv,
+      domain
     };
   }
 

package/src/index.ts

@@ -16,6 +16,13 @@ export {
 
 export { SnackController, type SnackControllerState } from './controllers/SnackController';
 
+export {
+  LogController,
+  type LogControllerState,
+  type LogEntry,
+  type LogLevel
+} from './controllers/LogController';
+
 export { ApiController, type ApiControllerState } from './controllers/ApiController';
 
 export { AssetController, type AssetControllerState } from './controllers/AssetController';
@@ -54,6 +61,7 @@ export { CoreHelperUtil } from './utils/CoreHelperUtil';
 export { StorageUtil } from './utils/StorageUtil';
 export { EventUtil } from './utils/EventUtil';
 export { WalletUtil } from './utils/WalletUtil';
+export { LogUtils } from './utils/LogUtils';
 
 // -- Features ----------------------------------------------------------------
 export { ReownAuthentication } from './features/reown-authentication/ReownAuthentication';

package/src/utils/ApiUtil.ts

@@ -3,7 +3,7 @@ import { CoreHelperUtil } from './CoreHelperUtil';
 
 export const ApiUtil = {
   getOrigin() {
-    return CoreHelperUtil.getBundleId();
+    return CoreHelperUtil.getBundleId() ?? 'react-native-unknown-origin';
   },
 
   getReactNativeVersion() {

package/src/utils/CoreHelperUtil.ts

@@ -252,7 +252,7 @@ export const CoreHelperUtil = {
     });
   },
 
-  getBundleId() {
+  getBundleId(): string | undefined {
     if ((global as any)?.Application?.applicationId) {
       return (global as any)?.Application?.applicationId;
     }

package/src/utils/FetchUtil.ts

@@ -1,4 +1,5 @@
 import type { RequestCache } from '@reown/appkit-common-react-native';
+import { LogController } from '../controllers/LogController';
 
 // -- Types ----------------------------------------------------------------------
 interface Options {
@@ -71,9 +72,13 @@ export class FetchUtil {
     return this.processResponse<T>(response);
   }
 
-  public async fetchImage(path: string, headers?: Record<string, string>) {
+  public async fetchImage(
+    path: string,
+    headers?: Record<string, string>,
+    params?: Record<string, string>
+  ) {
     try {
-      const url = this.createUrl({ path }).toString();
+      const url = this.createUrl({ path, params }).toString();
       const response = await fetch(url, { headers });
       const blob = await response.blob();
       const reader = new FileReader();
@@ -130,14 +135,18 @@ export class FetchUtil {
       if (response.headers.get('content-type')?.includes('application/json')) {
         try {
           const errorData = await response.json();
+          LogController.sendError(errorData, 'FetchUtil.ts', 'processResponse');
 
           return Promise.reject(errorData);
         } catch (jsonError) {
+          LogController.sendError(jsonError, 'FetchUtil.ts', 'processResponse');
+
           return Promise.reject(`Code: ${response.status} - ${response.statusText}`);
         }
       }
 
       const errorText = await response.text();
+      LogController.sendError(errorText, 'FetchUtil.ts', 'processResponse');
 
       return Promise.reject(`Code: ${response.status} - ${response.statusText} - ${errorText}`);
     }

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
+};