@reown/appkit-core-react-native 0.0.0-fix-email-login-20241010173711 → 0.0.0-fix-token-balance-20241017200828

package/src/controllers/RouterController.ts

@@ -2,25 +2,41 @@ import { proxy } from 'valtio';
 import type { WcWallet, CaipNetwork, Connector } from '../utils/TypeUtil';
 
 // -- Types --------------------------------------------- //
+type TransactionAction = {
+  goBack: boolean;
+  view: RouterControllerState['view'] | null;
+  close?: boolean;
+  replace?: boolean;
+  onSuccess?: () => void;
+  onCancel?: () => void;
+};
+
 export interface RouterControllerState {
   view:
     | 'Account'
+    | 'AccountDefault'
+    | 'AllWallets'
     | 'Connect'
-    | 'ConnectingWalletConnect'
     | 'ConnectingExternal'
-    | 'Networks'
-    | 'SwitchNetwork'
-    | 'AllWallets'
-    | 'WhatIsAWallet'
-    | 'WhatIsANetwork'
-    | 'GetWallet'
+    | 'ConnectingSiwe'
+    | 'ConnectingWalletConnect'
     | 'EmailVerifyDevice'
     | 'EmailVerifyOtp'
-    | 'UpdateEmailWallet'
+    | 'GetWallet'
+    | 'Networks'
+    | 'SwitchNetwork'
+    | 'Transactions'
     | 'UpdateEmailPrimaryOtp'
     | 'UpdateEmailSecondaryOtp'
+    | 'UpdateEmailWallet'
     | 'UpgradeEmailWallet'
-    | 'ConnectingSiwe';
+    | 'WalletCompatibleNetworks'
+    | 'WalletReceive'
+    | 'WalletSend'
+    | 'WalletSendPreview'
+    | 'WalletSendSelectToken'
+    | 'WhatIsANetwork'
+    | 'WhatIsAWallet';
   history: RouterControllerState['view'][];
   data?: {
     connector?: Connector;
@@ -29,12 +45,14 @@ export interface RouterControllerState {
     email?: string;
     newEmail?: string;
   };
+  transactionStack: TransactionAction[];
 }
 
 // -- State --------------------------------------------- //
 const state = proxy<RouterControllerState>({
   view: 'Connect',
-  history: ['Connect']
+  history: ['Connect'],
+  transactionStack: []
 });
 
 // -- Controller ---------------------------------------- //
@@ -49,6 +67,30 @@ export const RouterController = {
     }
   },
 
