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

package/src/controllers/OptionsController.ts

@@ -0,0 +1,143 @@
+import { proxy, ref } from 'valtio';
+import type {
+  Storage,
+  Metadata,
+  AppKitNetwork,
+  CustomWallet,
+  Features,
+  ProjectId,
+  SdkType,
+  SdkVersion,
+  SIWXConfig
+} from '@reown/appkit-common-react-native';
+
+import { ConstantsUtil } from '../utils/ConstantsUtil';
+
+// -- Types --------------------------------------------- //
+export interface ClipboardClient {
+  setString: (value: string) => Promise<void>;
+}
+
+export interface OptionsControllerState {
+  projectId: ProjectId;
+  clipboardClient?: ClipboardClient;
+  storage?: Storage;
+  includeWalletIds?: string[];
+  excludeWalletIds?: string[];
+  featuredWalletIds?: string[];
+  customWallets?: CustomWallet[];
+  enableAnalytics?: boolean;
+  sdkType: SdkType;
+  sdkVersion: SdkVersion;
+  metadata?: Metadata;
+  siwx?: SIWXConfig;
+  isOnRampEnabled?: boolean;
+  features?: Features;
+  debug?: boolean;
+  defaultNetwork?: AppKitNetwork;
+  requestedNetworks?: AppKitNetwork[];
+}
+
+// -- State --------------------------------------------- //
+const state = proxy<OptionsControllerState>({
+  projectId: '',
+  sdkType: 'appkit',
+  sdkVersion: 'react-native-undefined-undefined',
+  features: ConstantsUtil.DEFAULT_FEATURES,
+  customWallets: [],
+  debug: false
+});
+
+// -- Controller ---------------------------------------- //
+export const OptionsController = {
+  state,
+
+  setClipboardClient(client: ClipboardClient) {
+    state.clipboardClient = ref(client);
+  },
+
+  setProjectId(projectId: OptionsControllerState['projectId']) {
+    state.projectId = projectId;
+  },
+
+  setIncludeWalletIds(includeWalletIds: OptionsControllerState['includeWalletIds']) {
+    state.includeWalletIds = includeWalletIds;
+  },
+
+  setExcludeWalletIds(excludeWalletIds: OptionsControllerState['excludeWalletIds']) {
+    state.excludeWalletIds = excludeWalletIds;
+  },
+
+  setFeaturedWalletIds(featuredWalletIds: OptionsControllerState['featuredWalletIds']) {
+    state.featuredWalletIds = featuredWalletIds;
+  },
+
+  setCustomWallets(customWallets: OptionsControllerState['customWallets']) {
+    state.customWallets = customWallets;
+  },
+
+  setEnableAnalytics(enableAnalytics: OptionsControllerState['enableAnalytics']) {
+    state.enableAnalytics = enableAnalytics;
+  },
+
+  setSdkVersion(sdkVersion: OptionsControllerState['sdkVersion']) {
+    state.sdkVersion = sdkVersion;
+  },
+
+  setMetadata(metadata: OptionsControllerState['metadata']) {
+    state.metadata = metadata;
+  },
+
+  setFeatures(features: OptionsControllerState['features']) {
+    state.features = { ...ConstantsUtil.DEFAULT_FEATURES, ...features };
+  },
+
+  setDebug(debug: OptionsControllerState['debug']) {
+    state.debug = debug;
+  },
+
+  setIsOnRampEnabled(isOnRampEnabled: OptionsControllerState['isOnRampEnabled']) {
+    state.isOnRampEnabled = isOnRampEnabled;
+  },
+
+  setStorage(storage?: OptionsControllerState['storage']) {
+    if (storage) {
+      state.storage = ref(storage);
+    }
+  },
+
+  setDefaultNetwork(defaultNetwork?: OptionsControllerState['defaultNetwork']) {
+    state.defaultNetwork = defaultNetwork;
+  },
+
+  setRequestedNetworks(requestedNetworks?: OptionsControllerState['requestedNetworks']) {
+    state.requestedNetworks = requestedNetworks;
+  },
+
+  setSiwx(siwx?: OptionsControllerState['siwx']) {
+    if (siwx && (siwx?.signOutOnDisconnect === undefined || siwx?.signOutOnDisconnect === null)) {
+      siwx.signOutOnDisconnect = true;
+    }
+
+    state.siwx = siwx;
+  },
+
+  isClipboardAvailable() {
+    return !!state.clipboardClient;
+  },
+
+  getStorage() {
+    if (!state.storage) {
+      throw new Error('AppKit: Storage is not set');
+    }
+
+    return state.storage;
+  },
+
+  copyToClipboard(value: string) {
+    const client = state.clipboardClient;
+    if (client) {
+      client?.setString(value);
+    }
+  }
+};

