@reown/appkit-core-react-native 0.0.0-canary-20240912195440

package/src/utils/CoreHelperUtil.ts

@@ -0,0 +1,249 @@
+/* eslint-disable no-bitwise */
+
+import { Linking, Platform } from 'react-native';
+import { ConstantsUtil as CommonConstants } from '@reown/appkit-common-react-native';
+
+import { ConstantsUtil } from './ConstantsUtil';
+import type { CaipAddress, DataWallet, LinkingRecord } from './TypeUtil';
+
+// -- 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;
+  },
+
+  getPairingExpiry() {
+    return Date.now() + ConstantsUtil.FOUR_MINUTES_MS;
+  },
+
+  getNetworkId(caipAddress: CaipAddress | undefined) {
+    return caipAddress?.split(':')[1];
+  },
+
+  getPlainAddress(caipAddress: CaipAddress | undefined) {
+    return caipAddress?.split(':')[2];
+  },
+
+  async wait(milliseconds: number) {
+    return new Promise(resolve => {
+      setTimeout(resolve, milliseconds);
+    });
+  },
+
+  debounce(func: (...args: any[]) => unknown, timeout = 500) {
+    let timer: ReturnType<typeof setTimeout> | undefined;
+
+    return (...args: unknown[]) => {
+      function next() {
+        func(...args);
+      }
+      if (timer) {
+        clearTimeout(timer);
+      }
+      timer = setTimeout(next, timeout);
+    };
+  },
+
+  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): 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: `${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 || ''}`;
+  },
+
+  getApiUrl() {
+    return CommonConstants.API_URL;
+  },
+
+  getBlockchainApiUrl() {
+    return CommonConstants.BLOCKCHAIN_API_RPC_URL;
+  },
+
+  getAnalyticsUrl() {
+    return CommonConstants.PULSE_API_URL;
+  },
+
+  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() {
+    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 }))
+      )
+    );
+  }
+};

package/src/utils/EventUtil.ts

@@ -0,0 +1,22 @@
+import type { Platform, WcWallet } from './TypeUtil';
+
+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;
+  }
+};

package/src/utils/FetchUtil.ts

@@ -0,0 +1,117 @@
+// -- Types ----------------------------------------------------------------------
+interface Options {
+  baseUrl: string;
+  clientId?: string | null;
+}
+
+interface RequestArguments {
+  path: string;
+  headers?: HeadersInit_;
+  params?: Record<string, string | undefined>;
+}
+
+interface PostArguments extends RequestArguments {
+  body?: Record<string, unknown>;
+}
+
+// -- Utility --------------------------------------------------------------------
+export class FetchUtil {
+  public baseUrl: Options['baseUrl'];
+  public clientId: Options['clientId'];
+
+  public constructor({ baseUrl, clientId }: Options) {
+    this.baseUrl = baseUrl;
+    this.clientId = clientId;
+  }
+
+  public async get<T>({ headers, ...args }: RequestArguments) {
+    const url = this.createUrl(args);
+    const response = await fetch(url, { method: 'GET', headers });
+
+    return this.processResponse<T>(response);
+  }
+
+  public async post<T>({ body, headers, ...args }: PostArguments) {
+    const url = this.createUrl(args);
+    const response = await fetch(url, {
+      method: 'POST',
+      headers,
+      body: body ? JSON.stringify(body) : undefined
+    });
+
+    return this.processResponse<T>(response);
+  }
+
+  public async put<T>({ body, headers, ...args }: PostArguments) {
+    const url = this.createUrl(args);
+    const response = await fetch(url, {
+      method: 'PUT',
+      headers,
+      body: body ? JSON.stringify(body) : undefined
+    });
+
+    return this.processResponse<T>(response);
+  }
+
+  public async delete<T>({ body, headers, ...args }: PostArguments) {
+    const url = this.createUrl(args);
+    const response = await fetch(url, {
+      method: 'DELETE',
+      headers,
+      body: body ? JSON.stringify(body) : undefined
+    });
+
+    return this.processResponse<T>(response);
+  }
+
+  public async fetchImage(path: string, headers?: Record<string, string>) {
+    try {
+      const url = this.createUrl({ path }).toString();
+      const response = await fetch(url, { headers });
+      const blob = await response.blob();
+      const reader = new FileReader();
+      reader.readAsDataURL(blob);
+
+      return new Promise<string>(resolve => {
+        reader.onloadend = () => resolve(reader.result as string);
+      });
+    } catch {
+      return undefined;
+    }
+  }
+
+  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);
+        }
+      });
+    }
+
+    if (this.clientId) {
+      url.searchParams.append('clientId', this.clientId);
+    }
+
+    return url.toString();
+  }
+
+  private async processResponse<T>(response: Response) {
+    if (!response.ok) {
+      const errorText = await response.text();
+
+      return Promise.reject(`Code: ${response.status} - ${response.statusText} - ${errorText}`);
+    }
+
+    if (response.headers.get('content-length') === '0') {
+      return;
+    }
+
+    if (response.headers.get('content-type')?.includes('application/json')) {
+      return response.json() as T;
+    }
+
+    return;
+  }
+}

package/src/utils/RouterUtil.ts

