@reown/appkit-core-react-native 0.0.0-refactor-modal-migration-20241004184043 → 1.0.1

package/src/controllers/SendController.ts

@@ -1,234 +0,0 @@
-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

@@ -1,108 +0,0 @@
-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

@@ -1,141 +0,0 @@
-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/controllers/WebviewController.ts

@@ -1,48 +0,0 @@
-import type { SocialProvider } from '@reown/appkit-common-react-native';
-import { proxy, subscribe as sub } from 'valtio';
-
-// -- Types --------------------------------------------- //
-export interface WebviewControllerState {
-  frameViewVisible: boolean;
-  webviewVisible: boolean;
-  webviewUrl?: string;
-  connecting?: boolean;
-  connectingProvider?: SocialProvider;
-}
-
-// -- State --------------------------------------------- //
-const state = proxy<WebviewControllerState>({
-  frameViewVisible: false,
-  webviewVisible: false,
-  connecting: false,
-  connectingProvider: undefined
-});
-
-// -- Controller ---------------------------------------- //
-export const WebviewController = {
-  state,
-
-  subscribe(callback: (newState: WebviewControllerState) => void) {
-    return sub(state, () => callback(state));
-  },
-
-  setFrameViewVisible(frameViewVisible: WebviewControllerState['frameViewVisible']) {
-    state.frameViewVisible = frameViewVisible;
-  },
-
-  setWebviewVisible(visible: WebviewControllerState['webviewVisible']) {
-    state.webviewVisible = visible;
-  },
-
-  setWebviewUrl(url: WebviewControllerState['webviewUrl']) {
-    state.webviewUrl = url;
-  },
-
-  setConnecting(connecting: WebviewControllerState['connecting']) {
-    state.connecting = connecting;
-  },
-
-  setConnectingProvider(provider: WebviewControllerState['connectingProvider']) {
-    state.connectingProvider = provider;
-  }
-};

package/src/utils/ApiUtil.ts

@@ -1,18 +0,0 @@
-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}`;
-  }
-};

package/src/utils/SwapApiUtil.ts

@@ -1,19 +0,0 @@
-import { BlockchainApiController } from '../controllers/BlockchainApiController';
-import { OptionsController } from '../controllers/OptionsController';
-import { NetworkController } from '../controllers/NetworkController';
-
-export const SwapApiUtil = {
-  async fetchGasPrice() {
-    const projectId = OptionsController.state.projectId;
-    const caipNetwork = NetworkController.state.caipNetwork;
-
-    if (!caipNetwork) {
-      return null;
-    }
-
-    return await BlockchainApiController.fetchGasPrice({
-      projectId,
-      chainId: caipNetwork.id
-    });
-  }
-};

package/src/utils/SwapCalculationUtil.ts

@@ -1,21 +0,0 @@
-// -- Types --------------------------------------------- //
-
-import { NumberUtil } from '@reown/appkit-common-react-native';
-
-// -- Util ---------------------------------------- //
-export const SwapCalculationUtil = {
-  getGasPriceInEther(gas: bigint, gasPrice: bigint) {
-    const totalGasCostInWei = gasPrice * gas;
-    const totalGasCostInEther = Number(totalGasCostInWei) / 1e18;
-
-    return totalGasCostInEther;
-  },
-
-  getGasPriceInUSD(networkPrice: string, gas: bigint, gasPrice: bigint) {
-    const totalGasCostInEther = SwapCalculationUtil.getGasPriceInEther(gas, gasPrice);
-    const networkPriceInUSD = NumberUtil.bigNumber(networkPrice);
-    const gasCostInUSD = networkPriceInUSD.multipliedBy(totalGasCostInEther);
-
-    return gasCostInUSD.toNumber();
-  }
-};