package/src/controllers/PublicStateController.ts

@@ -0,0 +1,37 @@
+import { proxy, subscribe as sub } from 'valtio';
+import { subscribeKey as subKey } from 'valtio/utils';
+import type { CaipNetworkId } from '@reown/appkit-common-react-native';
+
+// -- Types --------------------------------------------- //
+export interface PublicStateControllerState {
+  open: boolean;
+  selectedNetworkId?: CaipNetworkId;
+}
+
+type StateKey = keyof PublicStateControllerState;
+
+// -- State --------------------------------------------- //
+const state = proxy<PublicStateControllerState>({
+  open: false,
+  selectedNetworkId: undefined
+});
+
+// -- Controller ---------------------------------------- //
+export const PublicStateController = {
+  state,
+
+  subscribe(callback: (newState: PublicStateControllerState) => void) {
+    return sub(state, () => callback(state));
+  },
+
+  subscribeKey<K extends StateKey>(
+    key: K,
+    callback: (value: PublicStateControllerState[K]) => void
+  ) {
+    return subKey(state, key, callback);
+  },
+
+  set(newState: Partial<PublicStateControllerState>) {
+    Object.assign(state, { ...state, ...newState });
+  }
+};

package/src/controllers/RouterController.ts

@@ -0,0 +1,112 @@
+import { proxy } from 'valtio';
+import type {
+  AppKitNetwork,
+  SocialProvider,
+  WcWallet,
+  OnRampTransactionResult
+} from '@reown/appkit-common-react-native';
+
+// -- Types --------------------------------------------- //
+export interface RouterControllerState {
+  view:
+    | 'Account'
+    | 'AccountDefault'
+    | 'AllWallets'
+    | 'Connect'
+    | 'ConnectSocials'
+    | 'ConnectingExternal'
+    | 'ConnectingSocial'
+    | 'GetWallet'
+    | 'Networks'
+    | 'OnRamp'
+    | 'OnRampCheckout'
+    | 'OnRampLoading'
+    | 'OnRampSettings'
+    | 'OnRampTransaction'
+    | 'SIWXSignMessage'
+    | 'Swap'
+    | 'SwapPreview'
+    | 'SwitchNetwork'
+    | 'Transactions'
+    | 'UnsupportedChain'
+    | 'UpgradeEmailWallet'
+    | 'WalletCompatibleNetworks'
+    | 'WalletConnect'
+    | 'WalletReceive'
+    | 'WalletSend'
+    | 'WalletSendPreview'
+    | 'WalletSendSelectToken'
+    | 'WhatIsANetwork'
+    | 'WhatIsAWallet';
+  history: RouterControllerState['view'][];
+  navigationDirection: 'forward' | 'backward' | 'none';
+  data?: {
+    wallet?: WcWallet;
+    network?: AppKitNetwork;
+    onrampResult?: OnRampTransactionResult;
+    socialProvider?: SocialProvider;
+  };
+}
+
+// -- State --------------------------------------------- //
+const state = proxy<RouterControllerState>({
+  view: 'Connect',
+  history: ['Connect'],
+  navigationDirection: 'none'
+});
+
+// -- Controller ---------------------------------------- //
+export const RouterController = {
+  state,
+
+  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;
+    }
+  },
+
+  reset(view: RouterControllerState['view'], data?: RouterControllerState['data']) {
+    state.navigationDirection = 'none';
+    state.view = view;
+    state.history = [view];
+    state.data = data;
+  },
+
+  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;
+    }
+  },
+
+  goBack() {
+    if (state.history.length > 1) {
+      state.history.pop();
+      const [last] = state.history.slice(-1);
+      if (last) {
+        state.navigationDirection = 'backward';
+        state.view = last;
+      }
+    }
+  },
+
+  goBackToIndex(historyIndex: number) {
+    if (state.history.length > 1) {
+      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

@@ -0,0 +1,270 @@
+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 { SnackController } from './SnackController';
+import { CoreHelperUtil } from '../utils/CoreHelperUtil';
+import { EventsController } from './EventsController';
+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;
+  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;
+  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;
+  },
+
+  setLoading(loading: SendControllerState['loading']) {
+    state.loading = loading;
+  },
+
+  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: 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
+      });
+      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 || '0'
+      });
+    } else if (
+      this.state.receiverAddress &&
+      this.state.sendTokenAmount &&
+      this.state.token?.quantity?.decimals
+    ) {
+      await this.sendNativeToken({
+        receiverAddress: this.state.receiverAddress,
+        sendTokenAmount: this.state.sendTokenAmount,
+        decimals: this.state.token.quantity.decimals
+      });
+    }
+  },
+
+  async sendNativeToken(params: TxParams) {
+    const to = params.receiverAddress as `0x${string}`;
+    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';
+
+    await ConnectionsController.sendTransaction({
+      to,
+      address,
+      data,
+      value,
+      network
+    });
+  },
+
+  async sendERC20Token(params: ContractWriteParams) {
+    const network = ConnectionsController.state.activeNetwork;
+    const amount = ConnectionsController.parseUnits(
+      params.sendTokenAmount.toString(),
+      Number(params.decimals)
+    );
+
+    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');
+      }
+
+      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();
+  },
+
+  resetState() {
+    state.token = undefined;
+    state.sendTokenAmount = undefined;
+    state.receiverAddress = undefined;
+    state.receiverProfileImageUrl = undefined;
+    state.receiverProfileName = undefined;
+    state.loading = false;
+  }
+};

