@reown/appkit-core-react-native 0.0.0-feat-multi-social-20250715153550 → 0.0.0-feat-onramp-20250718191948

package/src/utils/FetchUtil.ts

@@ -8,7 +8,7 @@ interface Options {
 
 interface RequestArguments {
   path: string;
-  headers?: HeadersInit;
+  headers?: HeadersInit_;
   params?: Record<string, string | undefined>;
   cache?: RequestCache;
   signal?: AbortSignal;
@@ -88,20 +88,41 @@ 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);
-        }
-      });
+    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) {
+        queryParams.push(`${encodeURIComponent(key)}=${encodeURIComponent(value)}`);
+      }
+    }
+
+    if (queryParams.length > 0) {
+      const queryString = queryParams.join('&');
+      if (fullUrl.includes('?')) {
+        fullUrl = `${fullUrl}&${queryString}`;
+      } else {
+        fullUrl = `${fullUrl}?${queryString}`;
+      }
     }
 
-    return url.toString();
+    return fullUrl;
   }
 
   private async processResponse<T>(response: Response) {

package/src/utils/NetworkUtil.ts

@@ -0,0 +1,33 @@
+import { RouterUtil } from './RouterUtil';
+import { RouterController } from '../controllers/RouterController';
+import { NetworkController } from '../controllers/NetworkController';
+import { AccountController } from '../controllers/AccountController';
+import { ConnectorController } from '../controllers/ConnectorController';
+import { SwapController } from '../controllers/SwapController';
+import type { CaipNetwork } from '../utils/TypeUtil';
+
+export const NetworkUtil = {
+  async handleNetworkSwitch(network: CaipNetwork) {
+    const { isConnected } = AccountController.state;
+    const { caipNetwork, approvedCaipNetworkIds, supportsAllNetworks } = NetworkController.state;
+    const isAuthConnected = ConnectorController.state.connectedConnector === 'AUTH';
+    let eventData = null;
+
+    if (isConnected && caipNetwork?.id !== network.id) {
+      if (approvedCaipNetworkIds?.includes(network.id) && !isAuthConnected) {
+        await NetworkController.switchActiveNetwork(network);
+        RouterUtil.navigateAfterNetworkSwitch(['ConnectingSiwe']);
+        eventData = { type: 'SWITCH_NETWORK', networkId: network.id };
+      } else if (supportsAllNetworks || isAuthConnected) {
+        RouterController.push('SwitchNetwork', { network });
+      }
+    } else if (!isConnected) {
+      NetworkController.setCaipNetwork(network);
+      RouterController.push('Connect');
+    }
+
+    SwapController.resetState();
+
+    return eventData;
+  }
+};

package/src/utils/StorageUtil.ts

@@ -2,6 +2,7 @@
 import AsyncStorage from '@react-native-async-storage/async-storage';
 import type {
   OnRampCountry,
+  OnRampCountryDefaults,
   OnRampFiatCurrency,
   OnRampFiatLimit,
   OnRampServiceProvider,
@@ -10,24 +11,22 @@ import type {
 import {
   DateUtil,
   type SocialProvider,
-  type ConnectorType,
-  type ChainNamespace
+  type ConnectorType
 } from '@reown/appkit-common-react-native';
 
 // -- Helpers -----------------------------------------------------------------
 const WC_DEEPLINK = 'WALLETCONNECT_DEEPLINK_CHOICE';
 const RECENT_WALLET = '@w3m/recent';
 const CONNECTED_WALLET_IMAGE_URL = '@w3m/connected_wallet_image_url';
-const CONNECTED_CONNECTORS = '@appkit/connected_connectors';
+const CONNECTED_CONNECTOR = '@w3m/connected_connector';
 const CONNECTED_SOCIAL = '@appkit/connected_social';
 const ONRAMP_PREFERRED_COUNTRY = '@appkit/onramp_preferred_country';
 const ONRAMP_COUNTRIES = '@appkit/onramp_countries';
+const ONRAMP_COUNTRIES_DEFAULTS = '@appkit/onramp_countries_defaults';
 const ONRAMP_SERVICE_PROVIDERS = '@appkit/onramp_service_providers';
 const ONRAMP_FIAT_LIMITS = '@appkit/onramp_fiat_limits';
 const ONRAMP_FIAT_CURRENCIES = '@appkit/onramp_fiat_currencies';
 const ONRAMP_PREFERRED_FIAT_CURRENCY = '@appkit/onramp_preferred_fiat_currency';
-const ACTIVE_NAMESPACE = '@appkit/active_namespace';
-
 // -- Utility -----------------------------------------------------------------
 export const StorageUtil = {
   setWalletConnectDeepLink({ href, name }: { href: string; name: string }) {
@@ -102,42 +101,29 @@ export const StorageUtil = {
     return [];
   },
 
-  async setConnectedConnectors({
-    type,
-    namespaces
-  }: {
-    type: ConnectorType;
-    namespaces: string[];
-  }) {
+  async setConnectedConnector(connectorType: ConnectorType) {
     try {
-      const currentConnectors = (await StorageUtil.getConnectedConnectors()) || [];
-      // Only add if it doesn't exist already
-      if (!currentConnectors.some(c => c.type === type)) {
-        const updatedConnectors = [...currentConnectors, { type, namespaces }];
-        await AsyncStorage.setItem(CONNECTED_CONNECTORS, JSON.stringify(updatedConnectors));
-      }
+      await AsyncStorage.setItem(CONNECTED_CONNECTOR, JSON.stringify(connectorType));
     } catch {
       console.info('Unable to set Connected Connector');
     }
   },
 
-  async getConnectedConnectors(): Promise<{ type: ConnectorType; namespaces: string[] }[]> {
+  async getConnectedConnector(): Promise<ConnectorType | undefined> {
     try {
-      const connectors = await AsyncStorage.getItem(CONNECTED_CONNECTORS);
+      const connector = (await AsyncStorage.getItem(CONNECTED_CONNECTOR)) as ConnectorType;
 
-      return connectors ? JSON.parse(connectors) : [];
+      return connector ? JSON.parse(connector) : undefined;
     } catch {
       console.info('Unable to get Connected Connector');
     }
 
-    return [];
+    return undefined;
   },
 
-  async removeConnectedConnectors(type: ConnectorType) {
+  async removeConnectedConnector() {
     try {
-      const currentConnectors = await StorageUtil.getConnectedConnectors();
-      const updatedConnectors = currentConnectors.filter(c => c.type !== type);
-      await AsyncStorage.setItem(CONNECTED_CONNECTORS, JSON.stringify(updatedConnectors));
+      await AsyncStorage.removeItem(CONNECTED_CONNECTOR);
     } catch {
       console.info('Unable to remove Connected Connector');
     }
@@ -257,6 +243,42 @@ export const StorageUtil = {
     return [];
   },
 
+  async setOnRampCountriesDefaults(countriesDefaults: OnRampCountryDefaults[]) {
+    try {
+      const timestamp = Date.now();
+
+      await AsyncStorage.setItem(
+        ONRAMP_COUNTRIES_DEFAULTS,
+        JSON.stringify({ data: countriesDefaults, timestamp })
+      );
+    } catch {
+      console.info('Unable to set OnRamp Countries Defaults');
+    }
+  },
+
+  async getOnRampCountriesDefaults() {
+    try {
+      const result = await AsyncStorage.getItem(ONRAMP_COUNTRIES_DEFAULTS);
+
+      if (!result) {
+        return [];
+      }
+
+      const { data, timestamp } = JSON.parse(result);
+
+      // Cache for 1 week
+      if (timestamp && DateUtil.isMoreThanOneWeekAgo(timestamp)) {
+        return [];
+      }
+
+      return data ? (data as OnRampCountryDefaults[]) : [];
+    } catch {
+      console.info('Unable to get OnRamp Countries Defaults');
+    }
+
+    return [];
+  },
+
   async setOnRampServiceProviders(serviceProviders: OnRampServiceProvider[]) {
     try {
       const timestamp = Date.now();
@@ -364,39 +386,5 @@ export const StorageUtil = {
     }
 
     return [];
-  },
-
-  async setActiveNamespace(namespace?: ChainNamespace) {
-    try {
-      if (!namespace) {
-        await AsyncStorage.removeItem(ACTIVE_NAMESPACE);
-
-        return;
-      }
-
-      await AsyncStorage.setItem(ACTIVE_NAMESPACE, namespace);
-    } catch {
-      console.info('Unable to set Active Namespace');
-    }
-  },
-
-  async getActiveNamespace() {
-    try {
-      const namespace = (await AsyncStorage.getItem(ACTIVE_NAMESPACE)) as ChainNamespace;
-
-      return namespace ?? undefined;
-    } catch (err) {
-      console.info('Unable to get Active Namespace');
-    }
-
-    return undefined;
-  },
-
-  async removeActiveNamespace() {
-    try {
-      await AsyncStorage.removeItem(ACTIVE_NAMESPACE);
-    } catch {
-      console.info('Unable to remove Active Namespace');
-    }
   }
 };

package/src/utils/SwapApiUtil.ts

@@ -1,17 +1,19 @@
-import type { Balance, CaipNetworkId } from '@reown/appkit-common-react-native';
 import { BlockchainApiController } from '../controllers/BlockchainApiController';
 import { OptionsController } from '../controllers/OptionsController';
-import type { BlockchainApiSwapAllowanceRequest, SwapTokenWithBalance } from './TypeUtil';
-import { ConnectionsController } from '../controllers/ConnectionsController';
-import { ConstantsUtil } from './ConstantsUtil';
+import { NetworkController } from '../controllers/NetworkController';
+import type {
+  BlockchainApiBalanceResponse,
+  BlockchainApiSwapAllowanceRequest,
+  SwapTokenWithBalance
+} from './TypeUtil';
+import { AccountController } from '../controllers/AccountController';
+import { ConnectionController } from '../controllers/ConnectionController';
 
 export const SwapApiUtil = {
   async getTokenList() {
-    const chainId: CaipNetworkId =
-      ConnectionsController.state.activeNetwork?.caipNetworkId ?? 'eip155:1';
     const response = await BlockchainApiController.fetchSwapTokens({
       projectId: OptionsController.state.projectId,
-      chainId
+      chainId: NetworkController.state.caipNetwork?.id
     });
     const tokens =
       response?.tokens?.map(
@@ -50,7 +52,7 @@ export const SwapApiUtil = {
 
     if (response?.allowance && sourceTokenAmount && sourceTokenDecimals) {
       const parsedValue =
-        ConnectionsController.parseUnits(sourceTokenAmount, sourceTokenDecimals) || 0;
+        ConnectionController.parseUnits(sourceTokenAmount, sourceTokenDecimals) || 0;
       const hasAllowance = BigInt(response.allowance) >= parsedValue;
 
       return hasAllowance;
@@ -59,31 +61,40 @@ export const SwapApiUtil = {
     return false;
   },
 
-  mapBalancesToSwapTokens(balances?: Balance[]) {
-    const { activeNamespace, activeCaipNetworkId } = ConnectionsController.state;
-    const address = activeNamespace
-      ? ConstantsUtil.NATIVE_TOKEN_ADDRESS[activeNamespace]
-      : undefined;
+  async getMyTokensWithBalance(forceUpdate?: string) {
+    const address = AccountController.state.address;
+    const chainId = NetworkController.state.caipNetwork?.id;
 
+    if (!address) {
+      return [];
+    }
+
+    const response = await BlockchainApiController.getBalance(address, chainId, forceUpdate);
+    const balances = response?.balances.filter(balance => balance.quantity.decimals !== '0');
+
+    AccountController.setTokenBalance(balances);
+
+    return this.mapBalancesToSwapTokens(balances);
+  },
+
+  mapBalancesToSwapTokens(balances?: BlockchainApiBalanceResponse['balances']) {
     return (
-      balances
-        ?.filter(balance => balance?.quantity?.numeric)
-        .map(
-          token =>
-            ({
-              ...token,
-              address: token?.address ?? `${token?.chainId ?? activeCaipNetworkId}:${address}`,
-              decimals: parseInt(token.quantity?.decimals ?? '0', 10),
-              logoUri: token.iconUrl,
-              eip2612: false
-            }) as SwapTokenWithBalance
-        ) || []
+      balances?.map(
+        token =>
+          ({
+            ...token,
+            address: token?.address || NetworkController.getActiveNetworkTokenAddress(),
+            decimals: parseInt(token.quantity.decimals, 10),
+            logoUri: token.iconUrl,
+            eip2612: false
+          }) as SwapTokenWithBalance
+      ) || []
     );
   },
 
   async fetchGasPrice() {
     const projectId = OptionsController.state.projectId;
-    const caipNetwork = ConnectionsController.state.activeNetwork;
+    const caipNetwork = NetworkController.state.caipNetwork;
 
     if (!caipNetwork) {
       return null;
@@ -91,7 +102,7 @@ export const SwapApiUtil = {
 
     return await BlockchainApiController.fetchGasPrice({
       projectId,
-      chainId: caipNetwork.caipNetworkId
+      chainId: caipNetwork.id
     });
   }
 };

package/src/utils/TypeUtil.ts

@@ -1,12 +1,28 @@
-import type { AccountType, CaipAddress, CaipNetworkId } from '@reown/appkit-common-react-native';
-import type { SocialProvider, Transaction } from '@reown/appkit-common-react-native';
-
+import { type EventEmitter } from 'events';
+import type {
+  Balance,
+  SocialProvider,
+  ThemeMode,
+  Transaction,
+  ConnectorType
+} from '@reown/appkit-common-react-native';
 import { OnRampErrorType } from './ConstantsUtil';
 
 export interface BaseError {
   message?: string;
 }
 
+export type CaipAddress = `${string}:${string}:${string}`;
+
+export type CaipNetworkId = `${string}:${string}`;
+
+export interface CaipNetwork {
+  id: CaipNetworkId;
+  name?: string;
+  imageId?: string;
+  imageUrl?: string;
+}
+
 export type ConnectedWalletInfo =
   | {
       name?: string;
@@ -32,6 +48,18 @@ export type ProjectId = string;
 
 export type Platform = 'mobile' | 'web' | 'qrcode' | 'email' | 'unsupported';
 
+export type Connector = {
+  id: string;
+  type: ConnectorType;
+  name?: string;
+  imageId?: string;
+  explorerId?: string;
+  imageUrl?: string;
+  info?: { rdns?: string };
+  provider?: unknown;
+  installed?: boolean;
+};
+
 export type CaipNamespaces = Record<
   string,
   {
@@ -43,13 +71,12 @@ export type CaipNamespaces = Record<
 
 export type SdkType = 'appkit';
 
-//TODO: check this
 export type SdkVersion =
   | `react-native-wagmi-${string}`
   | `react-native-ethers5-${string}`
   | `react-native-ethers-${string}`;
 
-type EnabledSocials = SocialProvider;
+type EnabledSocials = Exclude<SocialProvider, 'farcaster'>;
 
 export type Features = {
   /**
@@ -63,10 +90,15 @@ export type Features = {
    */
   onramp?: boolean;
   /**
-   * @description Show or hide the regular wallet options when socials are enabled. Enabled by default.
+   * @description Enable or disable the email feature. Enabled by default.
+   * @type {boolean}
+   */
+  email?: boolean;
+  /**
+   * @description Show or hide the regular wallet options when email is enabled. Enabled by default.
    * @type {boolean}
    */
-  showWallets?: boolean;
+  emailShowWallets?: boolean;
   /**
    * @description Enable or disable the socials feature. Enabled by default.
    * @type {EnabledSocials[]}
@@ -136,22 +168,8 @@ export interface BlockchainApiIdentityResponse {
   name: string;
 }
 
-export interface BlockchainApiBalance {
-  name: string;
-  symbol: string;
-  chainId: string;
-  address?: CaipAddress;
-  value?: number;
-  price: number;
-  quantity: {
-    decimals: string;
-    numeric: string;
-  };
-  iconUrl: string;
-}
-
 export interface BlockchainApiBalanceResponse {
-  balances: BlockchainApiBalance[];
+  balances: Balance[];
 }
 
 export interface BlockchainApiTransactionsRequest {
@@ -161,7 +179,6 @@ export interface BlockchainApiTransactionsRequest {
   onramp?: 'coinbase';
   signal?: AbortSignal;
   cache?: RequestCache;
-  chainId?: CaipNetworkId;
 }
 
 export interface BlockchainApiTransactionsResponse {
@@ -302,11 +319,12 @@ export interface BlockchainApiSwapTokensRequest {
 
 export interface BlockchainApiOnRampQuotesRequest {
   countryCode: string;
-  paymentMethodType: string;
+  paymentMethodType?: string;
   destinationCurrencyCode: string;
   sourceAmount: number;
   sourceCurrencyCode: string;
   walletAddress: string;
+  excludeProviders?: string[];
 }
 
 export interface BlockchainApiSwapTokensResponse {
@@ -329,6 +347,25 @@ export type BlockchainApiOnRampWidgetResponse = {
 };
 
 // -- OptionsController Types ---------------------------------------------------
+export interface Token {
+  address: string;
+  image?: string;
+}
+
+export type Tokens = Record<CaipNetworkId, Token>;
+
+export type Metadata = {
+  name: string;
+  description: string;
+  url: string;
+  icons: string[];
+  redirect?: {
+    native?: string;
+    universal?: string;
+    linkMode?: boolean;
+  };
+};
+
 export type CustomWallet = Pick<
   WcWallet,
   | 'id'
@@ -360,6 +397,9 @@ export type EventName =
   | 'CLICK_NETWORK_HELP'
   | 'CLICK_GET_WALLET'
   | 'EMAIL_LOGIN_SELECTED'
+  | 'EMAIL_SUBMITTED'
+  | 'DEVICE_REGISTERED_FOR_EMAIL'
+  | 'EMAIL_VERIFICATION_CODE_SENT'
   | 'EMAIL_VERIFICATION_CODE_PASS'
   | 'EMAIL_VERIFICATION_CODE_FAIL'
   | 'EMAIL_EDIT'
@@ -422,7 +462,7 @@ export type Event =
       type: 'track';
       event: 'SWITCH_NETWORK';
       properties: {
-        network: number | string;
+        network: string;
       };
     }
   | {
@@ -474,6 +514,18 @@ export type Event =
       type: 'track';
       event: 'EMAIL_LOGIN_SELECTED';
     }
+  | {
+      type: 'track';
+      event: 'EMAIL_SUBMITTED';
+    }
+  | {
+      type: 'track';
+      event: 'DEVICE_REGISTERED_FOR_EMAIL';
+    }
+  | {
+      type: 'track';
+      event: 'EMAIL_VERIFICATION_CODE_SENT';
+    }
   | {
       type: 'track';
       event: 'EMAIL_VERIFICATION_CODE_PASS';
@@ -675,7 +727,7 @@ export type Event =
       type: 'track';
       event: 'SET_PREFERRED_ACCOUNT_TYPE';
       properties: {
-        accountType: AccountType;
+        accountType: AppKitFrameAccountType;
         network: string;
       };
     }
@@ -809,6 +861,12 @@ export type OnRampCountry = {
   name: string;
 };
 
+export type OnRampCountryDefaults = {
+  countryCode: string;
+  defaultCurrencyCode: string;
+  defaultPaymentMethods: string[];
+};
+
 export type OnRampFiatCurrency = {
   currencyCode: string;
   name: string;
@@ -878,3 +936,92 @@ export type OnRampTransactionResult = {
   status: string | null;
   network: string | null;
 };
+
+// -- Email Types ------------------------------------------------
+/**
+ * Matches type defined for packages/wallet/src/AppKitFrameProvider.ts
+ * It's duplicated in order to decouple scaffold from email package
+ */
+
+export type AppKitFrameAccountType = 'eoa' | 'smartAccount';
+
+export interface AppKitFrameProvider {
+  readonly id: string;
+  readonly name: string;
+  getEventEmitter(): EventEmitter;
+  getSecureSiteURL(): string;
+  getSecureSiteDashboardURL(): string;
+  getSecureSiteIconURL(): string;
+  getEmail(): string | undefined;
+  getUsername(): string | undefined;
+  getLastUsedChainId(): Promise<number | undefined>;
+  rejectRpcRequest(): void;
+  connectEmail(payload: { email: string }): Promise<{
+    action: 'VERIFY_DEVICE' | 'VERIFY_OTP';
+  }>;
+  connectDevice(): Promise<unknown>;
+  connectSocial(uri: string): Promise<{
+    chainId: string | number;
+    email: string;
+    address: string;
+    accounts?: {
+      type: AppKitFrameAccountType;
+      address: string;
+    }[];
+    userName?: string;
+  }>;
+  getSocialRedirectUri(payload: { provider: SocialProvider }): Promise<{
+    uri: string;
+  }>;
+  connectOtp(payload: { otp: string }): Promise<unknown>;
+  connectFarcaster: () => Promise<{ userName: string }>;
+  getFarcasterUri(): Promise<{ url: string }>;
+  isConnected(): Promise<{
+    isConnected: boolean;
+  }>;
+  getChainId(): Promise<{
+    chainId: number;
+  }>;
+  updateEmail(payload: { email: string }): Promise<{
+    action: 'VERIFY_PRIMARY_OTP' | 'VERIFY_SECONDARY_OTP';
+  }>;
+  updateEmailPrimaryOtp(payload: { otp: string }): Promise<unknown>;
+  updateEmailSecondaryOtp(payload: { otp: string }): Promise<{
+    newEmail: string;
+  }>;
+  syncTheme(payload: {
+    themeMode: ThemeMode | undefined;
+    themeVariables: Record<string, string | number> | undefined;
+  }): Promise<unknown>;
+  syncDappData(payload: {
+    projectId: string;
+    sdkVersion: SdkVersion;
+    sdkType: SdkType;
+    metadata?: Metadata;
+  }): Promise<unknown>;
+  connect(payload?: { chainId: number | undefined }): Promise<{
+    chainId: number;
+    email?: string | null;
+    address: string;
+    smartAccountDeployed: boolean;
+    preferredAccountType: AppKitFrameAccountType;
+  }>;
+  switchNetwork(chainId: number): Promise<{
+    chainId: number;
+  }>;
+  setPreferredAccount(type: AppKitFrameAccountType): Promise<{
+    type: AppKitFrameAccountType;
+    address: string;
+  }>;
+  setOnTimeout(callback: () => void): void;
+  getSmartAccountEnabledNetworks(): Promise<{
+    smartAccountEnabledNetworks: number[];
+  }>;
+  disconnect(): Promise<unknown>;
+  request(req: any): Promise<any>;
+  AuthView: () => React.JSX.Element | null;
+  Webview: () => React.JSX.Element | null;
+  onSetPreferredAccount: (
+    callback: (values: { type: AppKitFrameAccountType; address: string }) => void
+  ) => void;
+}