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

package/src/controllers/AccountController.ts

@@ -0,0 +1,80 @@
+import { proxy } from 'valtio';
+import { subscribeKey as subKey } from 'valtio/utils';
+
+import { CoreHelperUtil } from '../utils/CoreHelperUtil';
+import type { CaipAddress, ConnectedWalletInfo } from '../utils/TypeUtil';
+
+// -- Types --------------------------------------------- //
+export interface AccountControllerState {
+  isConnected: boolean;
+  caipAddress?: CaipAddress;
+  address?: string;
+  balance?: string;
+  balanceSymbol?: string;
+  profileName?: string;
+  profileImage?: string;
+  addressExplorerUrl?: string;
+  connectedWalletInfo?: ConnectedWalletInfo;
+}
+
+type StateKey = keyof AccountControllerState;
+
+// -- State --------------------------------------------- //
+const state = proxy<AccountControllerState>({
+  isConnected: false
+});
+
+// -- Controller ---------------------------------------- //
+export const AccountController = {
+  state,
+
+  subscribeKey<K extends StateKey>(key: K, callback: (value: AccountControllerState[K]) => void) {
+    return subKey(state, key, callback);
+  },
+
+  setIsConnected(isConnected: AccountControllerState['isConnected']) {
+    state.isConnected = isConnected;
+  },
+
+  setCaipAddress(caipAddress: AccountControllerState['caipAddress']) {
+    const address = caipAddress ? CoreHelperUtil.getPlainAddress(caipAddress) : undefined;
+    state.caipAddress = caipAddress;
+    state.address = address;
+  },
+
+  setBalance(
+    balance: AccountControllerState['balance'],
+    balanceSymbol: AccountControllerState['balanceSymbol']
+  ) {
+    state.balance = balance;
+    state.balanceSymbol = balanceSymbol;
+  },
+
+  setProfileName(profileName: AccountControllerState['profileName']) {
+    state.profileName = profileName;
+  },
+
+  setProfileImage(profileImage: AccountControllerState['profileImage']) {
+    state.profileImage = profileImage;
+  },
+
+  setConnectedWalletInfo(connectedWalletInfo: AccountControllerState['connectedWalletInfo']) {
+    state.connectedWalletInfo = connectedWalletInfo;
+  },
+
+  setAddressExplorerUrl(explorerUrl: AccountControllerState['addressExplorerUrl']) {
+    state.addressExplorerUrl = explorerUrl;
+  },
+
+  resetAccount() {
+    state.isConnected = false;
+    state.caipAddress = undefined;
+    state.address = undefined;
+    state.balance = undefined;
+    state.balanceSymbol = undefined;
+    state.profileName = undefined;
+    state.profileImage = undefined;
+    state.addressExplorerUrl = undefined;
+    state.connectedWalletInfo = undefined;
+  }
+};

package/src/controllers/ApiController.ts

