@reown/appkit-core-react-native 1.2.4 → 2.0.0-alpha.0

package/src/controllers/BlockchainApiController.ts

@@ -19,14 +19,27 @@ import type {
   BlockchainApiSwapQuoteResponse,
   BlockchainApiSwapTokensRequest,
   BlockchainApiSwapTokensResponse,
+  BlockchainApiOnRampWidgetResponse,
   BlockchainApiTokenPriceRequest,
   BlockchainApiTokenPriceResponse,
   BlockchainApiTransactionsRequest,
-  BlockchainApiTransactionsResponse
+  BlockchainApiTransactionsResponse,
+  OnRampCountry,
+  OnRampServiceProvider,
+  OnRampPaymentMethod,
+  OnRampCryptoCurrency,
+  OnRampFiatCurrency,
+  OnRampQuote,
+  BlockchainApiOnRampWidgetRequest,
+  BlockchainApiOnRampQuotesRequest,
+  OnRampFiatLimit
 } from '../utils/TypeUtil';
 import { OptionsController } from './OptionsController';
 import { ConstantsUtil } from '../utils/ConstantsUtil';
 import { ApiUtil } from '../utils/ApiUtil';
+import type { CaipNetworkId } from '@reown/appkit-common-react-native';
+import { ConnectionsController } from './ConnectionsController';
+import { SnackController } from './SnackController';
 
 // -- Helpers ------------------------------------------- //
 const baseUrl = CoreHelperUtil.getBlockchainApiUrl();