package/src/controllers/SnackController.ts

@@ -0,0 +1,95 @@
+import { proxy } from 'valtio';
+import { OptionsController } from './OptionsController';
+
+// -- Types --------------------------------------------- //
+interface Message {
+  shortMessage: string;
+  longMessage?: string;
+}
+
+export interface SnackControllerState {
+  message: string;
+  variant: 'error' | 'success' | 'loading';
+  open: boolean;
+  long: boolean;
+}
+
+// -- State --------------------------------------------- //
+const state = proxy<SnackControllerState>({
+  message: '',
+  variant: 'success',
+  open: false,
+  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'], long = false) {
+    state.message = message;
+    state.variant = 'success';
+    state.open = true;
+    state.long = long;
+    scheduleAutoHide(long);
+  },
+
+  showError(message: SnackControllerState['message'], long = false) {
+    state.message = message;
+    state.variant = 'error';
+    state.open = true;
+    state.long = long;
+    scheduleAutoHide(long);
+  },
+
+  showLoading(message: SnackControllerState['message'], long = false) {
+    state.message = message;
+    state.variant = 'loading';
+    state.open = true;
+    state.long = long;
+    scheduleAutoHide(long);
+  },
+
+  showInternalError(error: Message) {
+    const { debug } = OptionsController.state;
+
+    if (debug) {
+      state.message = error.shortMessage;
+      state.variant = 'error';
+      state.open = true;
+      state.long = true;
+      scheduleAutoHide(true);
+    }
+
+    if (error.longMessage) {
+      // eslint-disable-next-line no-console
+      console.error(error.longMessage);
+    }
+  },
+
+  hide() {
+    clearHideTimeout();
+    state.open = false;
+    state.long = false;
+  }
+};