@reown/appkit-core-react-native 0.0.0-accounts-canary.1-20251023174733

package/src/controllers/ThemeController.ts

@@ -0,0 +1,47 @@
+import { Appearance } from 'react-native';
+import { proxy, subscribe as sub } from 'valtio';
+import type { ThemeMode, ThemeVariables } from '@reown/appkit-common-react-native';
+
+// -- Types --------------------------------------------- //
+export interface ThemeControllerState {
+  themeMode?: ThemeMode;
+  defaultThemeMode?: ThemeMode;
+  themeVariables?: ThemeVariables;
+}
+
+// -- State --------------------------------------------- //
+const state = proxy<ThemeControllerState>({
+  themeMode: undefined,
+  defaultThemeMode: undefined,
+  themeVariables: {}
+});
+
+// -- Controller ---------------------------------------- //
+export const ThemeController = {
+  state,
+
+  subscribe(callback: (newState: ThemeControllerState) => void) {
+    return sub(state, () => callback(state));
+  },
+
+  setThemeMode(themeMode: ThemeControllerState['themeMode']) {
+    if (!themeMode) {
+      state.themeMode = Appearance.getColorScheme() as ThemeMode;
+    } else {
+      state.themeMode = themeMode;
+    }
+  },
+
+  setDefaultThemeMode(themeMode: ThemeControllerState['defaultThemeMode']) {
+    state.defaultThemeMode = themeMode;
+    this.setThemeMode(themeMode);
+  },
+
+  setThemeVariables(themeVariables: ThemeControllerState['themeVariables']) {
+    if (!themeVariables) {
+      state.themeVariables = {};
+    }
+
+    state.themeVariables = { ...state.themeVariables, ...themeVariables };
+  }
+};

package/src/controllers/TransactionsController.ts

@@ -0,0 +1,150 @@
+import type { CaipAddress, Transaction } from '@reown/appkit-common-react-native';
+import { proxy, subscribe as sub } from 'valtio';
+import { OptionsController } from './OptionsController';
+import { EventsController } from './EventsController';
+import { SnackController } from './SnackController';
+import { BlockchainApiController } from './BlockchainApiController';
+import { ConnectionsController } from './ConnectionsController';
+import { LogController } from './LogController';
+
+// -- 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: CaipAddress, reset?: boolean) {
+    try {
+      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;
+      }
+
+      const [namespace, chain, address] = accountAddress?.split(':') ?? [];
+
+      if (!namespace || !chain || !address) {
+        throw new Error('Invalid address');
+      }
+
+      const response = await BlockchainApiController.fetchTransactions({
+        account: address,
+        chainId: `${namespace}:${chain}`,
+        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) {
+      LogController.sendError(error, 'TransactionsController.ts', 'fetchTransactions');
+      EventsController.sendEvent({
+        type: 'track',
+        event: 'ERROR_FETCH_TRANSACTIONS',
+        properties: {
+          address: accountAddress ?? '',
+          projectId: OptionsController.state.projectId,
+          cursor: state.next,
+          isSmartAccount: ConnectionsController.state.accountType === '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 = ConnectionsController.state.activeCaipNetworkId;
+    const filteredTransactions = transactions.filter(
+      transaction => transaction.metadata.chain === chainId
+    );
+
+    return filteredTransactions;
+  },
+
+  clearCursor() {
+    state.next = undefined;
+  },
+
+  resetState() {
+    state.transactions = [];
+    state.loading = false;
+    state.empty = false;
+    state.next = undefined;
+  }
+};

package/src/controllers/WcController.ts

@@ -0,0 +1,93 @@
+import { proxy } from 'valtio';
+import { subscribeKey as subKey } from 'valtio/utils';
+import type { WalletDeepLink, WcWallet } from '@reown/appkit-common-react-native';
+import { CoreHelperUtil } from '../utils/CoreHelperUtil';
+import { StorageUtil } from '../utils/StorageUtil';
+
+// -- Types --------------------------------------------- //
+export interface WcControllerState {
+  wcUri?: string;
+  wcPromise?: Promise<void>;
+  wcPairingExpiry?: number;
+  wcLinking?: WalletDeepLink;
+  wcError?: boolean;
+  pressedWallet?: WcWallet;
+  recentWallets?: WcWallet[];
+}
+
+type StateKey = keyof WcControllerState;
+
+// -- State --------------------------------------------- //
+const state = proxy<WcControllerState>({
+  wcError: false
+});
+
+// -- Controller ---------------------------------------- //
+export const WcController = {
+  state,
+
+  subscribeKey<K extends StateKey>(key: K, callback: (value: WcControllerState[K]) => void) {
+    return subKey(state, key, callback);
+  },
+
+  setWcLinking(wcLinking: WcControllerState['wcLinking']) {
+    state.wcLinking = wcLinking;
+  },
+
+  removeWcLinking() {
+    state.wcLinking = undefined;
+  },
+
+  setWcError(wcError: WcControllerState['wcError']) {
+    state.wcError = wcError;
+  },
+
+  setPressedWallet(wallet: WcControllerState['pressedWallet']) {
+    state.pressedWallet = wallet;
+  },
+
+  removePressedWallet() {
+    state.pressedWallet = undefined;
+  },
+
+  setWcPromise(wcPromise: WcControllerState['wcPromise']) {
+    state.wcPromise = wcPromise;
+  },
+
+  setWcUri(wcUri: WcControllerState['wcUri']) {
+    state.wcUri = wcUri;
+    state.wcPairingExpiry = CoreHelperUtil.getPairingExpiry();
+  },
+
+  setRecentWallets(wallets: WcControllerState['recentWallets']) {
+    state.recentWallets = wallets;
+  },
+
+  async addRecentWallet(wallet: WcWallet) {
+    const recentWallets = await StorageUtil.addRecentWallet(wallet);
+    if (recentWallets) {
+      WcController.setRecentWallets(recentWallets);
+    }
+  },
+
+  setConnectedWallet: async (wcLinking: WalletDeepLink, pressedWallet?: WcWallet) => {
+    StorageUtil.setWalletConnectDeepLink(wcLinking);
+
+    if (pressedWallet) {
+      WcController.addRecentWallet(pressedWallet);
+    }
+  },
+
+  clearUri() {
+    state.wcUri = undefined;
+    state.wcPairingExpiry = undefined;
+    state.wcPromise = undefined;
+    state.wcLinking = undefined;
+  },
+
+  resetState() {
+    this.clearUri();
+    state.pressedWallet = undefined;
+    StorageUtil.removeWalletConnectDeepLink();
+  }
+};