@@ -47,19 +60,54 @@ const getHeaders = () => {
 export interface BlockchainApiControllerState {
   clientId: string | null;
   api: FetchUtil;
+  supportedChains: { http: CaipNetworkId[]; ws: CaipNetworkId[] };
 }
 
 // -- State --------------------------------------------- //
 const state = proxy<BlockchainApiControllerState>({
   clientId: null,
-  api: new FetchUtil({ baseUrl })
+  api: new FetchUtil({ baseUrl }),
+  supportedChains: { http: [], ws: [] }
 });
 
 // -- Controller ---------------------------------------- //
 export const BlockchainApiController = {
   state,
 
-  fetchIdentity({ address }: BlockchainApiIdentityRequest) {
+  async isNetworkSupported(networkId?: CaipNetworkId) {
+    if (!networkId) {
+      return false;
+    }
+    try {
+      if (!state.supportedChains.http.length) {
+        await BlockchainApiController.getSupportedNetworks();
+      }
+    } catch (e) {
+      return false;
+    }
+
+    return state.supportedChains.http.includes(networkId);
+  },
+
+  async getSupportedNetworks() {
+    const supportedChains = await state.api.get<BlockchainApiControllerState['supportedChains']>({
+      path: 'v1/supported-chains'
+    });
+
+    state.supportedChains = supportedChains!;
+
+    return supportedChains;
+  },
+
+  async fetchIdentity({ address }: BlockchainApiIdentityRequest) {
+    const isSupported = await BlockchainApiController.isNetworkSupported(
+      ConnectionsController.state.activeCaipNetworkId
+    );
+
+    if (!isSupported) {
+      return { avatar: '', name: '' };
+    }
+
     return state.api.get<BlockchainApiIdentityResponse>({
       path: `/v1/identity/${address}`,
       params: {
@@ -69,29 +117,48 @@ export const BlockchainApiController = {
     });
   },
 
-  fetchTransactions({
+  async fetchTransactions({
     account,
     projectId,
     cursor,
     onramp,
     signal,
-    cache
+    cache,
+    chainId
   }: BlockchainApiTransactionsRequest) {
-    return state.api.get<BlockchainApiTransactionsResponse>({
+    const _chainId = chainId ?? ConnectionsController.state.activeCaipNetworkId;
+    const isSupported = await BlockchainApiController.isNetworkSupported(_chainId);
+
+    if (!isSupported) {
+      return { data: [], next: undefined };
+    }
+
+    const response = await state.api.get<BlockchainApiTransactionsResponse>({
       path: `/v1/account/${account}/history`,
       headers: getHeaders(),
       params: {
         projectId,
         cursor,
-        onramp
+        onramp,
+        chainId: _chainId
       },
       signal,
       cache
     });
+
+    return response;
   },
 
-  fetchTokenPrice({ projectId, addresses }: BlockchainApiTokenPriceRequest) {
-    return state.api.post<BlockchainApiTokenPriceResponse>({
+  async fetchTokenPrice({ projectId, addresses }: BlockchainApiTokenPriceRequest) {
+    const isSupported = await BlockchainApiController.isNetworkSupported(
+      ConnectionsController.state.activeCaipNetworkId
+    );
+
+    if (!isSupported) {
+      return { fungibles: [] };
+    }
+
+    const response = await state.api.post<BlockchainApiTokenPriceResponse>({
       path: '/v1/fungible/price',
       body: {
         projectId,
@@ -100,9 +167,23 @@ export const BlockchainApiController = {
       },
       headers: getHeaders()
     });
+
+    return response;
   },
 
-  fetchSwapAllowance({ projectId, tokenAddress, userAddress }: BlockchainApiSwapAllowanceRequest) {
+  async fetchSwapAllowance({
+    projectId,
+    tokenAddress,
+    userAddress
+  }: BlockchainApiSwapAllowanceRequest) {
+    const isSupported = await BlockchainApiController.isNetworkSupported(
+      ConnectionsController.state.activeCaipNetworkId
+    );
+
+    if (!isSupported) {
+      return { allowance: '0' };
+    }
+
     return state.api.get<BlockchainApiSwapAllowanceResponse>({
       path: `/v1/convert/allowance`,
       params: {
@@ -114,7 +195,15 @@ export const BlockchainApiController = {
     });
   },
 
-  fetchGasPrice({ projectId, chainId }: BlockchainApiGasPriceRequest) {
+  async fetchGasPrice({ projectId, chainId }: BlockchainApiGasPriceRequest) {
+    const isSupported = await BlockchainApiController.isNetworkSupported(
+      ConnectionsController.state.activeCaipNetworkId
+    );
+
+    if (!isSupported) {
+      throw new Error('Network not supported for Gas Price');
+    }
+
     return state.api.get<BlockchainApiGasPriceResponse>({
       path: `/v1/convert/gas-price`,
       headers: getHeaders(),
@@ -125,7 +214,7 @@ export const BlockchainApiController = {
     });
   },
 
-  fetchSwapQuote({
+  async fetchSwapQuote({
     projectId,
     amount,
     userAddress,
@@ -133,6 +222,14 @@ export const BlockchainApiController = {
     to,
     gasPrice
   }: BlockchainApiSwapQuoteRequest) {
+    const isSupported = await BlockchainApiController.isNetworkSupported(
+      ConnectionsController.state.activeCaipNetworkId
+    );
+
+    if (!isSupported) {
+      return { quotes: [] };
+    }
+
     return state.api.get<BlockchainApiSwapQuoteResponse>({
       path: `/v1/convert/quotes`,
       headers: getHeaders(),
@@ -147,7 +244,15 @@ export const BlockchainApiController = {
     });
   },
 
-  fetchSwapTokens({ projectId, chainId }: BlockchainApiSwapTokensRequest) {
+  async fetchSwapTokens({ projectId, chainId }: BlockchainApiSwapTokensRequest) {
+    const isSupported = await BlockchainApiController.isNetworkSupported(
+      ConnectionsController.state.activeCaipNetworkId
+    );
+
+    if (!isSupported) {
+      return { tokens: [] };
+    }
+
     return state.api.get<BlockchainApiSwapTokensResponse>({
       path: `/v1/convert/tokens`,
       headers: getHeaders(),
@@ -158,13 +263,21 @@ export const BlockchainApiController = {
     });
   },
 
-  generateSwapCalldata({
+  async generateSwapCalldata({
     amount,
     from,
     projectId,
     to,
     userAddress
   }: BlockchainApiGenerateSwapCalldataRequest) {
+    const isSupported = await BlockchainApiController.isNetworkSupported(
+      ConnectionsController.state.activeCaipNetworkId
+    );
+
+    if (!isSupported) {
+      throw new Error('Network not supported for Swaps');
+    }
+
     return state.api.post<BlockchainApiGenerateSwapCalldataResponse>({
       path: '/v1/convert/build-transaction',
       headers: getHeaders(),
@@ -181,12 +294,20 @@ export const BlockchainApiController = {
     });
   },
 
-  generateApproveCalldata({
+  async generateApproveCalldata({
     from,
     projectId,
     to,
     userAddress
   }: BlockchainApiGenerateApproveCalldataRequest) {
+    const isSupported = await BlockchainApiController.isNetworkSupported(
+      ConnectionsController.state.activeCaipNetworkId
+    );
+
+    if (!isSupported) {
+      throw new Error('Network not supported for Swaps');
+    }
+
     return state.api.get<BlockchainApiGenerateApproveCalldataResponse>({
       path: `/v1/convert/build-approve`,
       headers: getHeaders(),
@@ -200,6 +321,15 @@ export const BlockchainApiController = {
   },
 
   async getBalance(address: string, chainId?: string, forceUpdate?: string) {
+    const isSupported = await BlockchainApiController.isNetworkSupported(
+      ConnectionsController.state.activeCaipNetworkId
+    );
+    if (!isSupported) {
+      SnackController.showError('Token Balance Unavailable');
+
+      return { balances: [] };
+    }
+
     return state.api.get<BlockchainApiBalanceResponse>({
       path: `/v1/account/${address}/balance`,
       headers: getHeaders(),
@@ -223,6 +353,99 @@ export const BlockchainApiController = {
     });
   },
 
+  async fetchOnRampCountries() {
+    return await state.api.get<OnRampCountry[]>({
+      path: '/v1/onramp/providers/properties',
+      headers: getHeaders(),
+      params: {
+        projectId: OptionsController.state.projectId,
+        type: 'countries'
+      }
+    });
+  },
+
+  async fetchOnRampServiceProviders() {
+    return await state.api.get<OnRampServiceProvider[]>({
+      path: '/v1/onramp/providers',
+      headers: getHeaders(),
+      params: {
+        projectId: OptionsController.state.projectId
+      }
+    });
+  },
+
+  async fetchOnRampPaymentMethods(params: { countries?: string }) {
+    return await state.api.get<OnRampPaymentMethod[]>({
+      path: '/v1/onramp/providers/properties',
+      headers: getHeaders(),
+      params: {
+        projectId: OptionsController.state.projectId,
+        type: 'payment-methods',
+        ...params
+      }
+    });
+  },
+
+  async fetchOnRampCryptoCurrencies(params: { countries?: string }) {
+    return await state.api.get<OnRampCryptoCurrency[]>({
+      path: '/v1/onramp/providers/properties',
+      headers: getHeaders(),
+      params: {
+        projectId: OptionsController.state.projectId,
+        type: 'crypto-currencies',
+        ...params
+      }
+    });
+  },
+
+  async fetchOnRampFiatCurrencies() {
+    return await state.api.get<OnRampFiatCurrency[]>({
+      path: '/v1/onramp/providers/properties',
+      headers: getHeaders(),
+      params: {
+        projectId: OptionsController.state.projectId,
+        type: 'fiat-currencies'
+      }
+    });
+  },
+
+  async fetchOnRampFiatLimits() {
+    return await state.api.get<OnRampFiatLimit[]>({
+      path: '/v1/onramp/providers/properties',
+      headers: getHeaders(),
+      params: {
+        projectId: OptionsController.state.projectId,
+        type: 'fiat-purchases-limits'
+      }
+    });
+  },
+
+  async getOnRampQuotes(body: BlockchainApiOnRampQuotesRequest, signal?: AbortSignal) {
+    return await state.api.post<OnRampQuote[]>({
+      path: '/v1/onramp/multi/quotes',
+      headers: getHeaders(),
+      body: {
+        projectId: OptionsController.state.projectId,
+        ...body
+      },
+      signal
+    });
+  },
+
+  async getOnRampWidget(body: BlockchainApiOnRampWidgetRequest, signal?: AbortSignal) {
+    return await state.api.post<BlockchainApiOnRampWidgetResponse>({
+      path: '/v1/onramp/widget',
+      headers: getHeaders(),
+      body: {
+        projectId: OptionsController.state.projectId,
+        sessionData: {
+          ...body
+        }
+      },
+      signal
+    });
+  },
+
   setClientId(clientId: string | null) {
     state.clientId = clientId;
     state.api = new FetchUtil({ baseUrl, clientId });

package/src/controllers/ConnectionController.ts

@@ -120,6 +120,15 @@ export const ConnectionController = {
     state.pressedWallet = undefined;
   },
 
+  setWcPromise(wcPromise: ConnectionControllerState['wcPromise']) {
+    state.wcPromise = wcPromise;
+  },
+
+  setWcUri(wcUri: ConnectionControllerState['wcUri']) {
+    state.wcUri = wcUri;
+    state.wcPairingExpiry = CoreHelperUtil.getPairingExpiry();
+  },
+
   setRecentWallets(wallets: ConnectionControllerState['recentWallets']) {
     state.recentWallets = wallets;
   },
@@ -192,7 +201,6 @@ export const ConnectionController = {
   },
 
   async disconnect() {
-    await this._getClient().disconnect();
     this.resetWcConnection();
     // remove transactions
     // RouterController.reset('Connect');

package/src/controllers/ConnectionsController.ts

@@ -0,0 +1,236 @@
+import { proxy, ref } from 'valtio';
+import { derive } from 'valtio/utils';
+import type {
+  AppKitNetwork,
+  BlockchainAdapter,
+  CaipAddress,
+  CaipNetworkId,
+  ChainNamespace,
+  GetBalanceResponse,
+  WalletInfo
+} from '@reown/appkit-common-react-native';
+import { StorageUtil } from '../utils/StorageUtil';
+
+// -- Types --------------------------------------------- //
+type Balance = GetBalanceResponse;
+
+//TODO: balance could be elsewhere
+interface Connection {
+  accounts: CaipAddress[];
+  balances: Record<CaipAddress, Balance>; //TODO: make this an array of balances
+  adapter: BlockchainAdapter;
+  chains: CaipNetworkId[];
+  activeChain: CaipNetworkId;
+  wallet?: WalletInfo;
+}
+
+export interface ConnectionsControllerState {
+  activeNamespace?: ChainNamespace;
+  connections: Record<string, Connection>;
+  networks: AppKitNetwork[];
+}
+
+// -- State --------------------------------------------- //
+const baseState = proxy<ConnectionsControllerState>({
+  activeNamespace: undefined,
+  connections: {},
+  networks: []
+});
+
+const derivedState = derive(
+  {
+    activeAddress: (get): CaipAddress | undefined => {
+      const snap = get(baseState);
+
+      if (!snap.activeNamespace) return undefined;
+
+      const connection = snap.connections[snap.activeNamespace];
+
+      if (!connection || !connection.accounts || connection.accounts.length === 0) {
+        return undefined;
+      }
+
+      //TODO: what happens if there are several accounts on the same chain?
+      const activeAccount = connection.accounts.find(account =>
+        account.startsWith(connection.activeChain)
+      );
+
+      return activeAccount;
+    },
+    activeBalance: (get): Balance | undefined => {
+      const snap = get(baseState);
+
+      if (!snap.activeNamespace) return undefined;
+      const connection = snap.connections[snap.activeNamespace];
+
+      if (!connection || !connection.accounts || connection.accounts.length === 0) {
+        return undefined;
+      }
+
+      const activeAccount = connection.accounts.find(account =>
+        account.startsWith(connection.activeChain)
+      );
+
+      if (
+        !connection ||
+        !connection.balances ||
+        !activeAccount ||
+        Object.keys(connection.balances).length === 0
+      ) {
+        return undefined;
+      }
+
+      return connection.balances[activeAccount];
+    },
+    activeNetwork: (get): AppKitNetwork | undefined => {
+      const snap = get(baseState);
+
+      if (!snap.activeNamespace) return undefined;
+
+      const connection = snap.connections[snap.activeNamespace];
+
+      if (!connection) return undefined;
+
+      return snap.networks.find(
+        network =>
+          network.chainNamespace === snap.activeNamespace &&
+          network.id?.toString() === connection.activeChain?.split(':')[1]
+      );
+    },
+    activeCaipNetworkId: (get): CaipNetworkId | undefined => {
+      const snap = get(baseState);
+
+      if (!snap.activeNamespace) return undefined;
+
+      const connection = snap.connections[snap.activeNamespace];
+
+      if (!connection) return undefined;
+
+      return connection.activeChain;
+    },
+    walletInfo: (get): WalletInfo | undefined => {
+      const snap = get(baseState);
+
+      if (!snap.activeNamespace) return undefined;
+
+      return snap.connections[snap.activeNamespace]?.wallet;
+    }
+  },
+  {
+    proxy: baseState // Link derived proxy to the base state proxy
+  }
+);
+
+// -- Controller ---------------------------------------- //
+export const ConnectionsController = {
+  state: derivedState,
+
+  setActiveNamespace(namespace?: ChainNamespace) {
+    baseState.activeNamespace = namespace;
+    StorageUtil.setActiveNamespace(namespace);
+  },
+
+  storeConnection({
+    namespace,
+    adapter,
+    accounts,
+    chains,
+    wallet,
+    activeChain
+  }: {
+    namespace: string;
+    adapter: BlockchainAdapter;
+    accounts: CaipAddress[];
+    chains: CaipNetworkId[];
+    wallet?: WalletInfo;
+    activeChain?: CaipNetworkId;
+  }) {
+    baseState.connections[namespace] = {
+      balances: {},
+      activeChain: activeChain ?? chains[0]!,
+      adapter: ref(adapter),
+      accounts,
+      chains,
+      wallet
+    };
+  },
+
+  updateAccounts(namespace: string, accounts: CaipAddress[]) {
+    const connection = baseState.connections[namespace];
+    if (!connection) {
+      return;
+    }
+    connection.accounts = accounts;
+  },
+
+  updateBalance(namespace: string, address: CaipAddress, balance: Balance) {
+    const connection = baseState.connections[namespace];
+    if (!connection) {
+      return;
+    }
+    connection.balances[address] = balance;
+  },
+
+  setActiveChain(namespace: string, chain: CaipNetworkId) {
+    const connection = baseState.connections[namespace];
+
+    if (!connection) {
+      return;
+    }
+
+    connection.activeChain = chain;
+  },
+
+  setNetworks(networks: AppKitNetwork[]) {
+    baseState.networks = networks;
+  },
+
+  getConnectedNetworks() {
+    return baseState.networks.filter(
+      network =>
+        baseState.connections[network.chainNamespace]?.chains.includes(network.caipNetworkId)
+    );
+  },
+
+  async disconnect(namespace: string, isInternal = true) {
+    const connection = baseState.connections[namespace];
+    if (!connection) return;
+
+    // Get the current connector from the adapter
+    const connector = connection.adapter.connector;
+    if (!connector) return;
+
+    // Find all namespaces that use the same connector
+    const namespacesUsingConnector = Object.keys(baseState.connections).filter(
+      ns => baseState.connections[ns]?.adapter.connector === connector
+    );
+
+    // Unsubscribe all event listeners from the adapter
+    namespacesUsingConnector.forEach(ns => {
+      const _connection = baseState.connections[ns];
+      if (_connection?.adapter) {
+        _connection.adapter.removeAllListeners();
+      }
+    });
+
+    // Disconnect the adapter
+    if (isInternal) {
+      await connection.adapter.disconnect();
+    }
+
+    // Remove all namespaces that used this connector
+    namespacesUsingConnector.forEach(ns => {
+      delete baseState.connections[ns];
+    });
+
+    // Remove activeNamespace if it is in the list of namespaces using the connector
+    if (
+      baseState.activeNamespace &&
+      (baseState.activeNamespace === namespace ||
+        namespacesUsingConnector.includes(baseState.activeNamespace))
+    ) {
+      baseState.activeNamespace = undefined;
+      StorageUtil.setActiveNamespace(undefined);
+    }
+  }
+};

package/src/controllers/ConnectorController.ts

@@ -50,6 +50,7 @@ export const ConnectorController = {
 
     if (saveStorage) {
       if (connectorType) {
+        //TODO: Check this
         StorageUtil.setConnectedConnector(connectorType);
       } else {
         StorageUtil.removeConnectedConnector();

package/src/controllers/NetworkController.ts

@@ -1,5 +1,5 @@
 import { proxy, ref } from 'valtio';
-import type { CaipNetwork, CaipNetworkId } from '../utils/TypeUtil';
+import type { CaipNetwork, CaipNetworkId } from '@reown/appkit-common-react-native';
 import { PublicStateController } from './PublicStateController';
 import { NetworkUtil } from '@reown/appkit-common-react-native';
 import { ConstantsUtil } from '../utils/ConstantsUtil';