@@ -0,0 +1,360 @@
+import { Platform } from 'react-native';
+import { subscribeKey as subKey } from 'valtio/utils';
+import { proxy } from 'valtio';
+import { CoreHelperUtil } from '../utils/CoreHelperUtil';
+import { FetchUtil } from '../utils/FetchUtil';
+import { StorageUtil } from '../utils/StorageUtil';
+import type {
+  ApiGetAnalyticsConfigResponse,
+  ApiGetDataWalletsResponse,
+  ApiGetWalletsRequest,
+  ApiGetWalletsResponse,
+  WcWallet
+} from '../utils/TypeUtil';
+import { AssetController } from './AssetController';
+import { NetworkController } from './NetworkController';
+import { OptionsController } from './OptionsController';
+import { ConnectorController } from './ConnectorController';
+import { ConnectionController } from './ConnectionController';
+
+// -- Helpers ------------------------------------------- //
+const baseUrl = CoreHelperUtil.getApiUrl();
+const api = new FetchUtil({ baseUrl });
+const defaultEntries = '48';
+const recommendedEntries = '4';
+
+// -- Types --------------------------------------------- //
+export interface ApiControllerState {
+  prefetchPromise?: Promise<unknown>;
+  page: number;
+  count: number;
+  featured: WcWallet[];
+  recommended: WcWallet[];
+  installed: WcWallet[];
+  wallets: WcWallet[];
+  search: WcWallet[];
+}
+
+type StateKey = keyof ApiControllerState;
+
+// -- State --------------------------------------------- //
+const state = proxy<ApiControllerState>({
+  page: 1,
+  count: 0,
+  featured: [],
+  recommended: [],
+  wallets: [],
+  search: [],
+  installed: []
+});
+
+// -- Controller ---------------------------------------- //
+export const ApiController = {
+  state,
+
+  platform() {
+    return Platform.select({ default: 'ios', android: 'android' });
+  },
+
+  subscribeKey<K extends StateKey>(key: K, callback: (value: ApiControllerState[K]) => void) {
+    return subKey(state, key, callback);
+  },
+
+  _getApiHeaders() {
+    const { projectId, sdkType, sdkVersion } = OptionsController.state;
+    const reactNativeVersion = [
+      Platform.constants.reactNativeVersion.major,
+      Platform.constants.reactNativeVersion.minor,
+      Platform.constants.reactNativeVersion.patch
+    ].join('.');
+
+    return {
+      'x-project-id': projectId,
+      'x-sdk-type': sdkType,
+      'x-sdk-version': sdkVersion,
+      'User-Agent': `${Platform.OS}-${Platform.Version}@rn-${reactNativeVersion}`,
+      'Origin': CoreHelperUtil.getBundleId()
+    };
+  },
+
+  async _fetchWalletImage(imageId: string) {
+    const headers = ApiController._getApiHeaders();
+    const url = await api.fetchImage(`/getWalletImage/${imageId}`, headers);
+    if (url) {
+      AssetController.setWalletImage(imageId, url);
+    }
+  },
+
+  async _fetchConnectorImage(imageId: string) {
+    const headers = ApiController._getApiHeaders();
+    const url = await api.fetchImage(`/public/getAssetImage/${imageId}`, headers);
+    if (url) {
+      AssetController.setConnectorImage(imageId, url);
+    }
+  },
+
+  async _fetchNetworkImage(imageId: string) {
+    const headers = ApiController._getApiHeaders();
+    const url = await api.fetchImage(`/public/getAssetImage/${imageId}`, headers);
+    if (url) {
+      AssetController.setNetworkImage(imageId, url);
+    }
+  },
+
+  async fetchConnectorImages() {
+    const { connectors } = ConnectorController.state;
+    const ids = connectors.map(({ imageId }) => imageId).filter(Boolean);
+    await CoreHelperUtil.allSettled(
+      (ids as string[]).map(id => ApiController._fetchConnectorImage(id))
+    );
+  },
+
+  async fetchNetworkImages() {
+    const { requestedCaipNetworks } = NetworkController.state;
+    const ids = requestedCaipNetworks?.map(({ imageId }) => imageId).filter(Boolean);
+    if (ids) {
+      await CoreHelperUtil.allSettled(
+        (ids as string[]).map(id => ApiController._fetchNetworkImage(id))
+      );
+    }
+  },
+
+  async fetchInstalledWallets() {
+    const { includeWalletIds } = OptionsController.state;
+    const path = Platform.select({ default: 'getIosData', android: 'getAndroidData' });
+    const response = await api.get<ApiGetDataWalletsResponse>({
+      path,
+      headers: ApiController._getApiHeaders()
+    });
+
+    if (!response) return;
+
+    let { data: walletData } = response;
+
+    if (includeWalletIds?.length) {
+      walletData = walletData.filter(({ id }) => includeWalletIds.includes(id));
+    }
+
+    const promises = walletData.map(async item => {
+      return {
+        id: item.id,
+        isInstalled: await CoreHelperUtil.checkInstalled(item)
+      };
+    });
+
+    const results = await Promise.all(promises);
+    const installed = results.filter(({ isInstalled }) => isInstalled).map(({ id }) => id);
+    const { excludeWalletIds } = OptionsController.state;
+
+    if (installed.length > 0) {
+      const walletResponse = await api.get<ApiGetWalletsResponse>({
+        path: '/getWallets',
+        headers: ApiController._getApiHeaders(),
+        params: {
+          page: '1',
+          platform: this.platform(),
+          entries: installed?.length.toString(),
+          include: installed?.join(','),
+          exclude: excludeWalletIds?.join(',')
+        }
+      });
+
+      if (walletResponse?.data) {
+        const walletImages = walletResponse.data.map(d => d.image_id).filter(Boolean);
+        await CoreHelperUtil.allSettled(
+          (walletImages as string[]).map(id => ApiController._fetchWalletImage(id))
+        );
+        state.installed = walletResponse.data;
+        this.updateRecentWalletsInfo(walletResponse.data);
+      }
+    }
+  },
+
+  async fetchFeaturedWallets() {
+    const { featuredWalletIds } = OptionsController.state;
+    const exclude = state.installed.map(({ id }) => id);
+
+    if (featuredWalletIds?.length) {
+      const response = await api.get<ApiGetWalletsResponse>({
+        path: '/getWallets',
+        headers: ApiController._getApiHeaders(),
+        params: {
+          page: '1',
+          platform: this.platform(),
+          entries: featuredWalletIds?.length
+            ? String(featuredWalletIds.length)
+            : recommendedEntries,
+          include: featuredWalletIds?.join(','),
+          exclude: exclude?.join(',')
+        }
+      });
+      if (!response) return;
+      const { data } = response;
+
+      this.updateRecentWalletsInfo(data);
+
+      data.sort((a, b) => featuredWalletIds.indexOf(a.id) - featuredWalletIds.indexOf(b.id));
+      const images = data.map(d => d.image_id).filter(Boolean);
+      await CoreHelperUtil.allSettled(
+        (images as string[]).map(id => ApiController._fetchWalletImage(id))
+      );
+      state.featured = data;
+    }
+  },
+
+  async fetchRecommendedWallets() {
+    const { installed } = ApiController.state;
+    const { includeWalletIds, excludeWalletIds, featuredWalletIds } = OptionsController.state;
+
+    const exclude = [
+      ...installed.map(({ id }) => id),
+      ...(excludeWalletIds ?? []),
+      ...(featuredWalletIds ?? [])
+    ].filter(Boolean);
+
+    const response = await api.get<ApiGetWalletsResponse>({
+      path: '/getWallets',
+      headers: ApiController._getApiHeaders(),
+      params: {
+        page: '1',
+        platform: this.platform(),
+        entries: recommendedEntries,
+        include: includeWalletIds?.join(','),
+        exclude: exclude?.join(',')
+      }
+    });
+
+    if (!response) return;
+    const { data, count } = response;
+
+    this.updateRecentWalletsInfo(data);
+
+    const recent = await StorageUtil.getRecentWallets();
+    const recommendedImages = data.map(d => d.image_id).filter(Boolean);
+    const recentImages = recent.map(r => r.image_id).filter(Boolean);
+    await CoreHelperUtil.allSettled(
+      ([...recommendedImages, ...recentImages] as string[]).map(id =>
+        ApiController._fetchWalletImage(id)
+      )
+    );
+    state.recommended = data;
+    state.count = count ?? 0;
+  },
+
+  async fetchWallets({ page }: Pick<ApiGetWalletsRequest, 'page'>) {
+    const { includeWalletIds, excludeWalletIds, featuredWalletIds } = OptionsController.state;
+    const exclude = [
+      ...state.installed.map(({ id }) => id),
+      ...state.recommended.map(({ id }) => id),
+      ...(excludeWalletIds ?? []),
+      ...(featuredWalletIds ?? [])
+    ].filter(Boolean);
+    const response = await api.get<ApiGetWalletsResponse>({
+      path: '/getWallets',
+      headers: ApiController._getApiHeaders(),
+      params: {
+        page: String(page),
+        platform: this.platform(),
+        entries: String(defaultEntries),
+        include: includeWalletIds?.join(','),
+        exclude: exclude.join(',')
+      }
+    });
+
+    if (!response) return;
+    const { data, count } = response;
+
+    if (page === 1) {
+      this.updateRecentWalletsInfo(data);
+    }
+
+    const images = data.map(w => w.image_id).filter(Boolean);
+    await CoreHelperUtil.allSettled([
+      ...(images as string[]).map(id => ApiController._fetchWalletImage(id)),
+      CoreHelperUtil.wait(300)
+    ]);
+    state.wallets = [...state.wallets, ...data];
+    state.count = count > state.count ? count : state.count;
+    state.page = page;
+  },
+
+  async searchWallet({ search }: Pick<ApiGetWalletsRequest, 'search'>) {
+    const { includeWalletIds, excludeWalletIds } = OptionsController.state;
+    state.search = [];
+    const response = await api.get<ApiGetWalletsResponse>({
+      path: '/getWallets',
+      headers: ApiController._getApiHeaders(),
+      params: {
+        page: '1',
+        platform: this.platform(),
+        entries: String(defaultEntries),
+        search,
+        include: includeWalletIds?.join(','),
+        exclude: excludeWalletIds?.join(',')
+      }
+    });
+
+    if (!response) return;
+    const { data } = response;
+
+    const images = data.map(w => w.image_id).filter(Boolean);
+    await CoreHelperUtil.allSettled([
+      ...(images as string[]).map(id => ApiController._fetchWalletImage(id)),
+      CoreHelperUtil.wait(300)
+    ]);
+    state.search = data;
+  },
+
+  async updateRecentWalletsInfo(wallets: WcWallet[]) {
+    let update = false;
+    const recent = await StorageUtil.getRecentWallets();
+    if (!recent.length) {
+      return;
+    }
+
+    const updatedRecent = recent.map(r => {
+      const wallet = wallets.find(w => w.id === r.id);
+      if (wallet && JSON.stringify(wallet) !== JSON.stringify(r)) {
+        update = true;
+
+        return wallet;
+      }
+
+      return r;
+    });
+
+    if (update) {
+      await StorageUtil.setRecentWallets(updatedRecent);
+      ConnectionController.setRecentWallets(updatedRecent);
+    }
+  },
+
+  async prefetch() {
+    // this fetch must resolve first so we filter them in the other wallet requests
+    await ApiController.fetchInstalledWallets();
+
+    const promises = [
+      ApiController.fetchFeaturedWallets(),
+      ApiController.fetchRecommendedWallets(),
+      ApiController.fetchNetworkImages(),
+      ApiController.fetchConnectorImages()
+    ];
+    if (OptionsController.state.enableAnalytics === undefined) {
+      promises.push(ApiController.fetchAnalyticsConfig());
+    }
+
+    state.prefetchPromise = Promise.race([
+      CoreHelperUtil.allSettled(promises),
+      CoreHelperUtil.wait(3000)
+    ]);
+  },
+
+  async fetchAnalyticsConfig() {
+    const response = await api.get<ApiGetAnalyticsConfigResponse>({
+      path: '/getAnalyticsConfig',
+      headers: ApiController._getApiHeaders()
+    });
+    if (!response) return;
+    OptionsController.setEnableAnalytics(response.isAnalyticsEnabled);
+  }
+};