+  pushTransactionStack(action: TransactionAction) {
+    state.transactionStack.push(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']) {
     state.view = view;
     state.history = [view];

package/src/controllers/SendController.ts

@@ -0,0 +1,234 @@
+import { subscribeKey as subKey } from 'valtio/vanilla/utils';
+import { proxy, ref, subscribe as sub } from 'valtio/vanilla';
+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';
+
+// -- Types --------------------------------------------- //
+export interface TxParams {
+  receiverAddress: string;
+  sendTokenAmount: number;
+  gasPrice: bigint;
+  decimals: string;
+}
+
+export interface ContractWriteParams {
+  receiverAddress: string;
+  tokenAddress: string;
+  sendTokenAmount: number;
+  decimals: string;
+}
+
+export interface SendControllerState {
+  token?: Balance;
+  sendTokenAmount?: number;
+  receiverAddress?: string;
+  receiverProfileName?: string;
+  receiverProfileImageUrl?: string;
+  gasPrice?: bigint;
+  gasPriceInUSD?: number;
+  loading: boolean;
+}
+
+type StateKey = keyof SendControllerState;
+
+// -- State --------------------------------------------- //
+const state = proxy<SendControllerState>({
+  loading: false
+});
+
+// -- Controller ---------------------------------------- //
+export const SendController = {
+  state,
+
+  subscribe(callback: (newState: SendControllerState) => void) {
+    return sub(state, () => callback(state));
+  },
+
+  subscribeKey<K extends StateKey>(key: K, callback: (value: SendControllerState[K]) => void) {
+    return subKey(state, key, callback);
+  },
+
+  setToken(token: SendControllerState['token']) {
+    if (token) {
+      state.token = ref(token);
+    }
+  },
+
+  setTokenAmount(sendTokenAmount: SendControllerState['sendTokenAmount']) {
+    state.sendTokenAmount = sendTokenAmount;
+  },
+
+  setReceiverAddress(receiverAddress: SendControllerState['receiverAddress']) {
+    state.receiverAddress = receiverAddress;
+  },
+
+  setReceiverProfileImageUrl(
+    receiverProfileImageUrl: SendControllerState['receiverProfileImageUrl']
+  ) {
+    state.receiverProfileImageUrl = receiverProfileImageUrl;
+  },
+
+  setReceiverProfileName(receiverProfileName: SendControllerState['receiverProfileName']) {
+    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;
+      EventsController.sendEvent({
+        type: 'track',
+        event: 'SEND_INITIATED',
+        properties: {
+          isSmartAccount: false,
+          token: this.state.token.address,
+          amount: this.state.sendTokenAmount,
+          network: NetworkController.state.caipNetwork?.id || ''
+        }
+      });
+      this.sendERC20Token({
+        receiverAddress: this.state.receiverAddress,
+        tokenAddress: this.state.token.address,
+        sendTokenAmount: this.state.sendTokenAmount,
+        decimals: this.state.token.quantity.decimals
+      });
+    } else if (
+      this.state.receiverAddress &&
+      this.state.sendTokenAmount &&
+      this.state.gasPrice &&
+      this.state.token?.quantity.decimals
+    ) {
+      state.loading = true;
+      EventsController.sendEvent({
+        type: 'track',
+        event: 'SEND_INITIATED',
+        properties: {
+          isSmartAccount: false,
+          token: this.state.token?.symbol,
+          amount: this.state.sendTokenAmount,
+          network: NetworkController.state.caipNetwork?.id || ''
+        }
+      });
+      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(
+      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: false,
+          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: false,
+          token: this.state.token?.symbol || '',
+          amount: params.sendTokenAmount,
+          network: NetworkController.state.caipNetwork?.id || ''
+        }
+      });
+      SnackController.showError('Something went wrong');
+    }
+  },
+
+  async sendERC20Token(params: ContractWriteParams) {
+    RouterController.pushTransactionStack({
+      view: 'Account',
+      goBack: false
+    });
+
+    const amount = ConnectionController.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();
+      }
+    } catch (error) {
+      state.loading = false;
+      SnackController.showError('Something went wrong');
+    }
+  },
+
+  resetSend() {
+    state.token = undefined;
+    state.sendTokenAmount = undefined;
+    state.receiverAddress = undefined;
+    state.receiverProfileImageUrl = undefined;
+    state.receiverProfileName = undefined;
+    state.loading = false;
+  }
+};

package/src/controllers/SwapController.ts

