@reown/appkit-core-react-native 2.0.0 → 2.0.1

package/src/utils/CoreHelperUtil.ts

@@ -2,16 +2,24 @@
 
 import { Linking, Platform } from 'react-native';
 import {
+  BlockchainAdapter,
   ConstantsUtil as CommonConstants,
+  type AdapterType,
   type Balance,
   type CaipAddress,
-  type CaipNetwork
+  type CaipNetwork,
+  type ChainNamespace,
+  type SocialProvider,
+  type LinkingRecord,
+  type DataWallet,
+  type SdkVersion
 } from '@reown/appkit-common-react-native';
 
 import * as ct from 'countries-and-timezones';
 
 import { ConstantsUtil } from './ConstantsUtil';
-import type { DataWallet, LinkingRecord } from './TypeUtil';
+import { OptionsController } from '../controllers/OptionsController';
+
 // -- Helpers -----------------------------------------------------------------
 async function isAppInstalledIos(deepLink?: string): Promise<boolean> {
   try {
@@ -45,6 +53,20 @@ export const CoreHelperUtil = {
     return Date.now() - lastRetry >= ConstantsUtil.ONE_SEC_MS;
   },
 
+  isCaipAddress(address?: unknown): address is CaipAddress {
+    if (typeof address !== 'string') {
+      return false;
+    }
+
+    const sections = address.split(':');
+    const namespace = sections[0];
+
+    return (
+      sections.filter(Boolean).length === 3 &&
+      (namespace as string) in CommonConstants.CHAIN_NAME_MAP
+    );
+  },
+
   getPairingExpiry() {
     return Date.now() + ConstantsUtil.FOUR_MINUTES_MS;
   },
@@ -53,8 +75,12 @@ export const CoreHelperUtil = {
     return caipAddress?.split(':')[1];
   },
 
-  getPlainAddress(caipAddress: CaipAddress | undefined) {
-    return caipAddress?.split(':')[2];
+  getPlainAddress(address: CaipAddress | string | undefined) {
+    if (this.isCaipAddress(address)) {
+      return address?.split(':')[2];
+    }
+
+    return address;
   },
 
   async wait(milliseconds: number) {
@@ -102,7 +128,7 @@ export const CoreHelperUtil = {
     };
   },
 
-  formatUniversalUrl(appUrl: string, wcUri: string): LinkingRecord {
+  formatUniversalUrl(appUrl: string, wcUri: string, provider?: SocialProvider): LinkingRecord {
     if (CoreHelperUtil.isLinkModeURL(wcUri)) {
       return {
         redirect: wcUri,
@@ -120,7 +146,9 @@ export const CoreHelperUtil = {
     const encodedWcUrl = encodeURIComponent(wcUri);
 
     return {
-      redirect: `${safeAppUrl}wc?uri=${encodedWcUrl}`,
+      redirect: provider
+        ? `${safeAppUrl}wc?uri=${encodedWcUrl}&provider=${provider}`
+        : `${safeAppUrl}wc?uri=${encodedWcUrl}`,
       href: safeAppUrl
     };
   },
@@ -149,8 +177,8 @@ export const CoreHelperUtil = {
     return formattedBalance ? `${formattedBalance} ${symbol}` : `0.000 ${symbol || ''}`;
   },
 
-  isAddress(address: string, chain = 'eip155'): boolean {
-    switch (chain) {
+  isAddress(address: string, namespace: ChainNamespace = 'eip155'): boolean {
+    switch (namespace) {
       case 'eip155':
         if (!/^(?:0x)?[0-9a-f]{40}$/iu.test(address)) {
           return false;
@@ -191,7 +219,7 @@ export const CoreHelperUtil = {
       const { timeZone } = new Intl.DateTimeFormat().resolvedOptions();
       const country = ct.getCountryForTimezone(timeZone);
 
-      return country ? country.id : 'US'; // 'id' is the ISO country code (e.g., "GB" for United Kingdom)
+      return country ? country.id : 'US'; // 'id' is the ISO country code (e.g., "US" for United States)
     } catch (error) {
       return 'US';
     }
@@ -224,7 +252,7 @@ export const CoreHelperUtil = {
     });
   },
 
-  getBundleId() {
+  getBundleId(): string | undefined {
     if ((global as any)?.Application?.applicationId) {
       return (global as any)?.Application?.applicationId;
     }
@@ -282,7 +310,7 @@ export const CoreHelperUtil = {
 
     let sum = 0;
     for (const item of array) {
-      sum += item.value ?? 0;
+      sum += item?.value ?? 0;
     }
 
     const roundedNumber = sum.toFixed(2);
@@ -322,5 +350,28 @@ export const CoreHelperUtil = {
         func(...args);
       }, wait);
     };
+  },
+
+  generateSdkVersion(adapters: BlockchainAdapter[], version: string): SdkVersion {
+    const hasNoAdapters = adapters.length === 0;
+    const universalType: AdapterType = 'universal';
+
+    const adapterNames = hasNoAdapters
+      ? universalType
+      : adapters
+          .sort((a, b) => a.adapterType.localeCompare(b.adapterType))
+          .map(adapter => adapter.adapterType)
+          .join(',');
+
+    return `react-native-${adapterNames}-${version}`;
+  },
+
+  getRequestedCaipNetworkIds() {
+    const chains = OptionsController.state.requestedNetworks;
+    if (!chains) return [];
+
+    const requestedIds = chains.map(caipNetwork => caipNetwork.caipNetworkId);
+
+    return requestedIds;
   }
 };

package/src/utils/EventUtil.ts

@@ -1,4 +1,4 @@
-import type { Platform, WcWallet } from './TypeUtil';
+import type { Platform, WcWallet } from '@reown/appkit-common-react-native';
 
 export const EventUtil = {
   getWalletPlatform(wallet: WcWallet, installed?: boolean): Platform | undefined {

package/src/utils/FetchUtil.ts

@@ -1,4 +1,5 @@
-import type { RequestCache } from './TypeUtil';
+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();
@@ -87,30 +92,61 @@ export class FetchUtil {
     }
   }
 
-  private createUrl({ path, params }: RequestArguments) {
-    const url = new URL(path, this.baseUrl);
-    if (params) {
-      Object.entries(params).forEach(([key, value]) => {
-        if (value) {
-          url.searchParams.append(key, value);
-        }
-      });
+  public createUrl({ path, params }: RequestArguments) {
+    let fullUrl: string;
+
+    const isAbsoluteUrl = path.startsWith('http://') || path.startsWith('https://');
+
+    if (isAbsoluteUrl) {
+      fullUrl = path;
+    } else {
+      const baseUrl = this.baseUrl.endsWith('/') ? this.baseUrl : `${this.baseUrl}/`;
+      const pathUrl = path.startsWith('/') ? path.substring(1) : path;
+      fullUrl = `${baseUrl}${pathUrl}`;
     }
 
+    const allParams: Record<string, string | undefined> = { ...params };
     if (this.clientId) {
-      url.searchParams.append('clientId', this.clientId);
+      allParams['clientId'] = this.clientId;
+    }
+
+    const queryParams: string[] = [];
+    for (const key in allParams) {
+      const value = allParams[key];
+      if (value !== undefined && value !== null && value !== '') {
+        queryParams.push(`${encodeURIComponent(key)}=${encodeURIComponent(value)}`);
+      }
     }
 
-    return url.toString();
+    if (queryParams.length > 0) {
+      const queryString = queryParams.join('&');
+      if (fullUrl.includes('?')) {
+        fullUrl = `${fullUrl}&${queryString}`;
+      } else {
+        fullUrl = `${fullUrl}?${queryString}`;
+      }
+    }
+
+    return fullUrl;
   }
 
   private async processResponse<T>(response: Response) {
     if (!response.ok) {
       if (response.headers.get('content-type')?.includes('application/json')) {
-        return Promise.reject((await response.json()) as T);
+        try {
+          const errorData = await response.json();
+          LogController.sendError(JSON.stringify(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
+};