@reown/appkit-core-react-native 1.0.1 → 1.1.0

package/src/controllers/TransactionsController.ts

@@ -0,0 +1,142 @@
+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';
+import { AccountController } from './AccountController';
+
+// -- 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: AccountController.state.preferredAccountType === 'smartAccount'
+        }
+      });
+      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

@@ -0,0 +1,63 @@
+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;
+  processingAuth?: boolean;
+}
+
+// -- State --------------------------------------------- //
+const state = proxy<WebviewControllerState>({
+  frameViewVisible: false,
+  webviewVisible: false,
+  connecting: false,
+  connectingProvider: undefined,
+  processingAuth: false
+});
+
+// -- 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;
+  },
+
+  setProcessingAuth(processingAuth: WebviewControllerState['processingAuth']) {
+    state.processingAuth = processingAuth;
+  },
+
+  reset() {
+    state.frameViewVisible = false;
+    state.webviewVisible = false;
+    state.connecting = false;
+    state.connectingProvider = undefined;
+    state.processingAuth = false;
+    state.webviewUrl = undefined;
+  }
+};

package/src/index.ts

@@ -1,52 +1,65 @@
 // -- 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';
+
+export { WebviewController, type WebviewControllerState } from './controllers/WebviewController';
 
 // -- 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,26 @@
+import { Platform } from 'react-native';
+import { CoreHelperUtil } from './CoreHelperUtil';
+
+export const ApiUtil = {
+  getOrigin() {
+    return CoreHelperUtil.getBundleId();
+  },
+
+  getReactNativeVersion() {
+    return [
+      Platform.constants?.reactNativeVersion?.major,
+      Platform.constants?.reactNativeVersion?.minor,
+      Platform.constants?.reactNativeVersion?.patch
+    ].join('.');
+  },
+
+  getUserAgent() {
+    const rnVersion = Platform.select({
+      ios: this.getReactNativeVersion(),
+      android: this.getReactNativeVersion(),
+      default: 'undefined'
+    });
+
+    return `${Platform.OS}-${Platform.Version}@rn-${rnVersion}`;
+  }
+};

package/src/utils/ConstantsUtil.ts

@@ -1,3 +1,11 @@
+import type { Features } from './TypeUtil';
+
+const defaultFeatures: Features = {
+  email: true,
+  emailShowWallets: true,
+  socials: ['x', 'discord', 'apple']
+};
+
 export const ConstantsUtil = {
   FOUR_MINUTES_MS: 240000,
 
@@ -7,5 +15,9 @@ export const ConstantsUtil = {
 
   EMAIL_REGEX: /^[a-zA-Z0-9.!#$%&’*+/=?^_`{|}~-]+@[a-zA-Z0-9-]+(?:\.[a-zA-Z0-9-]+)+$/,
 
-  LINKING_ERROR: 'LINKING_ERROR'
+  LINKING_ERROR: 'LINKING_ERROR',
+
+  NATIVE_TOKEN_ADDRESS: '0xeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee',
+
+  DEFAULT_FEATURES: defaultFeatures
 };

package/src/utils/CoreHelperUtil.ts

@@ -1,7 +1,7 @@
 /* eslint-disable no-bitwise */
 
 import { Linking, Platform } from 'react-native';
-import { ConstantsUtil as CommonConstants } from '@reown/appkit-common-react-native';
+import { ConstantsUtil as CommonConstants, type Balance } from '@reown/appkit-common-react-native';
 
 import { ConstantsUtil } from './ConstantsUtil';
 import type { CaipAddress, DataWallet, LinkingRecord } from './TypeUtil';
@@ -157,6 +157,27 @@ export const CoreHelperUtil = {
     return formattedBalance ? `${formattedBalance} ${symbol}` : `0.000 ${symbol || ''}`;
   },
 
+  isAddress(address: string, chain = 'eip155'): boolean {
+    switch (chain) {
+      case 'eip155':
+        if (!/^(?:0x)?[0-9a-f]{40}$/iu.test(address)) {
+          return false;
+        } else if (
+          /^(?:0x)?[0-9a-f]{40}$/iu.test(address) ||
+          /^(?:0x)?[0-9A-F]{40}$/iu.test(address)
+        ) {
+          return true;
+        }
+
+        return false;
+      case 'solana':
+        return /[1-9A-HJ-NP-Za-km-z]{32,44}$/iu.test(address);
+
+      default:
+        return false;
+    }
+  },
+
   getApiUrl() {
     return CommonConstants.API_URL;
   },
@@ -245,5 +266,21 @@ export const CoreHelperUtil = {
           .catch(reason => ({ status: 'rejected', reason }))
       )
     );
+  },
+
+  calculateAndFormatBalance(array?: Balance[]) {
+    if (!array?.length) {
+      return { dollars: '0', pennies: '00' };
+    }
+
+    let sum = 0;
+    for (const item of array) {
+      sum += item.value ?? 0;
+    }
+
+    const roundedNumber = sum.toFixed(2);
+    const [dollars, pennies] = roundedNumber.split('.');
+
+    return { dollars, pennies };
   }
 };

package/src/utils/FetchUtil.ts

@@ -1,3 +1,5 @@
+import type { RequestCache } from './TypeUtil';
+
 // -- Types ----------------------------------------------------------------------
 interface Options {
   baseUrl: string;
@@ -8,6 +10,8 @@ interface RequestArguments {
   path: string;
   headers?: HeadersInit_;
   params?: Record<string, string | undefined>;
+  cache?: RequestCache;
+  signal?: AbortSignal;
 }
 
 interface PostArguments extends RequestArguments {

package/src/utils/StorageUtil.ts

@@ -1,12 +1,14 @@
 /* eslint-disable no-console */
 import AsyncStorage from '@react-native-async-storage/async-storage';
 import type { ConnectorType, WcWallet } from './TypeUtil';
+import type { SocialProvider } 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_CONNECTOR = '@w3m/connected_connector';
+const CONNECTED_SOCIAL = '@appkit/connected_social';
 
 // -- Utility -----------------------------------------------------------------
 export const StorageUtil = {
@@ -90,7 +92,7 @@ export const StorageUtil = {
     }
   },
 
-  async getConnectedConnector() {
+  async getConnectedConnector(): Promise<ConnectorType | undefined> {
     try {
       const connector = (await AsyncStorage.getItem(CONNECTED_CONNECTOR)) as ConnectorType;
 
@@ -134,5 +136,33 @@ export const StorageUtil = {
     } catch {
       console.info('Unable to remove Connected Wallet Image URL');
     }
+  },
+
+  async setConnectedSocialProvider(provider: SocialProvider) {
+    try {
+      await AsyncStorage.setItem(CONNECTED_SOCIAL, JSON.stringify(provider));
+    } catch {
+      console.info('Unable to set Connected Social Provider');
+    }
+  },
+
+  async getConnectedSocialProvider() {
+    try {
+      const provider = (await AsyncStorage.getItem(CONNECTED_SOCIAL)) as SocialProvider;
+
+      return provider ? JSON.parse(provider) : undefined;
+    } catch {
+      console.info('Unable to get Connected Social Provider');
+    }
+
+    return undefined;
+  },
+
+  async removeConnectedSocialProvider() {
+    try {
+      await AsyncStorage.removeItem(CONNECTED_SOCIAL);
+    } catch {
+      console.info('Unable to remove Connected Social Provider');
+    }
   }
 };

package/src/utils/SwapApiUtil.ts

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

@@ -0,0 +1,21 @@
+// -- 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();
+  }
+};