package/src/controllers/AssetController.ts

@@ -0,0 +1,38 @@
+import { proxy } from 'valtio';
+
+// -- Types --------------------------------------------- //
+export interface AssetControllerState {
+  walletImages: Record<string, string>;
+  networkImages: Record<string, string>;
+  connectorImages: Record<string, string>;
+  tokenImages: Record<string, string>;
+}
+
+// -- State --------------------------------------------- //
+const state = proxy<AssetControllerState>({
+  walletImages: {},
+  networkImages: {},
+  connectorImages: {},
+  tokenImages: {}
+});
+
+// -- Controller ---------------------------------------- //
+export const AssetController = {
+  state,
+
+  setWalletImage(key: string, value: string) {
+    state.walletImages[key] = value;
+  },
+
+  setNetworkImage(key: string, value: string) {
+    state.networkImages[key] = value;
+  },
+
+  setConnectorImage(key: string, value: string) {
+    state.connectorImages[key] = value;
+  },
+
+  setTokenImage(key: string, value: string) {
+    state.tokenImages[key] = value;
+  }
+};

package/src/controllers/BlockchainApiController.ts

@@ -0,0 +1,43 @@
+import { proxy } from 'valtio';
+
+import { CoreHelperUtil } from '../utils/CoreHelperUtil';
+import { FetchUtil } from '../utils/FetchUtil';
+import type {
+  BlockchainApiIdentityRequest,
+  BlockchainApiIdentityResponse
+} from '../utils/TypeUtil';
+import { OptionsController } from './OptionsController';
+
+// -- Helpers ------------------------------------------- //
+const baseUrl = CoreHelperUtil.getBlockchainApiUrl();
+
+// -- Types --------------------------------------------- //
+export interface BlockchainApiControllerState {
+  clientId: string | null;
+  api: FetchUtil;
+}
+
+// -- State --------------------------------------------- //
+const state = proxy<BlockchainApiControllerState>({
+  clientId: null,
+  api: new FetchUtil({ baseUrl })
+});
+
+// -- Controller ---------------------------------------- //
+export const BlockchainApiController = {
+  state,
+
+  fetchIdentity({ address }: BlockchainApiIdentityRequest) {
+    return state.api.get<BlockchainApiIdentityResponse>({
+      path: `/v1/identity/${address}`,
+      params: {
+        projectId: OptionsController.state.projectId
+      }
+    });
+  },
+
+  setClientId(clientId: string | null) {
+    state.clientId = clientId;
+    state.api = new FetchUtil({ baseUrl, clientId });
+  }
+};