@@ -0,0 +1,18 @@
+import { RouterController, type RouterControllerState } from '../controllers/RouterController';
+import { ModalController } from '../controllers/ModalController';
+
+export const RouterUtil = {
+  navigateAfterNetworkSwitch(excludeViews: RouterControllerState['view'][] = []) {
+    if (excludeViews.includes(RouterController.state.view)) {
+      return;
+    }
+
+    const { history } = RouterController.state;
+    const networkSelectIndex = history.findIndex(name => name === 'Networks');
+    if (networkSelectIndex >= 1) {
+      RouterController.goBackToIndex(networkSelectIndex - 1);
+    } else {
+      ModalController.close();
+    }
+  }
+};

package/src/utils/StorageUtil.ts

@@ -0,0 +1,138 @@
+/* eslint-disable no-console */
+import AsyncStorage from '@react-native-async-storage/async-storage';
+import type { ConnectorType, WcWallet } from './TypeUtil';
+
+// -- Helpers -----------------------------------------------------------------
+const WC_DEEPLINK = 'WALLETCONNECT_DEEPLINK_CHOICE';
+const RECENT_WALLET = '@w3m/recent';
+const CONNECTED_WALLET_IMAGE_URL = '@w3m/connected_wallet_image_url';
+const CONNECTED_CONNECTOR = '@w3m/connected_connector';
+
+// -- Utility -----------------------------------------------------------------
+export const StorageUtil = {
+  setWalletConnectDeepLink({ href, name }: { href: string; name: string }) {
+    try {
+      AsyncStorage.setItem(WC_DEEPLINK, JSON.stringify({ href, name }));
+    } catch {
+      console.info('Unable to set WalletConnect deep link');
+    }
+  },
+
+  async getWalletConnectDeepLink() {
+    try {
+      const deepLink = await AsyncStorage.getItem(WC_DEEPLINK);
+      if (deepLink) {
+        return JSON.parse(deepLink);
+      }
+    } catch {
+      console.info('Unable to get WalletConnect deep link');
+    }
+
+    return undefined;
+  },
+
+  async removeWalletConnectDeepLink() {
+    try {
+      await AsyncStorage.removeItem(WC_DEEPLINK);
+    } catch {
+      console.info('Unable to delete WalletConnect deep link');
+    }
+  },
+
+  async addRecentWallet(wallet: WcWallet) {
+    try {
+      const recentWallets = await StorageUtil.getRecentWallets();
+      const recentIndex = recentWallets.findIndex(w => w.id === wallet.id);
+
+      if (recentIndex > -1) {
+        recentWallets.splice(recentIndex, 1);
+      }
+
+      recentWallets.unshift(wallet);
+      if (recentWallets.length > 2) {
+        recentWallets.pop();
+      }
+      AsyncStorage.setItem(RECENT_WALLET, JSON.stringify(recentWallets));
+
+      return recentWallets;
+    } catch {
+      console.info('Unable to set recent wallet');
+
+      return undefined;
+    }
+  },
+
+  async setRecentWallets(wallets: WcWallet[]) {
+    try {
+      await AsyncStorage.setItem(RECENT_WALLET, JSON.stringify(wallets));
+    } catch {
+      console.info('Unable to set recent wallets');
+    }
+  },
+
+  async getRecentWallets(): Promise<WcWallet[]> {
+    try {
+      const recent = await AsyncStorage.getItem(RECENT_WALLET);
+
+      return recent ? JSON.parse(recent) : [];
+    } catch {
+      console.info('Unable to get recent wallets');
+    }
+
+    return [];
+  },
+
+  async setConnectedConnector(connectorType: ConnectorType) {
+    try {
+      await AsyncStorage.setItem(CONNECTED_CONNECTOR, JSON.stringify(connectorType));
+    } catch {
+      console.info('Unable to set Connected Connector');
+    }
+  },
+
+  async getConnectedConnector() {
+    try {
+      const connector = (await AsyncStorage.getItem(CONNECTED_CONNECTOR)) as ConnectorType;
+
+      return connector ? JSON.parse(connector) : undefined;
+    } catch {
+      console.info('Unable to get Connected Connector');
+    }
+
+    return undefined;
+  },
+
+  async removeConnectedConnector() {
+    try {
+      await AsyncStorage.removeItem(CONNECTED_CONNECTOR);
+    } catch {
+      console.info('Unable to remove Connected Connector');
+    }
+  },
+
+  async setConnectedWalletImageUrl(url: string) {
+    try {
+      await AsyncStorage.setItem(CONNECTED_WALLET_IMAGE_URL, url);
+    } catch {
+      console.info('Unable to set Connected Wallet Image URL');
+    }
+  },
+
+  async getConnectedWalletImageUrl() {
+    try {
+      return await AsyncStorage.getItem(CONNECTED_WALLET_IMAGE_URL);
+    } catch {
+      console.info('Unable to get Connected Wallet Image URL');
+    }
+
+    return undefined;
+  },
+
+  async removeConnectedWalletImageUrl() {
+    try {
+      await AsyncStorage.removeItem(CONNECTED_WALLET_IMAGE_URL);
+    } catch {
+      console.info('Unable to remove Connected Wallet Image URL');
+    }
+  }
+};