@reown/appkit-core-react-native 0.0.0-chore-spring-effect-20250909214820 → 0.0.0-chore-examples-20251009175707

package/src/controllers/BlockchainApiController.ts

@@ -42,17 +42,24 @@ import { ConstantsUtil } from '../utils/ConstantsUtil';
 import { ApiUtil } from '../utils/ApiUtil';
 
 import { SnackController } from './SnackController';
+import { LogController } from './LogController';
 
 // -- Helpers ------------------------------------------- //
 const baseUrl = CoreHelperUtil.getBlockchainApiUrl();
 
-const getHeaders = () => {
-  const { sdkType, sdkVersion } = OptionsController.state;
+const getParams = () => {
+  const { projectId, sdkType, sdkVersion } = OptionsController.state;
 
+  return {
+    projectId,
+    st: sdkType,
+    sv: sdkVersion
+  };
+};
+
+const getHeaders = () => {
   return {
     'Content-Type': 'application/json',
-    'x-sdk-type': sdkType,
-    'x-sdk-version': sdkVersion,
     'User-Agent': ApiUtil.getUserAgent(),
     'origin': ApiUtil.getOrigin()
   };
@@ -89,6 +96,8 @@ export const BlockchainApiController = {
         await BlockchainApiController.getSupportedNetworks();
       }
     } catch (e) {
+      LogController.sendError(e, 'BlockchainApiController.ts', 'isNetworkSupported');
+
       return false;
     }
 
@@ -97,7 +106,8 @@ export const BlockchainApiController = {
 
   async getSupportedNetworks() {
     const supportedChains = await state.api.get<BlockchainApiControllerState['supportedChains']>({
-      path: 'v1/supported-chains'
+      path: 'v1/supported-chains',
+      params: getParams()
     });
 
     state.supportedChains = supportedChains!;
@@ -110,15 +120,13 @@ export const BlockchainApiController = {
 
     return state.api.get<BlockchainApiIdentityResponse>({
       path: `/v1/identity/${address}`,
-      params: {
-        projectId: OptionsController.state.projectId
-      },
-      headers: getHeaders()
+      headers: getHeaders(),
+      params: getParams()
     });
   },
 
   async fetchTransactions(params: BlockchainApiTransactionsRequest) {
-    const { account, projectId, cursor, signal, cache, chainId } = params;
+    const { account, cursor, signal, cache, chainId } = params;
     const isSupported = ConstantsUtil.ACTIVITY_SUPPORTED_CHAINS.includes(chainId);
 
     if (!isSupported) {
@@ -129,7 +137,7 @@ export const BlockchainApiController = {
       path: `/v1/account/${account}/history`,
       headers: getHeaders(),
       params: {
-        projectId,
+        ...getParams(),
         cursor,
         chainId
       },
@@ -150,19 +158,20 @@ export const BlockchainApiController = {
 
     const response = await state.api.post<BlockchainApiTokenPriceResponse>({
       path: '/v1/fungible/price',
+      headers: getHeaders(),
+      params: getParams(),
       body: {
         projectId,
         currency: 'usd',
         addresses
-      },
-      headers: getHeaders()
+      }
     });
 
     return response;
   },
 
   async fetchSwapAllowance(params: BlockchainApiSwapAllowanceRequest) {
-    const { projectId, tokenAddress, userAddress } = params;
+    const { tokenAddress, userAddress } = params;
     const [namespace, chain] = userAddress.split(':');
     const networkId: CaipNetworkId = `${namespace}:${chain}`;
     const isSupported = await BlockchainApiController.isNetworkSupported(networkId);
@@ -174,7 +183,7 @@ export const BlockchainApiController = {
     return state.api.get<BlockchainApiSwapAllowanceResponse>({
       path: `/v1/convert/allowance`,
       params: {
-        projectId,
+        ...getParams(),
         tokenAddress,
         userAddress
       },
@@ -183,7 +192,7 @@ export const BlockchainApiController = {
   },
 
   async fetchGasPrice(params: BlockchainApiGasPriceRequest) {
-    const { projectId, chainId } = params;
+    const { chainId } = params;
     const isSupported = await BlockchainApiController.isNetworkSupported(chainId);
 
     if (!isSupported) {
@@ -194,14 +203,14 @@ export const BlockchainApiController = {
       path: `/v1/convert/gas-price`,
       headers: getHeaders(),
       params: {
-        projectId,
+        ...getParams(),
         chainId
       }
     });
   },
 
   async fetchSwapQuote(params: BlockchainApiSwapQuoteRequest) {
-    const { projectId, amount, userAddress, from, to, gasPrice } = params;
+    const { amount, userAddress, from, to, gasPrice } = params;
     const [namespace, chain] = userAddress.split(':');
     const networkId: CaipNetworkId = `${namespace}:${chain}`;
     const isSupported = await BlockchainApiController.isNetworkSupported(networkId);
@@ -214,7 +223,7 @@ export const BlockchainApiController = {
       path: `/v1/convert/quotes`,
       headers: getHeaders(),
       params: {
-        projectId,
+        ...getParams(),
         amount,
         userAddress,
         from,
@@ -225,7 +234,7 @@ export const BlockchainApiController = {
   },
 
   async fetchSwapTokens(params: BlockchainApiSwapTokensRequest) {
-    const { projectId, chainId } = params;
+    const { chainId } = params;
     const isSupported = await BlockchainApiController.isNetworkSupported(chainId);
 
     if (!isSupported) {
@@ -236,7 +245,7 @@ export const BlockchainApiController = {
       path: `/v1/convert/tokens`,
       headers: getHeaders(),
       params: {
-        projectId,
+        ...getParams(),
         chainId
       }
     });
@@ -255,6 +264,7 @@ export const BlockchainApiController = {
     return state.api.post<BlockchainApiGenerateSwapCalldataResponse>({
       path: '/v1/convert/build-transaction',
       headers: getHeaders(),
+      params: getParams(),
       body: {
         amount,
         eip155: {
@@ -269,7 +279,7 @@ export const BlockchainApiController = {
   },
 
   async generateApproveCalldata(params: BlockchainApiGenerateApproveCalldataRequest) {
-    const { from, projectId, to, userAddress } = params;
+    const { from, to, userAddress } = params;
     const [namespace, chain] = userAddress.split(':');
     const networkId: CaipNetworkId = `${namespace}:${chain}`;
     const isSupported = await BlockchainApiController.isNetworkSupported(networkId);
@@ -282,7 +292,7 @@ export const BlockchainApiController = {
       path: `/v1/convert/build-approve`,
       headers: getHeaders(),
       params: {
-        projectId,
+        ...getParams(),
         userAddress,
         from,
         to
@@ -309,8 +319,8 @@ export const BlockchainApiController = {
       path: `/v1/account/${plainAddress}/balance`,
       headers: getHeaders(),
       params: {
+        ...getParams(),
         currency: 'usd',
-        projectId: OptionsController.state.projectId,
         chainId: `${namespace}:${chain}`,
         forceUpdate: forceUpdate?.join(',')
       }
@@ -322,7 +332,7 @@ export const BlockchainApiController = {
       path: `/v1/profile/account/${name}`,
       headers: getHeaders(),
       params: {
-        projectId: OptionsController.state.projectId,
+        ...getParams(),
         apiVersion: '2'
       }
     });
@@ -332,9 +342,7 @@ export const BlockchainApiController = {
     return await state.api.get<OnRampServiceProvider[]>({
       path: '/v1/onramp/providers',
       headers: getHeaders(),
-      params: {
-        projectId: OptionsController.state.projectId
-      }
+      params: getParams()
     });
   },
 
@@ -367,7 +375,7 @@ export const BlockchainApiController = {
       path: '/v1/onramp/providers/properties',
       headers: getHeaders(),
       params: {
-        projectId: OptionsController.state.projectId,
+        ...getParams(),
         type,
         excludeProviders: EXCLUDED_ONRAMP_PROVIDERS.join(','),
         ...params
@@ -379,6 +387,7 @@ export const BlockchainApiController = {
     return await state.api.post<OnRampQuote[]>({
       path: '/v1/onramp/multi/quotes',
       headers: getHeaders(),
+      params: getParams(),
       body: {
         projectId: OptionsController.state.projectId,
         ...body
@@ -391,6 +400,7 @@ export const BlockchainApiController = {
     return await state.api.post<BlockchainApiOnRampWidgetResponse>({
       path: '/v1/onramp/widget',
       headers: getHeaders(),
+      params: getParams(),
       body: {
         projectId: OptionsController.state.projectId,
         sessionData: {

package/src/controllers/ConnectionsController.ts

@@ -13,11 +13,13 @@ import {
   type AccountType,
   type Connection,
   SolanaBaseAdapter,
+  BitcoinBaseAdapter,
   type Identity
 } from '@reown/appkit-common-react-native';
 import { StorageUtil } from '../utils/StorageUtil';
 import { BlockchainApiController } from './BlockchainApiController';
 import { SnackController } from './SnackController';
+import { LogController } from './LogController';
 import { CoreHelperUtil } from '../utils/CoreHelperUtil';
 
 // -- Types --------------------------------------------- //
@@ -279,8 +281,11 @@ export const ConnectionsController = {
     const existingBalances = connection.balances.get(address) || [];
     // Check if this token already exists by contract address or symbol
     const existingIndex = existingBalances.findIndex(existingBalance => {
-      if (balance.address) {
-        return existingBalance.address === balance.address;
+      if (balance.address && existingBalance.address) {
+        return (
+          CoreHelperUtil.getPlainAddress(existingBalance.address) ===
+          CoreHelperUtil.getPlainAddress(balance.address)
+        );
       }
 
       return existingBalance.symbol === balance.symbol;
@@ -386,6 +391,15 @@ export const ConnectionsController = {
     return getActiveAddress(newConnection);
   },
 
+  getActiveNetworkId(namespace?: ChainNamespace) {
+    const connection = namespace
+      ? baseState.connections.get(namespace)
+      : getActiveConnection(baseState);
+    if (!connection) return undefined;
+
+    return connection.caipNetwork;
+  },
+
   async disconnect(namespace: ChainNamespace, isInternal = true) {
     const connection = baseState.connections.get(namespace);
     if (!connection) return;
@@ -449,7 +463,13 @@ export const ConnectionsController = {
 
     const adapter = baseState.connections.get(baseState.activeNamespace)?.adapter;
 
-    if (adapter instanceof EVMAdapter && plainAddress && chainId) {
+    if (
+      (adapter instanceof EVMAdapter ||
+        adapter instanceof SolanaBaseAdapter ||
+        adapter instanceof BitcoinBaseAdapter) &&
+      plainAddress &&
+      chainId
+    ) {
       return adapter.signMessage(plainAddress, message, chainId);
     }
 
@@ -521,6 +541,10 @@ export const ConnectionsController = {
         });
       });
     } catch (error) {
+      LogController.sendError(error, 'ConnectionsController.ts', 'fetchBalance', {
+        address,
+        namespace
+      });
       SnackController.showError('Failed to get account balance');
     }
   },

package/src/controllers/EnsController.ts

@@ -2,6 +2,7 @@ import { subscribeKey as subKey } from 'valtio/utils';
 import { proxy, subscribe as sub } from 'valtio';
 import { BlockchainApiController } from './BlockchainApiController';
 import type { BlockchainApiEnsError } from '@reown/appkit-common-react-native';
+import { LogController } from './LogController';
 
 // -- Types --------------------------------------------- //
 
@@ -32,6 +33,7 @@ export const EnsController = {
     try {
       return await BlockchainApiController.lookupEnsName(name);
     } catch (e) {
+      LogController.sendError(e, 'EnsController.ts', 'resolveName');
       const error = e as BlockchainApiEnsError;
       throw new Error(error?.reasons?.[0]?.description || 'Error resolving name');
     }

package/src/controllers/EventsController.ts

@@ -3,17 +3,25 @@ import { ApiController } from './ApiController';
 import { OptionsController } from './OptionsController';
 import { CoreHelperUtil } from '../utils/CoreHelperUtil';
 import { FetchUtil } from '../utils/FetchUtil';
-import type { Event, EventName } from '@reown/appkit-common-react-native';
+import type {
+  Event,
+  EventName,
+  WalletImpressionItem,
+  WcWallet
+} from '@reown/appkit-common-react-native';
 
 // -- Helpers ------------------------------------------- //
 const baseUrl = CoreHelperUtil.getAnalyticsUrl();
 const api = new FetchUtil({ baseUrl });
 const excluded = ['MODAL_CREATED'];
+const IMPRESSION_TIMEOUT = 3000;
 
 // -- Types --------------------------------------------- //
 export interface EventsControllerState {
   timestamp: number;
   data: Event;
+  pendingWalletImpressions: WalletImpressionItem[];
+  pendingImpressionTimeout?: NodeJS.Timeout;
 }
 
 // -- State --------------------------------------------- //
@@ -22,7 +30,9 @@ const state = proxy<EventsControllerState>({
   data: {
     type: 'track',
     event: 'MODAL_CREATED' // just for init purposes
-  }
+  },
+  pendingWalletImpressions: [],
+  pendingImpressionTimeout: undefined
 });
 
 // -- Controller ---------------------------------------- //
@@ -41,6 +51,53 @@ export const EventsController = {
     });
   },
 
+  trackWalletImpression(props: {
+    wallet: WcWallet;
+    view: 'Connect' | 'AllWallets';
+    displayIndex: number;
+    query?: string;
+    installed?: boolean;
+  }) {
+    state.pendingWalletImpressions.push({
+      name: props.wallet.name ?? 'Unknown',
+      walletRank: props.wallet.order,
+      explorerId: props.wallet.id,
+      certified: props.wallet.badge_type === 'certified',
+      displayIndex: props.displayIndex,
+      view: props.view,
+      query: props.query,
+      installed: props.installed
+    });
+
+    if (state.pendingImpressionTimeout) {
+      clearTimeout(state.pendingImpressionTimeout);
+    }
+
+    state.pendingImpressionTimeout = setTimeout(() => {
+      EventsController.sendWalletImpressions();
+    }, IMPRESSION_TIMEOUT);
+  },
+
+  sendWalletImpressions() {
+    if (state.pendingImpressionTimeout) {
+      clearTimeout(state.pendingImpressionTimeout);
+      state.pendingImpressionTimeout = undefined;
+    }
+
+    const impressions = state.pendingWalletImpressions;
+
+    if (impressions.length === 0) {
+      return;
+    }
+
+    state.pendingWalletImpressions = [];
+    EventsController.sendEvent({
+      type: 'track',
+      event: 'WALLET_IMPRESSION',
+      items: impressions
+    });
+  },
+
   async _sendAnalyticsEvent(data: EventsControllerState['data'], timestamp: number) {
     if (excluded.includes(data.event)) {
       return;
@@ -50,6 +107,7 @@ export const EventsController = {
       await api.post({
         path: '/e',
         headers: ApiController._getApiHeaders(),
+        params: ApiController._getApiParams(),
         body: {
           eventId: CoreHelperUtil.getUUID(),
           bundleId: CoreHelperUtil.getBundleId(),
@@ -71,5 +129,18 @@ export const EventsController = {
     if (OptionsController.state.enableAnalytics) {
       EventsController._sendAnalyticsEvent(data, timestamp);
     }
+  },
+
+  resetState() {
+    if (state.pendingImpressionTimeout) {
+      clearTimeout(state.pendingImpressionTimeout);
+      state.pendingImpressionTimeout = undefined;
+    }
+    state.pendingWalletImpressions = [];
+    state.data = {
+      type: 'track',
+      event: 'MODAL_CREATED'
+    };
+    state.timestamp = Date.now();
   }
 };

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