@@ -0,0 +1,108 @@
+import { subscribeKey as subKey } from 'valtio/utils';
+import { proxy, subscribe as sub } from 'valtio';
+
+import { ConstantsUtil } from '../utils/ConstantsUtil';
+import { SwapApiUtil } from '../utils/SwapApiUtil';
+import { NetworkController } from './NetworkController';
+import { BlockchainApiController } from './BlockchainApiController';
+import { OptionsController } from './OptionsController';
+import { SwapCalculationUtil } from '../utils/SwapCalculationUtil';
+
+// -- Constants ---------------------------------------- //
+export const INITIAL_GAS_LIMIT = 150000;
+export const TO_AMOUNT_DECIMALS = 6;
+
+// -- Types --------------------------------------------- //
+
+export interface SwapControllerState {
+  // Input values
+  networkPrice: string;
+  networkTokenSymbol: string;
+
+  // Tokens
+  tokensPriceMap: Record<string, number>;
+
+  // Calculations
+  gasFee: string;
+  gasPriceInUSD?: number;
+}
+
+type StateKey = keyof SwapControllerState;
+
+// -- State --------------------------------------------- //
+const initialState: SwapControllerState = {
+  // Input values
+  networkPrice: '0',
+  networkTokenSymbol: '',
+
+  // Tokens
+  tokensPriceMap: {},
+
+  // Calculations
+  gasFee: '0',
+  gasPriceInUSD: 0
+};
+
+const state = proxy<SwapControllerState>(initialState);
+
+// -- Controller ---------------------------------------- //
+export const SwapController = {
+  state,
+
+  subscribe(callback: (newState: SwapControllerState) => void) {
+    return sub(state, () => callback(state));
+  },
+
+  subscribeKey<K extends StateKey>(key: K, callback: (value: SwapControllerState[K]) => void) {
+    return subKey(state, key, callback);
+  },
+
+  getParams() {
+    const caipNetwork = NetworkController.state.caipNetwork;
+    const networkAddress = `${caipNetwork?.id}:${ConstantsUtil.NATIVE_TOKEN_ADDRESS}`;
+
+    return {
+      networkAddress
+    };
+  },
+
+  resetState() {
+    state.tokensPriceMap = initialState.tokensPriceMap;
+    state.networkPrice = initialState.networkPrice;
+    state.networkTokenSymbol = initialState.networkTokenSymbol;
+  },
+
+  //this
+  async getNetworkTokenPrice() {
+    const { networkAddress } = this.getParams();
+
+    const response = await BlockchainApiController.fetchTokenPrice({
+      projectId: OptionsController.state.projectId,
+      addresses: [networkAddress]
+    });
+    const token = response?.fungibles?.[0];
+    const price = token?.price.toString() || '0';
+    state.tokensPriceMap[networkAddress] = parseFloat(price);
+    state.networkTokenSymbol = token?.symbol || '';
+    state.networkPrice = price;
+  },
+
+  //this
+  async getInitialGasPrice() {
+    const res = await SwapApiUtil.fetchGasPrice();
+
+    if (!res) {
+      return { gasPrice: null, gasPriceInUsd: null };
+    }
+
+    const value = res.standard;
+    const gasFee = BigInt(value);
+    const gasLimit = BigInt(INITIAL_GAS_LIMIT);
+    const gasPrice = SwapCalculationUtil.getGasPriceInUSD(state.networkPrice, gasLimit, gasFee);
+
+    state.gasFee = value;
+    state.gasPriceInUSD = gasPrice;
+
+    return { gasPrice: gasFee, gasPriceInUSD: state.gasPriceInUSD };
+  }
+};

package/src/controllers/TransactionsController.ts

