@reown/appkit-core-react-native 0.0.0-accounts-canary.1-20251023174733

package/src/utils/ConstantsUtil.ts

@@ -0,0 +1,303 @@
+import type { ChainNamespace, Features } from '@reown/appkit-common-react-native';
+
+const defaultFeatures: Features = {
+  swaps: true,
+  onramp: true,
+  socials: ['email', 'google', 'x', 'discord', 'apple', 'facebook', 'github', 'farcaster'],
+  showWallets: true
+};
+
+export const OnRampErrorType = {
+  AMOUNT_TOO_LOW: 'INVALID_AMOUNT_TOO_LOW',
+  AMOUNT_TOO_HIGH: 'INVALID_AMOUNT_TOO_HIGH',
+  INVALID_AMOUNT: 'INVALID_AMOUNT',
+  INCOMPATIBLE_REQUEST: 'INCOMPATIBLE_REQUEST',
+  BAD_REQUEST: 'BAD_REQUEST',
+  NO_VALID_QUOTES: 'NO_VALID_QUOTES',
+  FAILED_TO_LOAD: 'FAILED_TO_LOAD',
+  FAILED_TO_LOAD_COUNTRIES: 'FAILED_TO_LOAD_COUNTRIES',
+  FAILED_TO_LOAD_PROVIDERS: 'FAILED_TO_LOAD_PROVIDERS',
+  FAILED_TO_LOAD_METHODS: 'FAILED_TO_LOAD_METHODS',
+  FAILED_TO_LOAD_CURRENCIES: 'FAILED_TO_LOAD_CURRENCIES',
+  FAILED_TO_LOAD_LIMITS: 'FAILED_TO_LOAD_LIMITS',
+  UNKNOWN: 'UNKNOWN_ERROR'
+} as const;
+
+export const ConstantsUtil = {
+  FOUR_MINUTES_MS: 240000,
+
+  TEN_SEC_MS: 10000,
+
+  ONE_SEC_MS: 1000,
+
+  EMAIL_REGEX: /^[a-zA-Z0-9.!#$%&'*+/=?^_`{|}~-]+@[a-zA-Z0-9-]+(?:\.[a-zA-Z0-9-]+)+$/,
+
+  LINKING_ERROR: 'LINKING_ERROR',
+
+  NATIVE_TOKEN_ADDRESS: {
+    eip155: '0xeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee',
+    solana: 'So11111111111111111111111111111111111111111',
+    bip122: '0x'
+  } as const satisfies Record<ChainNamespace, string>,
+
+  ONRAMP_ERROR_TYPES: OnRampErrorType,
+
+  SWAP_SUGGESTED_TOKENS: [
+    'ETH',
+    'UNI',
+    '1INCH',
+    'AAVE',
+    'SOL',
+    'ADA',
+    'AVAX',
+    'DOT',
+    'LINK',
+    'NITRO',
+    'GAIA',
+    'MILK',
+    'TRX',
+    'NEAR',
+    'GNO',
+    'WBTC',
+    'DAI',
+    'WETH',
+    'USDC',
+    'USDT',
+    'ARB',
+    'BAL',
+    'BICO',
+    'CRV',
+    'ENS',
+    'POL',
+    'OP'
+  ],
+
+  SWAP_POPULAR_TOKENS: [
+    'ETH',
+    'UNI',
+    '1INCH',
+    'AAVE',
+    'SOL',
+    'ADA',
+    'AVAX',
+    'DOT',
+    'LINK',
+    'NITRO',
+    'GAIA',
+    'MILK',
+    'TRX',
+    'NEAR',
+    'GNO',
+    'WBTC',
+    'DAI',
+    'WETH',
+    'USDC',
+    'USDT',
+    'ARB',
+    'BAL',
+    'BICO',
+    'CRV',
+    'ENS',
+    'POL',
+    'OP',
+    'METAL',
+    'DAI',
+    'CHAMP',
+    'WOLF',
+    'SALE',
+    'BAL',
+    'BUSD',
+    'MUST',
+    'BTCpx',
+    'ROUTE',
+    'HEX',
+    'WELT',
+    'amDAI',
+    'VSQ',
+    'VISION',
+    'AURUM',
+    'pSP',
+    'SNX',
+    'VC',
+    'LINK',
+    'CHP',
+    'amUSDT',
+    'SPHERE',
+    'FOX',
+    'GIDDY',
+    'GFC',
+    'OMEN',
+    'OX_OLD',
+    'DE',
+    'WNT'
+  ],
+
+  //TODO: replace with supported chains from backend
+  ACTIVITY_SUPPORTED_CHAINS: [
+    // Arbitrum
+    'eip155:42161',
+    // BNB Chain
+    'eip155:56',
+    // Ethereum
+    'eip155:1',
+    // Blast
+    'eip155:81457',
+    // Ape Chain
+    'eip155:99999',
+    // Avalanche
+    'eip155:43114',
+    // Abstract
+    'eip155:900',
+    // opBNB
+    'eip155:204',
+    // Astar zkEVM
+    'eip155:3776',
+    // ZKsync Era
+    'eip155:324',
+    // Berachain
+    'eip155:80085',
+    // BOB
+    'eip155:60808',
+    // Cyber
+    'eip155:7560',
+    // Degen Chain
+    'eip155:666666666',
+    // Fraxtal
+    'eip155:252',
+    // Gravity Alpha
+    'eip155:10003',
+    // Ink
+    'eip155:999',
+    // Lens
+    'eip155:1348',
+    // Lisk
+    'eip155:113',
+    // Mode
+    'eip155:34443',
+    // Base
+    'eip155:8453',
+    // Mantle
+    'eip155:5000',
+    // Optimism
+    'eip155:10',
+    // Polygon
+    'eip155:137',
+    // Celo
+    'eip155:42220',
+    // Manta Pacific
+    'eip155:169',
+    // Gnosis Chain
+    'eip155:100',
+    // Fantom
+    'eip155:250',
+    // Ronin
+    'eip155:2020',
+    // Linea
+    'eip155:59144',
+    // Metis Andromeda
+    'eip155:1088',
+    // Aurora
+    'eip155:1313161554',
+    // XDC
+    'eip155:50',
+    // Cronos zkEVM
+    'eip155:1030',
+    // Polygon zkEVM
+    'eip155:1101',
+    // Polynomial
+    'eip155:80001',
+    // Rari
+    'eip155:1380012617',
+    // Redstone
+    'eip155:690',
+    // Scroll
+    'eip155:534352',
+    // Sei
+    'eip155:1329',
+    // Soneium
+    'eip155:1499',
+    // Sonic
+    'eip155:7007',
+    // Taiko
+    'eip155:167000',
+    // Viction
+    'eip155:88',
+    // Unichain
+    'eip155:12345',
+    // Wonder
+    'eip155:8787',
+    // X Layer
+    'eip155:196',
+    // World Chain
+    'eip155:2008',
+    // ZERϴ
+    'eip155:77777',
+    // ZkLink Nova
+    'eip155:810180',
+    // re.al
+    'eip155:666'
+  ],
+
+  SWAP_SUPPORTED_NETWORKS: [
+    // Ethereum'
+    'eip155:1',
+    // Arbitrum One'
+    'eip155:42161',
+    // Optimism'
+    'eip155:10',
+    // ZKSync Era'
+    'eip155:324',
+    // Base'
+    'eip155:8453',
+    // BNB Smart Chain'
+    'eip155:56',
+    // Polygon'
+    'eip155:137',
+    // Gnosis'
+    'eip155:100',
+    // Avalanche'
+    'eip155:43114',
+    // Fantom'
+    'eip155:250',
+    // Klaytn'
+    'eip155:8217',
+    // Aurora
+    'eip155:1313161554'
+  ],
+
+  SEND_SUPPORTED_NAMESPACES: ['eip155', 'solana'],
+
+  ONRAMP_SUPPORTED_NAMESPACES: ['eip155', 'solana', 'bip122'],
+
+  CONVERT_SLIPPAGE_TOLERANCE: 1,
+
+  DEFAULT_FEATURES: defaultFeatures,
+
+  NETWORK_DEFAULT_CURRENCIES: {
+    'eip155:1': 'ETH', // Ethereum Mainnet
+    'eip155:56': 'BNB', // Binance Smart Chain
+    'eip155:137': 'POL', // Polygon
+    'eip155:42161': 'ETH_ARBITRUM', // Arbitrum One
+    'eip155:43114': 'AVAX', // Avalanche C-Chain
+    'eip155:10': 'ETH_OPTIMISM', // Optimism
+    'eip155:250': 'FTM', // Fantom
+    'eip155:100': 'xDAI', // Gnosis Chain (formerly xDai)
+    'eip155:8453': 'ETH_BASE', // Base
+    'eip155:1284': 'GLMR', // Moonbeam
+    'eip155:1285': 'MOVR', // Moonriver
+    'eip155:25': 'CRO', // Cronos
+    'eip155:42220': 'CELO', // Celo
+    'eip155:8217': 'KLAY', // Klaytn
+    'eip155:1313161554': 'AURORA_ETH', // Aurora
+    'eip155:40': 'TLOS', // Telos EVM
+    'eip155:1088': 'METIS', // Metis Andromeda
+    'eip155:2222': 'KAVA', // Kava EVM
+    'eip155:7777777': 'ZETA', // ZetaChain
+    'eip155:7700': 'CANTO', // Canto
+    'eip155:59144': 'ETH_LINEA', // Linea
+    'eip155:1101': 'ETH_POLYGONZKEVM', // Polygon zkEVM
+    'eip155:196': 'XIN', // Mixin
+    'solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp': 'SOL',
+    'bip122:000000000019d6689c085ae165831e93': 'BTC'
+  }
+};

package/src/utils/CoreHelperUtil.ts

@@ -0,0 +1,377 @@
+/* eslint-disable no-bitwise */
+
+import { Linking, Platform } from 'react-native';
+import {
+  BlockchainAdapter,
+  ConstantsUtil as CommonConstants,
+  type AdapterType,
+  type Balance,
+  type CaipAddress,
+  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 { OptionsController } from '../controllers/OptionsController';
+
+// -- Helpers -----------------------------------------------------------------
+async function isAppInstalledIos(deepLink?: string): Promise<boolean> {
+  try {
+    return deepLink ? Linking.canOpenURL(deepLink) : Promise.resolve(false);
+  } catch (error) {
+    return Promise.resolve(false);
+  }
+}
+
+async function isAppInstalledAndroid(packageName?: string): Promise<boolean> {
+  try {
+    //@ts-ignore
+    if (!packageName || typeof global?.Application?.isAppInstalled !== 'function') {
+      return Promise.resolve(false);
+    }
+
+    //@ts-ignore
+    return global?.Application?.isAppInstalled(packageName);
+  } catch (error) {
+    return Promise.resolve(false);
+  }
+}
+
+// -- Utility --------------------------------------------------------------------
+export const CoreHelperUtil = {
+  isPairingExpired(expiry?: number) {
+    return expiry ? expiry - Date.now() <= ConstantsUtil.TEN_SEC_MS : true;
+  },
+
+  isAllowedRetry(lastRetry: number) {
+    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;
+  },
+
+  getNetworkId(caipAddress: CaipAddress | undefined) {
+    return caipAddress?.split(':')[1];
+  },
+
+  getPlainAddress(address: CaipAddress | string | undefined) {
+    if (this.isCaipAddress(address)) {
+      return address?.split(':')[2];
+    }
+
+    return address;
+  },
+
+  async wait(milliseconds: number) {
+    return new Promise(resolve => {
+      setTimeout(resolve, milliseconds);
+    });
+  },
+
+  isHttpUrl(url: string) {
+    return url.startsWith('http://') || url.startsWith('https://');
+  },
+
+  isLinkModeURL(url?: string) {
+    if (!url) {
+      return false;
+    }
+
+    return CoreHelperUtil.isHttpUrl(url) && url.includes('wc_ev');
+  },
+
+  formatNativeUrl(appUrl: string, wcUri: string): LinkingRecord {
+    if (CoreHelperUtil.isLinkModeURL(wcUri)) {
+      return {
+        redirect: wcUri,
+        href: wcUri
+      };
+    }
+
+    if (CoreHelperUtil.isHttpUrl(appUrl)) {
+      return this.formatUniversalUrl(appUrl, wcUri);
+    }
+    let safeAppUrl = appUrl;
+    if (!safeAppUrl.includes('://')) {
+      safeAppUrl = appUrl.replaceAll('/', '').replaceAll(':', '');
+      safeAppUrl = `${safeAppUrl}://`;
+    }
+    if (!safeAppUrl.endsWith('/')) {
+      safeAppUrl = `${safeAppUrl}/`;
+    }
+    const encodedWcUrl = encodeURIComponent(wcUri);
+
+    return {
+      redirect: `${safeAppUrl}wc?uri=${encodedWcUrl}`,
+      href: safeAppUrl
+    };
+  },
+
+  formatUniversalUrl(appUrl: string, wcUri: string, provider?: SocialProvider): LinkingRecord {
+    if (CoreHelperUtil.isLinkModeURL(wcUri)) {
+      return {
+        redirect: wcUri,
+        href: wcUri
+      };
+    }
+
+    if (!CoreHelperUtil.isHttpUrl(appUrl)) {
+      return this.formatNativeUrl(appUrl, wcUri);
+    }
+    let safeAppUrl = appUrl;
+    if (!safeAppUrl.endsWith('/')) {
+      safeAppUrl = `${safeAppUrl}/`;
+    }
+    const encodedWcUrl = encodeURIComponent(wcUri);
+
+    return {
+      redirect: provider
+        ? `${safeAppUrl}wc?uri=${encodedWcUrl}&provider=${provider}`
+        : `${safeAppUrl}wc?uri=${encodedWcUrl}`,
+      href: safeAppUrl
+    };
+  },
+
+  async openLink(url: string) {
+    try {
+      await Linking.openURL(url);
+    } catch (error) {
+      throw new Error(ConstantsUtil.LINKING_ERROR);
+    }
+  },
+
+  formatBalance(balance: string | undefined, symbol: string | undefined, decimals = 3) {
+    let formattedBalance;
+
+    if (balance === '0') {
+      formattedBalance = '0.000';
+    } else if (typeof balance === 'string') {
+      const number = Number(balance);
+      if (number) {
+        const regex = new RegExp(`^-?\\d+(?:\\.\\d{0,${decimals}})?`, 'u');
+        formattedBalance = number.toString().match(regex)?.[0];
+      }
+    }
+
+    return formattedBalance ? `${formattedBalance} ${symbol}` : `0.000 ${symbol || ''}`;
+  },
+
+  isAddress(address: string, namespace: ChainNamespace = 'eip155'): boolean {
+    switch (namespace) {
+      case 'eip155':
+        if (!/^(?:0x)?[0-9a-f]{40}$/iu.test(address)) {
+          return false;
+        } else if (
+          /^(?:0x)?[0-9a-f]{40}$/iu.test(address) ||
+          /^(?:0x)?[0-9A-F]{40}$/iu.test(address)
+        ) {
+          return true;
+        }
+
+        return false;
+      case 'solana':
+        return /[1-9A-HJ-NP-Za-km-z]{32,44}$/iu.test(address);
+
+      default:
+        return false;
+    }
+  },
+
+  getApiUrl() {
+    return CommonConstants.API_URL;
+  },
+
+  getBlockchainApiUrl() {
+    return CommonConstants.BLOCKCHAIN_API_RPC_URL;
+  },
+
+  getBlockchainStagingApiUrl() {
+    return CommonConstants.BLOCKCHAIN_API_RPC_URL_STAGING;
+  },
+
+  getAnalyticsUrl() {
+    return CommonConstants.PULSE_API_URL;
+  },
+
+  getCountryFromTimezone() {
+    try {
+      const { timeZone } = new Intl.DateTimeFormat().resolvedOptions();
+      const country = ct.getCountryForTimezone(timeZone);
+
+      return country ? country.id : 'US'; // 'id' is the ISO country code (e.g., "US" for United States)
+    } catch (error) {
+      return 'US';
+    }
+  },
+
+  getUUID() {
+    if ((global as any)?.crypto.getRandomValues) {
+      const buffer = new Uint8Array(16);
+      (global as any)?.crypto.getRandomValues(buffer);
+
+      // Set the version (4) and variant (8, 9, A, or B) bits
+      buffer[6] = (buffer[6] ?? 0 & 0x0f) | 0x40;
+      buffer[8] = (buffer[8] ?? 0 & 0x3f) | 0x80;
+
+      // Convert the buffer to a hexadecimal string
+      const hexString = Array.from(buffer, byte => byte.toString(16).padStart(2, '0')).join('');
+      const formatted = `${hexString.slice(0, 8)}-${hexString.slice(8, 12)}-${hexString.slice(
+        12,
+        16
+      )}-${hexString.slice(16, 20)}-${hexString.slice(20)}`;
+
+      return formatted;
+    }
+
+    return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/gu, c => {
+      const r = (Math.random() * 16) | 0;
+      const v = c === 'x' ? r : (r & 0x3) | 0x8;
+
+      return v.toString(16);
+    });
+  },
+
+  getBundleId(): string | undefined {
+    if ((global as any)?.Application?.applicationId) {
+      return (global as any)?.Application?.applicationId;
+    }
+
+    return undefined;
+  },
+
+  parseError(error: any): string {
+    if (typeof error === 'string') {
+      return error;
+    } else if (typeof error?.issues?.[0]?.message === 'string') {
+      return error.issues[0].message;
+    } else if (error instanceof Error) {
+      return error.message;
+    }
+
+    return 'Unknown error';
+  },
+
+  async checkInstalled(wallet: DataWallet): Promise<boolean> {
+    let isInstalled = false;
+    const scheme = wallet.ios_schema;
+    const appId = wallet.android_app_id;
+    try {
+      isInstalled = await Platform.select({
+        ios: isAppInstalledIos(scheme),
+        android: isAppInstalledAndroid(appId),
+        default: Promise.resolve(false)
+      });
+    } catch {
+      isInstalled = false;
+    }
+
+    return isInstalled;
+  },
+
+  isValidEmail(email: string) {
+    return ConstantsUtil.EMAIL_REGEX.test(email);
+  },
+
+  allSettled(promises: Promise<unknown>[]) {
+    return Promise.all(
+      promises.map(promise =>
+        promise
+          .then(value => ({ status: 'fulfilled', value }))
+          .catch(reason => ({ status: 'rejected', reason }))
+      )
+    );
+  },
+
+  calculateAndFormatBalance(array?: Balance[]) {
+    if (!array?.length) {
+      return { dollars: '0', pennies: '00' };
+    }
+
+    let sum = 0;
+    for (const item of array) {
+      sum += item?.value ?? 0;
+    }
+
+    const roundedNumber = sum.toFixed(2);
+    const [dollars, pennies] = roundedNumber.split('.');
+
+    return { dollars, pennies };
+  },
+
+  sortNetworks(
+    approvedCaipNetworkIds: `${string}:${string}`[] | undefined,
+    requestedCaipNetworks: CaipNetwork[] = []
+  ) {
+    const approvedIds = approvedCaipNetworkIds;
+    const requested = [...requestedCaipNetworks];
+
+    if (approvedIds?.length) {
+      requested?.sort((a, b) => {
+        if (approvedIds.includes(a.id) && !approvedIds.includes(b.id)) return -1;
+        if (approvedIds.includes(b.id) && !approvedIds.includes(a.id)) return 1;
+
+        return 0;
+      });
+    }
+
+    return requested;
+  },
+
+  debounce<F extends (...args: any[]) => any>(func: F, wait: number) {
+    let timeout: ReturnType<typeof setTimeout> | null = null;
+
+    return function (...args: Parameters<F>) {
+      if (timeout) {
+        clearTimeout(timeout);
+      }
+
+      timeout = setTimeout(() => {
+        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

@@ -0,0 +1,22 @@
+import type { Platform, WcWallet } from '@reown/appkit-common-react-native';
+
+export const EventUtil = {
+  getWalletPlatform(wallet: WcWallet, installed?: boolean): Platform | undefined {
+    if (installed) {
+      return 'mobile';
+    }
+
+    if (wallet.mobile_link && wallet.webapp_link) {
+      // if we cannot assure what platform the wallet is, we return undefined
+      return undefined;
+    }
+    if (wallet.mobile_link) {
+      return 'mobile';
+    }
+    if (wallet.webapp_link) {
+      return 'web';
+    }
+
+    return undefined;
+  }
+};