package/src/controllers/ConnectionController.ts

@@ -0,0 +1,147 @@
+import { subscribeKey as subKey } from 'valtio/utils';
+import { proxy, ref } from 'valtio';
+import { CoreHelperUtil } from '../utils/CoreHelperUtil';
+import { StorageUtil } from '../utils/StorageUtil';
+import type { Connector, WcWallet } from '../utils/TypeUtil';
+import { RouterController } from './RouterController';
+import { ConnectorController } from './ConnectorController';
+
+// -- Types --------------------------------------------- //
+export interface ConnectExternalOptions {
+  id: Connector['id'];
+  type: Connector['type'];
+  provider?: Connector['provider'];
+  info?: Connector['info'];
+}
+
+export interface ConnectionControllerClient {
+  connectWalletConnect: (
+    onUri: (uri: string) => void,
+    walletUniversalLink?: string
+  ) => Promise<void>;
+  connectExternal?: (options: ConnectExternalOptions) => Promise<void>;
+  signMessage: (message: string) => Promise<string>;
+  disconnect: () => Promise<void>;
+}
+
+export interface ConnectionControllerState {
+  _client?: ConnectionControllerClient;
+  wcUri?: string;
+  wcPromise?: Promise<void>;
+  wcPairingExpiry?: number;
+  wcLinking?: {
+    href: string;
+    name: string;
+  };
+  wcError?: boolean;
+  pressedWallet?: WcWallet;
+  recentWallets?: WcWallet[];
+  connectedWalletImageUrl?: string;
+}
+
+type StateKey = keyof ConnectionControllerState;
+
+// -- State --------------------------------------------- //
+const state = proxy<ConnectionControllerState>({
+  wcError: false
+});
+
+// -- Controller ---------------------------------------- //
+export const ConnectionController = {
+  state,
+
+  subscribeKey<K extends StateKey>(
+    key: K,
+    callback: (value: ConnectionControllerState[K]) => void
+  ) {
+    return subKey(state, key, callback);
+  },
+
+  _getClient() {
+    if (!state._client) {
+      throw new Error('ConnectionController client not set');
+    }
+
+    return state._client;
+  },
+
+  setClient(client: ConnectionControllerClient) {
+    state._client = ref(client);
+  },
+
+  connectWalletConnect(walletUniversalLink?: string) {
+    state.wcPromise = this._getClient().connectWalletConnect(uri => {
+      state.wcUri = uri;
+      state.wcPairingExpiry = CoreHelperUtil.getPairingExpiry();
+      ConnectorController.setConnectedConnector('WALLET_CONNECT');
+      StorageUtil.setConnectedConnector('WALLET_CONNECT');
+    }, walletUniversalLink);
+  },
+
+  async connectExternal(options: ConnectExternalOptions) {
+    await this._getClient().connectExternal?.(options);
+    ConnectorController.setConnectedConnector(options.type);
+    StorageUtil.setConnectedConnector(options.type);
+  },
+
+  async signMessage(message: string) {
+    return this._getClient().signMessage(message);
+  },
+
+  setWcLinking(wcLinking: ConnectionControllerState['wcLinking']) {
+    state.wcLinking = wcLinking;
+  },
+
+  removeWcLinking() {
+    state.wcLinking = undefined;
+  },
+
+  setWcError(wcError: ConnectionControllerState['wcError']) {
+    state.wcError = wcError;
+  },
+
+  setPressedWallet(wallet: ConnectionControllerState['pressedWallet']) {
+    state.pressedWallet = wallet;
+  },
+
+  removePressedWallet() {
+    state.pressedWallet = undefined;
+  },
+
+  setRecentWallets(wallets: ConnectionControllerState['recentWallets']) {
+    state.recentWallets = wallets;
+  },
+
+  async setConnectedWalletImageUrl(url: ConnectionControllerState['connectedWalletImageUrl']) {
+    state.connectedWalletImageUrl = url;
+
+    if (url) {
+      await StorageUtil.setConnectedWalletImageUrl(url);
+    } else {
+      StorageUtil.removeConnectedWalletImageUrl();
+    }
+  },
+
+  clearUri() {
+    state.wcUri = undefined;
+    state.wcPairingExpiry = undefined;
+    state.wcPromise = undefined;
+    state.wcLinking = undefined;
+  },
+
+  resetWcConnection() {
+    this.clearUri();
+    state.pressedWallet = undefined;
+    state.connectedWalletImageUrl = undefined;
+    ConnectorController.setConnectedConnector(undefined);
+    StorageUtil.removeWalletConnectDeepLink();
+    StorageUtil.removeConnectedWalletImageUrl();
+    StorageUtil.removeConnectedConnector();
+  },
+
+  async disconnect() {
+    await this._getClient().disconnect();
+    this.resetWcConnection();
+    RouterController.reset('Connect');
+  }
+};