@@ -0,0 +1,141 @@
+import type { Transaction } from '@reown/appkit-common-react-native';
+import { proxy, subscribe as sub } from 'valtio/vanilla';
+import { OptionsController } from './OptionsController';
+import { EventsController } from './EventsController';
+import { SnackController } from './SnackController';
+import { NetworkController } from './NetworkController';
+import { BlockchainApiController } from './BlockchainApiController';
+
+// -- Types --------------------------------------------- //
+type TransactionByMonthMap = Record<string, Transaction[]>;
+type TransactionByYearMap = Record<string, TransactionByMonthMap>;
+
+export interface TransactionsControllerState {
+  transactions: Transaction[];
+  loading: boolean;
+  empty: boolean;
+  next: string | undefined;
+}
+
+// -- State --------------------------------------------- //
+const state = proxy<TransactionsControllerState>({
+  transactions: [],
+  loading: false,
+  empty: false,
+  next: undefined
+});
+
+// -- Controller ---------------------------------------- //
+export const TransactionsController = {
+  state,
+
+  subscribe(callback: (newState: TransactionsControllerState) => void) {
+    return sub(state, () => callback(state));
+  },
+
+  async fetchTransactions(accountAddress?: string, reset?: boolean) {
+    const { projectId } = OptionsController.state;
+
+    if (!projectId || !accountAddress) {
+      throw new Error("Transactions can't be fetched without a projectId and an accountAddress");
+    }
+
+    state.loading = true;
+
+    if (reset) {
+      state.next = undefined;
+    }
+
+    try {
+      const response = await BlockchainApiController.fetchTransactions({
+        account: accountAddress,
+        projectId,
+        cursor: state.next
+      });
+
+      const nonSpamTransactions = this.filterSpamTransactions(response?.data ?? []);
+      let filteredTransactions = [...state.transactions, ...nonSpamTransactions];
+
+      if (reset) {
+        filteredTransactions = nonSpamTransactions;
+      }
+
+      state.loading = false;
+
+      state.transactions = filteredTransactions;
+
+      state.empty = nonSpamTransactions.length === 0;
+      state.next = response?.next ? response.next : undefined;
+    } catch (error) {
+      EventsController.sendEvent({
+        type: 'track',
+        event: 'ERROR_FETCH_TRANSACTIONS',
+        properties: {
+          address: accountAddress,
+          projectId,
+          cursor: state.next,
+          isSmartAccount: false
+        }
+      });
+      SnackController.showError('Failed to fetch transactions');
+      state.loading = false;
+      state.empty = true;
+      state.next = undefined;
+    }
+  },
+
+  getTransactionsByYearAndMonth(transactions: Transaction[]) {
+    const grouped: TransactionByYearMap = {};
+    let filteredTransactions = this.filterByConnectedChain(transactions);
+
+    filteredTransactions.forEach(transaction => {
+      const year = new Date(transaction.metadata.minedAt).getFullYear();
+      const month = new Date(transaction.metadata.minedAt).getMonth();
+
+      const yearTransactions = grouped[year] ?? {};
+      const monthTransactions = yearTransactions[month] ?? [];
+
+      // If there's a transaction with the same id, remove the old one
+      const newMonthTransactions = monthTransactions.filter(tx => tx.id !== transaction.id);
+
+      grouped[year] = {
+        ...yearTransactions,
+        [month]: [...newMonthTransactions, transaction].sort(
+          (a, b) => new Date(b.metadata.minedAt).getTime() - new Date(a.metadata.minedAt).getTime()
+        )
+      };
+    });
+
+    return grouped;
+  },
+
+  filterSpamTransactions(transactions: Transaction[]) {
+    return transactions.filter(transaction => {
+      const isAllSpam = transaction.transfers.every(
+        transfer => transfer.nft_info?.flags.is_spam === true
+      );
+
+      return !isAllSpam;
+    });
+  },
+
+  filterByConnectedChain(transactions: Transaction[]) {
+    const chainId = NetworkController.state.caipNetwork?.id;
+    const filteredTransactions = transactions.filter(
+      transaction => transaction.metadata.chain === chainId
+    );
+
+    return filteredTransactions;
+  },
+
+  clearCursor() {
+    state.next = undefined;
+  },
+
+  resetTransactions() {
+    state.transactions = [];
+    state.loading = false;
+    state.empty = false;
+    state.next = undefined;
+  }
+};

package/src/index.ts

@@ -1,52 +1,63 @@
 // -- Controllers -------------------------------------------------------------
-export { ModalController } from './controllers/ModalController';
-export type { ModalControllerArguments, ModalControllerState } from './controllers/ModalController';
+export {
+  ModalController,
+  type ModalControllerArguments,
+  type ModalControllerState
+} from './controllers/ModalController';
 
-export { RouterController } from './controllers/RouterController';
-export type { RouterControllerState } from './controllers/RouterController';
+export { RouterController, type RouterControllerState } from './controllers/RouterController';
 
