@reown/appkit-core-react-native 0.0.0-develop-20250728153935 → 0.0.0-develop-20251008155354

package/src/controllers/RouterController.ts

@@ -1,22 +1,12 @@
 import { proxy } from 'valtio';
 import type {
+  AppKitNetwork,
+  SocialProvider,
   WcWallet,
-  CaipNetwork,
-  Connector,
-  SwapInputTarget,
   OnRampTransactionResult
-} from '../utils/TypeUtil';
+} from '@reown/appkit-common-react-native';
 
 // -- Types --------------------------------------------- //
-type TransactionAction = {
-  goBack: boolean;
-  view: RouterControllerState['view'] | null;
-  close?: boolean;
-  replace?: boolean;
-  onSuccess?: () => void;
-  onCancel?: () => void;
-};
-
 export interface RouterControllerState {
   view:
     | 'Account'
@@ -25,13 +15,7 @@ export interface RouterControllerState {
     | 'Connect'
     | 'ConnectSocials'
     | 'ConnectingExternal'
-    | 'ConnectingSiwe'
     | 'ConnectingSocial'
-    | 'ConnectingFarcaster'
-    | 'ConnectingWalletConnect'
-    | 'Create'
-    | 'EmailVerifyDevice'
-    | 'EmailVerifyOtp'
     | 'GetWallet'
     | 'Networks'
     | 'OnRamp'
@@ -39,18 +23,15 @@ export interface RouterControllerState {
     | 'OnRampLoading'
     | 'OnRampSettings'
     | 'OnRampTransaction'
-    | 'SwitchNetwork'
+    | 'SIWXSignMessage'
     | 'Swap'
-    | 'SwapSelectToken'
     | 'SwapPreview'
+    | 'SwitchNetwork'
     | 'Transactions'
     | 'UnsupportedChain'
-    | 'UpdateEmailPrimaryOtp'
-    | 'UpdateEmailSecondaryOtp'
-    | 'UpdateEmailWallet'
     | 'UpgradeEmailWallet'
-    | 'UpgradeToSmartAccount'
     | 'WalletCompatibleNetworks'
+    | 'WalletConnect'
     | 'WalletReceive'
     | 'WalletSend'
     | 'WalletSendPreview'
@@ -58,62 +39,41 @@ export interface RouterControllerState {
     | 'WhatIsANetwork'
     | 'WhatIsAWallet';
   history: RouterControllerState['view'][];
+  navigationDirection: 'forward' | 'backward' | 'none';
   data?: {
-    connector?: Connector;
     wallet?: WcWallet;
-    network?: CaipNetwork;
-    email?: string;
-    newEmail?: string;
-    swapTarget?: SwapInputTarget;
+    network?: AppKitNetwork;
     onrampResult?: OnRampTransactionResult;
+    socialProvider?: SocialProvider;
   };
-  transactionStack: TransactionAction[];
 }
 
 // -- State --------------------------------------------- //
 const state = proxy<RouterControllerState>({
   view: 'Connect',
   history: ['Connect'],
-  transactionStack: []
+  navigationDirection: 'none'
 });
 
 // -- Controller ---------------------------------------- //
 export const RouterController = {
   state,
 
-  push(view: RouterControllerState['view'], data?: RouterControllerState['data']) {
+  push(
+    view: RouterControllerState['view'],
+    data?: RouterControllerState['data'],
+    direction: 'forward' | 'backward' = 'forward'
+  ) {
     if (view !== state.view) {
+      state.navigationDirection = direction;
       state.view = view;
       state.history = [...state.history, view];
       state.data = data;
     }
   },
 
-  pushTransactionStack(action: TransactionAction) {
-    state.transactionStack = [...state.transactionStack, action];
-  },
-
-  popTransactionStack(cancel?: boolean) {
-    const action = state.transactionStack.pop();
-
-    if (!action) {
-      return;
-    }
-
-    if (cancel) {
-      this.goBack();
-      action?.onCancel?.();
-    } else {
-      if (action.goBack) {
-        this.goBack();
-      } else if (action.view) {
-        this.reset(action.view);
-      }
-      action?.onSuccess?.();
-    }
-  },
-
   reset(view: RouterControllerState['view'], data?: RouterControllerState['data']) {
+    state.navigationDirection = 'none';
     state.view = view;
     state.history = [view];
     state.data = data;
@@ -121,6 +81,7 @@ export const RouterController = {
 
   replace(view: RouterControllerState['view'], data?: RouterControllerState['data']) {
     if (state.history.length >= 1 && state.history.at(-1) !== view) {
+      state.navigationDirection = 'none';
       state.view = view;
       state.history[state.history.length - 1] = view;
       state.data = data;
@@ -132,6 +93,7 @@ export const RouterController = {
       state.history.pop();
       const [last] = state.history.slice(-1);
       if (last) {
+        state.navigationDirection = 'backward';
         state.view = last;
       }
     }
@@ -142,6 +104,7 @@ export const RouterController = {
       state.history = state.history.slice(0, historyIndex + 1);
       const [last] = state.history.slice(-1);
       if (last) {
+        state.navigationDirection = 'backward';
         state.view = last;
       }
     }

package/src/controllers/SendController.ts

@@ -1,19 +1,20 @@
 import { subscribeKey as subKey } from 'valtio/utils';
 import { proxy, ref, subscribe as sub } from 'valtio';
 import { ContractUtil, type Balance } from '@reown/appkit-common-react-native';
-import { AccountController } from './AccountController';
-import { ConnectionController } from './ConnectionController';
+
 import { SnackController } from './SnackController';
 import { CoreHelperUtil } from '../utils/CoreHelperUtil';
 import { EventsController } from './EventsController';
-import { NetworkController } from './NetworkController';
 import { RouterController } from './RouterController';
+import { ConnectionsController } from './ConnectionsController';
+import { SwapController } from './SwapController';
+import { ConstantsUtil as CoreConstantsUtil } from '../utils/ConstantsUtil';
+import { LogController } from './LogController';
 
 // -- Types --------------------------------------------- //
 export interface TxParams {
   receiverAddress: string;
   sendTokenAmount: number;
-  gasPrice: bigint;
   decimals: string;
 }
 
@@ -30,8 +31,6 @@ export interface SendControllerState {
   receiverAddress?: string;
   receiverProfileName?: string;
   receiverProfileImageUrl?: string;
-  gasPrice?: bigint;
-  gasPriceInUSD?: number;
   loading: boolean;
 }
 
@@ -78,152 +77,189 @@ export const SendController = {
     state.receiverProfileName = receiverProfileName;
   },
 
-  setGasPrice(gasPrice: SendControllerState['gasPrice']) {
-    state.gasPrice = gasPrice;
-  },
-
-  setGasPriceInUsd(gasPriceInUSD: SendControllerState['gasPriceInUSD']) {
-    state.gasPriceInUSD = gasPriceInUSD;
-  },
-
   setLoading(loading: SendControllerState['loading']) {
     state.loading = loading;
   },
 
-  sendToken() {
-    if (this.state.token?.address && this.state.sendTokenAmount && this.state.receiverAddress) {
-      state.loading = true;
+  async sendToken() {
+    const isAuth = !!ConnectionsController.state.connection?.properties?.provider;
+    const eventProperties = {
+      isSmartAccount: ConnectionsController.state.accountType === 'smartAccount',
+      token: this.state.token?.address ?? this.state.token?.symbol ?? '',
+      amount: this.state.sendTokenAmount || 0,
+      network: ConnectionsController.state.activeNetwork?.caipNetworkId
+    };
+
+    try {
+      this.state.loading = true;
+
       EventsController.sendEvent({
         type: 'track',
         event: 'SEND_INITIATED',
-        properties: {
-          isSmartAccount: AccountController.state.preferredAccountType === 'smartAccount',
-          token: this.state.token.address,
-          amount: this.state.sendTokenAmount,
-          network: NetworkController.state.caipNetwork?.id || ''
-        }
+        properties: eventProperties
+      });
+
+      switch (ConnectionsController.state.activeNamespace) {
+        case 'eip155':
+          await SendController.sendEvmToken();
+
+          break;
+        case 'solana':
+          await SendController.sendSolanaToken();
+
+          break;
+        default:
+          throw new Error('Unsupported chain');
+      }
+
+      SnackController.showSuccess('Transaction started');
+      EventsController.sendEvent({
+        type: 'track',
+        event: 'SEND_SUCCESS',
+        properties: eventProperties
       });
-      this.sendERC20Token({
+      RouterController.reset(isAuth ? 'Account' : 'AccountDefault');
+      this.resetState();
+    } catch (error: any) {
+      LogController.sendError(error, 'SendController.ts', 'sendToken');
+      EventsController.sendEvent({
+        type: 'track',
+        event: 'SEND_ERROR',
+        properties: eventProperties
+      });
+
+      if (
+        error?.message &&
+        (error?.message.includes('user rejected') || error?.message.includes('canceled'))
+      ) {
+        SnackController.showError('Transaction cancelled');
+      } else {
+        SnackController.showError('Something went wrong');
+      }
+    } finally {
+      this.state.loading = false;
+    }
+  },
+
+  async sendEvmToken() {
+    if (this.state.token?.address && this.state.sendTokenAmount && this.state.receiverAddress) {
+      await this.sendERC20Token({
         receiverAddress: this.state.receiverAddress,
         tokenAddress: this.state.token.address,
         sendTokenAmount: this.state.sendTokenAmount,
-        decimals: this.state.token.quantity.decimals
+        decimals: this.state.token.quantity?.decimals || '0'
       });
     } else if (
       this.state.receiverAddress &&
       this.state.sendTokenAmount &&
-      this.state.gasPrice &&
-      this.state.token?.quantity.decimals
+      this.state.token?.quantity?.decimals
     ) {
-      state.loading = true;
-      EventsController.sendEvent({
-        type: 'track',
-        event: 'SEND_INITIATED',
-        properties: {
-          isSmartAccount: AccountController.state.preferredAccountType === 'smartAccount',
-          token: this.state.token?.symbol,
-          amount: this.state.sendTokenAmount,
-          network: NetworkController.state.caipNetwork?.id || ''
-        }
-      });
-      this.sendNativeToken({
+      await this.sendNativeToken({
         receiverAddress: this.state.receiverAddress,
         sendTokenAmount: this.state.sendTokenAmount,
-        gasPrice: this.state.gasPrice,
         decimals: this.state.token.quantity.decimals
       });
     }
   },
 
   async sendNativeToken(params: TxParams) {
-    RouterController.pushTransactionStack({
-      view: 'Account',
-      goBack: false
-    });
-
     const to = params.receiverAddress as `0x${string}`;
-    const address = AccountController.state.address as `0x${string}`;
-    const value = ConnectionController.parseUnits(
+    const network = ConnectionsController.state.activeNetwork;
+    const address = CoreHelperUtil.getPlainAddress(
+      ConnectionsController.state.activeAddress
+    ) as `0x${string}`;
+    if (!address) {
+      throw new Error('Invalid address');
+    }
+
+    const value = ConnectionsController.parseUnits(
       params.sendTokenAmount.toString(),
       Number(params.decimals)
     );
     const data = '0x';
 
-    try {
-      await ConnectionController.sendTransaction({
-        to,
-        address,
-        data,
-        value,
-        gasPrice: params.gasPrice
-      });
-      SnackController.showSuccess('Transaction started');
-      EventsController.sendEvent({
-        type: 'track',
-        event: 'SEND_SUCCESS',
-        properties: {
-          isSmartAccount: AccountController.state.preferredAccountType === 'smartAccount',
-          token: this.state.token?.symbol || '',
-          amount: params.sendTokenAmount,
-          network: NetworkController.state.caipNetwork?.id || ''
-        }
-      });
-      this.resetSend();
-    } catch (error) {
-      state.loading = false;
-      EventsController.sendEvent({
-        type: 'track',
-        event: 'SEND_ERROR',
-        properties: {
-          isSmartAccount: AccountController.state.preferredAccountType === 'smartAccount',
-          token: this.state.token?.symbol || '',
-          amount: params.sendTokenAmount,
-          network: NetworkController.state.caipNetwork?.id || ''
-        }
-      });
-      SnackController.showError('Something went wrong');
-    }
+    await ConnectionsController.sendTransaction({
+      to,
+      address,
+      data,
+      value,
+      network
+    });
   },
 
   async sendERC20Token(params: ContractWriteParams) {
-    RouterController.pushTransactionStack({
-      view: 'Account',
-      goBack: false
-    });
-
-    const amount = ConnectionController.parseUnits(
+    const network = ConnectionsController.state.activeNetwork;
+    const amount = ConnectionsController.parseUnits(
       params.sendTokenAmount.toString(),
       Number(params.decimals)
     );
 
-    try {
-      if (
-        AccountController.state.address &&
-        params.sendTokenAmount &&
-        params.receiverAddress &&
-        params.tokenAddress
-      ) {
-        const tokenAddress = CoreHelperUtil.getPlainAddress(
-          params.tokenAddress as `${string}:${string}:${string}`
-        ) as `0x${string}`;
-        await ConnectionController.writeContract({
-          fromAddress: AccountController.state.address as `0x${string}`,
-          tokenAddress,
-          receiverAddress: params.receiverAddress as `0x${string}`,
-          tokenAmount: amount,
-          method: 'transfer',
-          abi: ContractUtil.getERC20Abi(tokenAddress)
-        });
-        SnackController.showSuccess('Transaction started');
-        this.resetSend();
+    if (
+      ConnectionsController.state.activeAddress &&
+      params.sendTokenAmount &&
+      params.receiverAddress &&
+      params.tokenAddress
+    ) {
+      const tokenAddress = CoreHelperUtil.getPlainAddress(
+        params.tokenAddress as `${string}:${string}:${string}`
+      ) as `0x${string}`;
+
+      const fromAddress = CoreHelperUtil.getPlainAddress(
+        ConnectionsController.state.activeAddress
+      ) as `0x${string}`;
+      if (!fromAddress) {
+        throw new Error('Invalid address');
       }
-    } catch (error) {
-      state.loading = false;
-      SnackController.showError('Something went wrong');
+
+      await ConnectionsController.writeContract({
+        fromAddress,
+        tokenAddress,
+        receiverAddress: params.receiverAddress as `0x${string}`,
+        tokenAmount: amount,
+        method: 'transfer',
+        abi: ContractUtil.getERC20Abi(tokenAddress),
+        network
+      });
+    }
+  },
+
+  async sendSolanaToken() {
+    if (!this.state.sendTokenAmount || !this.state.receiverAddress) {
+      throw new Error('An amount and receiver address are required');
+    }
+
+    const plainAddress = CoreHelperUtil.getPlainAddress(ConnectionsController.state.activeAddress);
+    if (!plainAddress) {
+      throw new Error('Invalid address');
     }
+
+    let tokenMint: string | undefined;
+
+    if (
+      SendController.state.token &&
+      SendController.state.token.address !== CoreConstantsUtil.NATIVE_TOKEN_ADDRESS.solana
+    ) {
+      if (CoreHelperUtil.isCaipAddress(SendController.state.token.address)) {
+        tokenMint = CoreHelperUtil.getPlainAddress(SendController.state.token.address);
+      } else {
+        tokenMint = SendController.state.token.address;
+      }
+    }
+
+    await ConnectionsController.sendTransaction({
+      tokenMint,
+      fromAddress: plainAddress,
+      toAddress: this.state.receiverAddress,
+      amount: this.state.sendTokenAmount,
+      network: ConnectionsController.state.activeNetwork
+    });
+  },
+
+  async fetchNetworkPrice() {
+    await SwapController.getNetworkTokenPrice();
   },
 
-  resetSend() {
+  resetState() {
     state.token = undefined;
     state.sendTokenAmount = undefined;
     state.receiverAddress = undefined;

package/src/controllers/SnackController.ts

@@ -22,26 +22,52 @@ const state = proxy<SnackControllerState>({
   long: false
 });
 
+// -- Private Variables --------------------------------- //
+let hideTimeout: NodeJS.Timeout | null = null;
+
+// -- Private Functions --------------------------------- //
+const clearHideTimeout = () => {
+  if (hideTimeout) {
+    clearTimeout(hideTimeout);
+    hideTimeout = null;
+  }
+};
+
+const scheduleAutoHide = (long: boolean) => {
+  clearHideTimeout();
+
+  const duration = long ? 15000 : 2200;
+  hideTimeout = setTimeout(() => {
+    SnackController.hide();
+  }, duration);
+};
+
 // -- Controller ---------------------------------------- //
 export const SnackController = {
   state,
 
-  showSuccess(message: SnackControllerState['message']) {
+  showSuccess(message: SnackControllerState['message'], long = false) {
     state.message = message;
     state.variant = 'success';
     state.open = true;
+    state.long = long;
+    scheduleAutoHide(long);
   },
 
-  showError(message: SnackControllerState['message']) {
+  showError(message: SnackControllerState['message'], long = false) {
     state.message = message;
     state.variant = 'error';
     state.open = true;
+    state.long = long;
+    scheduleAutoHide(long);
   },
 
-  showLoading(message: SnackControllerState['message']) {
+  showLoading(message: SnackControllerState['message'], long = false) {
     state.message = message;
     state.variant = 'loading';
     state.open = true;
+    state.long = long;
+    scheduleAutoHide(long);
   },
 
   showInternalError(error: Message) {
@@ -52,6 +78,7 @@ export const SnackController = {
       state.variant = 'error';
       state.open = true;
       state.long = true;
+      scheduleAutoHide(true);
     }
 
     if (error.longMessage) {
@@ -61,9 +88,8 @@ export const SnackController = {
   },
 
   hide() {
+    clearHideTimeout();
     state.open = false;
     state.long = false;
-    state.message = '';
-    state.variant = 'success';
   }
 };