-export { AccountController } from './controllers/AccountController';
-export type { AccountControllerState } from './controllers/AccountController';
+export { AccountController, type AccountControllerState } from './controllers/AccountController';
 
-export { NetworkController } from './controllers/NetworkController';
-export type {
-  NetworkControllerClient,
-  NetworkControllerState
+export {
+  NetworkController,
+  type NetworkControllerClient,
+  type NetworkControllerState
 } from './controllers/NetworkController';
 
-export { ConnectionController } from './controllers/ConnectionController';
-export type {
-  ConnectionControllerClient,
-  ConnectionControllerState
+export {
+  ConnectionController,
+  type ConnectionControllerClient,
+  type ConnectionControllerState
 } from './controllers/ConnectionController';
 
-export { ConnectorController } from './controllers/ConnectorController';
-export type { ConnectorControllerState } from './controllers/ConnectorController';
+export {
+  ConnectorController,
+  type ConnectorControllerState
+} from './controllers/ConnectorController';
 
-export { SnackController } from './controllers/SnackController';
-export type { SnackControllerState } from './controllers/SnackController';
+export { SnackController, type SnackControllerState } from './controllers/SnackController';
 
-export { ApiController } from './controllers/ApiController';
-export type { ApiControllerState } from './controllers/ApiController';
+export { ApiController, type ApiControllerState } from './controllers/ApiController';
 
-export { AssetController } from './controllers/AssetController';
-export type { AssetControllerState } from './controllers/AssetController';
+export { AssetController, type AssetControllerState } from './controllers/AssetController';
 
-export { ThemeController } from './controllers/ThemeController';
-export type { ThemeControllerState } from './controllers/ThemeController';
+export { ThemeController, type ThemeControllerState } from './controllers/ThemeController';
 
-export { OptionsController } from './controllers/OptionsController';
-export type { OptionsControllerState } from './controllers/OptionsController';
+export { OptionsController, type OptionsControllerState } from './controllers/OptionsController';
 
-export { PublicStateController } from './controllers/PublicStateController';
-export type { PublicStateControllerState } from './controllers/PublicStateController';
+export {
+  PublicStateController,
+  type PublicStateControllerState
+} from './controllers/PublicStateController';
 
 export { BlockchainApiController } from './controllers/BlockchainApiController';
 
-export { EventsController } from './controllers/EventsController';
-export type { EventsControllerState } from './controllers/EventsController';
+export { SwapController, type SwapControllerState } from './controllers/SwapController';
+
+export { EventsController, type EventsControllerState } from './controllers/EventsController';
+
+export { EnsController, type EnsControllerState } from './controllers/EnsController';
+
+export {
+  TransactionsController,
+  type TransactionsControllerState
+} from './controllers/TransactionsController';
+
+export { SendController, type SendControllerState } from './controllers/SendController';
 
 // -- Utils -------------------------------------------------------------------
+export { ApiUtil } from './utils/ApiUtil';
 export { AssetUtil } from './utils/AssetUtil';
 export { ConstantsUtil } from './utils/ConstantsUtil';
 export { CoreHelperUtil } from './utils/CoreHelperUtil';

package/src/utils/ApiUtil.ts

@@ -0,0 +1,18 @@
+import { Platform } from 'react-native';
+import { CoreHelperUtil } from './CoreHelperUtil';
+
+export const ApiUtil = {
+  getOrigin() {
+    return CoreHelperUtil.getBundleId();
+  },
+
+  getUserAgent() {
+    const reactNativeVersion = [
+      Platform.constants.reactNativeVersion.major,
+      Platform.constants.reactNativeVersion.minor,
+      Platform.constants.reactNativeVersion.patch
+    ].join('.');
+
+    return `${Platform.OS}-${Platform.Version}@rn-${reactNativeVersion}`;
+  }
+};