@reown/appkit-react-native 0.0.0-chore-spring-effect-20250909214820 → 0.0.0-chore-added-import-20251002170458

package/src/partials/w3m-all-wallets-list/components/WalletList.tsx

@@ -18,12 +18,13 @@ const ITEM_HEIGHT_WITH_GAP = ITEM_HEIGHT + Spacing['3xs'];
 
 interface Props {
   data: WcWallet[];
-  onItemPress: (wallet: WcWallet) => void;
+  onItemPress: (wallet: WcWallet, displayIndex: number) => void;
   onEndReached?: () => void;
   onEndReachedThreshold?: number;
   isLoading?: boolean;
   loadingItems?: number;
   style?: StyleProp<ViewStyle>;
+  testIDKey?: string;
 }
 
 export function WalletList({
@@ -33,6 +34,7 @@ export function WalletList({
   onEndReachedThreshold,
   isLoading = false,
   loadingItems = 20,
+  testIDKey,
   style
 }: Props) {
   const { padding, maxHeight } = useCustomDimensions();
@@ -50,7 +52,7 @@ export function WalletList({
       data={displayData}
       style={[styles.list, { height: maxHeight }, style]}
       columnWrapperStyle={styles.columnWrapperStyle}
-      renderItem={({ item }) => {
+      renderItem={({ item, index }) => {
         if (isLoading) {
           return <CardSelectLoader style={styles.itemContainer} />;
         }
@@ -59,12 +61,17 @@ export function WalletList({
           <WalletItem
             item={item}
             imageHeaders={imageHeaders}
+            displayIndex={index}
             onItemPress={onItemPress}
             style={styles.itemContainer}
+            testID={testIDKey ? `${testIDKey}-${item?.id}` : undefined}
           />
         );
       }}
       contentContainerStyle={[styles.contentContainer, { paddingHorizontal: padding }]}
+      initialNumToRender={32}
+      maxToRenderPerBatch={12}
+      windowSize={10}
       onEndReached={onEndReached}
       onEndReachedThreshold={onEndReachedThreshold}
       keyExtractor={(item, index) => item?.id ?? `item-${index}`}

package/src/partials/w3m-all-wallets-list/index.tsx

@@ -2,6 +2,7 @@ import { useEffect, useState } from 'react';
 import { useSnapshot } from 'valtio';
 import {
   ApiController,
+  LogController,
   OptionsController,
   SnackController,
   type OptionsControllerState
@@ -14,7 +15,7 @@ import { Loading } from './components/Loading';
 import { WalletList } from './components/WalletList';
 
 interface AllWalletsListProps {
-  onItemPress: (wallet: WcWallet) => void;
+  onItemPress: (wallet: WcWallet, displayIndex: number) => void;
   headerHeight?: number;
 }
 
@@ -61,6 +62,7 @@ export function AllWalletsList({ onItemPress }: AllWalletsListProps) {
       await ApiController.fetchWallets({ page: 1 });
       setLoading(false);
     } catch (error) {
+      LogController.sendError(error, 'AllWalletsList.tsx', 'initialFetch');
       SnackController.showError('Failed to load wallets');
       setLoading(false);
       setLoadingError(true);

package/src/partials/w3m-all-wallets-search/index.tsx

@@ -1,6 +1,11 @@
 import { useSnapshot } from 'valtio';
 import { useCallback, useEffect, useState } from 'react';
-import { ApiController, OptionsController, SnackController } from '@reown/appkit-core-react-native';
+import {
+  ApiController,
+  LogController,
+  OptionsController,
+  SnackController
+} from '@reown/appkit-core-react-native';
 import { type WcWallet } from '@reown/appkit-common-react-native';
 import { useCustomDimensions } from '@reown/appkit-ui-react-native';
 import { Placeholder } from '../w3m-placeholder';
@@ -10,7 +15,7 @@ import { Loading } from '../w3m-all-wallets-list/components/Loading';
 import { WalletList } from '../w3m-all-wallets-list/components/WalletList';
 
 export interface AllWalletsSearchProps {
-  onItemPress: (wallet: WcWallet) => void;
+  onItemPress: (wallet: WcWallet, displayIndex: number) => void;
   searchQuery?: string;
 }
 
@@ -36,6 +41,7 @@ export function AllWalletsSearch({ searchQuery, onItemPress }: AllWalletsSearchP
       await ApiController.searchWallet({ search: searchQuery });
       setLoading(false);
     } catch (error) {
+      LogController.sendError(error, 'AllWalletsSearch.tsx', 'searchFetch');
       SnackController.showError('Failed to load wallets');
       setLoading(false);
       setLoadingError(true);
@@ -78,5 +84,5 @@ export function AllWalletsSearch({ searchQuery, onItemPress }: AllWalletsSearchP
     );
   }
 
-  return <WalletList onItemPress={onItemPress} data={results} />;
+  return <WalletList onItemPress={onItemPress} data={results} testIDKey="wallet-search-item" />;
 }

package/src/partials/w3m-connecting-mobile/index.tsx

@@ -10,7 +10,9 @@ import {
   OptionsController,
   EventsController,
   ConstantsUtil,
-  AssetController
+  AssetController,
+  LogController,
+  ConnectionsController
 } from '@reown/appkit-core-react-native';
 import {
   Button,
@@ -60,6 +62,21 @@ export function ConnectingMobile({ onRetry, onCopyUri, isInstalled }: Props) {
   const onStorePress = () => {
     if (storeUrl) {
       CoreHelperUtil.openLink(storeUrl);
+      EventsController.sendEvent({
+        type: 'track',
+        event: 'GET_WALLET',
+        properties: {
+          name: data?.wallet?.name ?? 'Unknown',
+          link: storeUrl,
+          linkType: Platform.select({
+            ios: 'appstore',
+            android: 'playstore',
+            default: undefined
+          }),
+          explorerId: data?.wallet?.id,
+          walletRank: data?.wallet?.order
+        }
+      });
     }
   };
 
@@ -74,17 +91,22 @@ export function ConnectingMobile({ onRetry, onCopyUri, isInstalled }: Props) {
         await CoreHelperUtil.openLink(redirect);
         await WcController.state.wcPromise;
         WcController.setConnectedWallet(wcLinking, data?.wallet);
+        const address = ConnectionsController.state.activeAddress;
+        const caipNetworkId = ConnectionsController.state.activeNetwork?.caipNetworkId;
         EventsController.sendEvent({
           type: 'track',
           event: 'CONNECT_SUCCESS',
+          address: CoreHelperUtil.getPlainAddress(address),
           properties: {
             method: 'mobile',
             name: data?.wallet?.name ?? 'Unknown',
-            explorer_id: data?.wallet?.id
+            explorerId: data?.wallet?.id,
+            caipNetworkId
           }
         });
       }
     } catch (error: any) {
+      LogController.sendError(error, 'ConnectingMobile.tsx', 'onConnect');
       if (error.message.includes(ConstantsUtil.LINKING_ERROR)) {
         setErrorType('not_installed');
       } else {

package/src/partials/w3m-connecting-qrcode/index.tsx

@@ -4,7 +4,9 @@ import {
   WcController,
   EventsController,
   OptionsController,
-  SnackController
+  SnackController,
+  ConnectionsController,
+  CoreHelperUtil
 } from '@reown/appkit-core-react-native';
 import {
   FlexView,
@@ -35,13 +37,17 @@ export function ConnectingQrCode() {
 
   const onConnect = async () => {
     await WcController.state.wcPromise;
+    const address = ConnectionsController.state.activeAddress;
+    const caipNetworkId = ConnectionsController.state.activeNetwork?.caipNetworkId;
 
     EventsController.sendEvent({
       type: 'track',
       event: 'CONNECT_SUCCESS',
+      address: CoreHelperUtil.getPlainAddress(address),
       properties: {
         method: 'qrcode',
-        name: 'WalletConnect'
+        name: 'WalletConnect',
+        caipNetworkId
       }
     });
   };

package/src/partials/w3m-connecting-web/index.tsx

@@ -9,7 +9,9 @@ import {
   CoreHelperUtil,
   OptionsController,
   EventsController,
-  AssetController
+  AssetController,
+  LogController,
+  ConnectionsController
 } from '@reown/appkit-core-react-native';
 import {
   Button,
@@ -50,18 +52,24 @@ export function ConnectingWeb({ onCopyUri }: ConnectingWebProps) {
         await Linking.openURL(redirect);
         await WcController.state.wcPromise;
         WcController.setConnectedWallet(wcLinking, data?.wallet);
+        const address = ConnectionsController.state.activeAddress;
+        const caipNetworkId = ConnectionsController.state.activeNetwork?.caipNetworkId;
 
         EventsController.sendEvent({
           type: 'track',
           event: 'CONNECT_SUCCESS',
+          address: CoreHelperUtil.getPlainAddress(address),
           properties: {
             method: 'web',
             name: data?.wallet?.name ?? 'Unknown',
-            explorer_id: data?.wallet?.id
+            explorerId: data?.wallet?.id,
+            caipNetworkId
           }
         });
       }
-    } catch {}
+    } catch (error) {
+      LogController.sendError(error, 'ConnectingWeb.tsx', 'onConnect');
+    }
   }, [data?.wallet, wcUri]);
 
   return (

package/src/partials/w3m-header/index.tsx

@@ -32,9 +32,9 @@ export function Header() {
       Connect: 'Connect wallet',
       ConnectSocials: 'All socials',
       ConnectingExternal: walletName ?? 'Connect wallet',
-      ConnectingSiwe: 'Sign in',
+      SIWXSignMessage: 'Sign in',
       ConnectingSocial: socialName ?? 'Connecting Social',
-      ConnectingWalletConnect: walletName ?? 'WalletConnect',
+      WalletConnect: walletName ?? 'WalletConnect',
       GetWallet: 'Get a wallet',
       Networks: 'Select network',
       OnRamp: undefined,
@@ -58,8 +58,8 @@ export function Header() {
     }[_view];
   };
 
-  const noCloseViews = ['OnRampSettings', 'ConnectingSiwe'];
-  const noBackViews = ['UnsupportedChain'];
+  const noCloseViews = ['OnRampSettings', 'SIWXSignMessage'];
+  const noBackViews = ['UnsupportedChain', 'SIWXSignMessage'];
   const showClose = !noCloseViews.includes(view);
   const header = headings(data, view);
 

package/src/types.ts

@@ -7,10 +7,10 @@ import {
   type Metadata,
   type Network,
   type Storage,
-  type AppKitSIWEClient,
   type ThemeMode,
   type ThemeVariables,
-  type Tokens
+  type Tokens,
+  type SIWXConfig
 } from '@reown/appkit-common-react-native';
 
 /**
@@ -129,6 +129,7 @@ export interface AppKitConfig {
   /**
    * Optional flag to enable debug mode.
    * When enabled, additional logging and debugging information will be output.
+   * Only enabled in development mode.
    *
    * @see {@link https://docs.reown.com/appkit/react-native/core/options#debug | Debug Documentation}
    * @default false
@@ -154,13 +155,11 @@ export interface AppKitConfig {
   themeVariables?: ThemeVariables;
 
   /**
-   * Optional SIWE (Sign-In with Ethereum) configuration.
-   * Enables authentication flow using Ethereum signatures.
-   * Must implement the AppKitSIWEClient interface.
-   *
-   * @see {@link https://docs.reown.com/appkit/react-native/core/siwe | SIWE Documentation}
+   * @experimental - This feature is not production ready.
+   * Enable Sign In With X (SIWX) feature.
+   * @default undefined
    */
-  siweConfig?: AppKitSIWEClient;
+  siwx?: SIWXConfig;
 
   /**
    * Optional default network to use when no specific network is selected.

package/src/utils/SIWXUtil.ts

@@ -0,0 +1,359 @@
+import UniversalProvider from '@walletconnect/universal-provider';
+
+import {
+  type CaipNetworkId,
+  type ChainNamespace,
+  type SIWXSession
+} from '@reown/appkit-common-react-native';
+
+import {
+  ModalController,
+  OptionsController,
+  RouterController,
+  SnackController,
+  CoreHelperUtil,
+  ConnectionsController,
+  EventsController,
+  LogController
+} from '@reown/appkit-core-react-native';
+
+/**
+ * SIWXUtil holds the methods to interact with the SIWX plugin and must be called internally on AppKit.
+ */
+
+export const SIWXUtil = {
+  getSIWX() {
+    return OptionsController.state.siwx;
+  },
+
+  async initializeIfEnabled({
+    onDisconnect,
+    caipAddress = ConnectionsController.state.activeAddress,
+    closeModal = false
+  }: {
+    onDisconnect: () => Promise<void>;
+    caipAddress?: string;
+    closeModal?: boolean;
+  }) {
+    const siwx = OptionsController.state.siwx;
+
+    if (!siwx || !caipAddress) {
+      if (closeModal) {
+        ModalController.close();
+      }
+
+      return;
+    }
+
+    const [namespace, chainId, address] = caipAddress.split(':') as [
+      ChainNamespace,
+      string,
+      string
+    ];
+
+    const isSupportedNetwork = ConnectionsController.getAvailableNetworks().find(
+      network => network.caipNetworkId === `${namespace}:${chainId}`
+    );
+
+    if (!isSupportedNetwork) {
+      return;
+    }
+
+    try {
+      const sessions = await siwx.getSessions(`${namespace}:${chainId}`, address);
+
+      if (sessions.length) {
+        ModalController.close();
+
+        return;
+      }
+
+      if (ModalController.state.open) {
+        RouterController.push('SIWXSignMessage');
+      } else {
+        ModalController.open({ view: 'SIWXSignMessage' });
+      }
+    } catch (error: unknown) {
+      LogController.sendError(error, 'SIWXUtil.ts', 'initializeIfEnabled');
+
+      EventsController.sendEvent({
+        type: 'track',
+        event: 'SIWX_AUTH_ERROR',
+        properties: this.getSIWXEventProperties(error)
+      });
+
+      await onDisconnect();
+      SnackController.showError('A problem occurred while trying initialize authentication');
+    }
+  },
+  async requestSignMessage() {
+    EventsController.sendEvent({
+      type: 'track',
+      event: 'CLICK_SIGN_SIWX_MESSAGE',
+      properties: this.getSIWXEventProperties()
+    });
+
+    const siwx = OptionsController.state.siwx;
+
+    const address = ConnectionsController.state.activeAddress;
+    const plainAddress = CoreHelperUtil.getPlainAddress(address);
+    const network = ConnectionsController.state.activeNetwork;
+
+    if (!siwx) {
+      throw new Error('SIWX is not enabled');
+    }
+
+    if (!address || !plainAddress) {
+      throw new Error('No ActiveCaipAddress found');
+    }
+
+    if (!network) {
+      throw new Error('No ActiveCaipNetwork or client found');
+    }
+
+    try {
+      const siwxMessage = await siwx.createMessage({
+        chainId: network.caipNetworkId,
+        accountAddress: plainAddress
+      });
+
+      const message = siwxMessage.toString();
+
+      const signature = await ConnectionsController.signMessage(address, message);
+
+      if (!signature) {
+        throw new Error('Error signing message');
+      }
+
+      SnackController.showLoading('Authenticating...', true);
+
+      // Add a small delay to allow the app to fully restore network connectivity
+      // after returning from background (wallet redirect)
+      await new Promise(resolve => setTimeout(resolve, 500));
+
+      await siwx.addSession({
+        data: siwxMessage,
+        message,
+        signature
+      });
+
+      SnackController.hide();
+
+      ModalController.close();
+
+      EventsController.sendEvent({
+        type: 'track',
+        event: 'SIWX_AUTH_SUCCESS',
+        properties: this.getSIWXEventProperties()
+      });
+    } catch (error) {
+      if (!ModalController.state.open) {
+        await ModalController.open({
+          view: 'SIWXSignMessage'
+        });
+      }
+      SnackController.hide();
+      SnackController.showError('Error signing message');
+      EventsController.sendEvent({
+        type: 'track',
+        event: 'SIWX_AUTH_ERROR',
+        properties: this.getSIWXEventProperties(error)
+      });
+
+      // eslint-disable-next-line no-console
+      console.error('SIWXUtil:requestSignMessage', error);
+    }
+  },
+  async cancelSignMessage(onDisconnect: () => Promise<void>) {
+    try {
+      const siwx = this.getSIWX();
+      const isRequired = siwx?.getRequired?.();
+      if (isRequired) {
+        await onDisconnect();
+      } else {
+        ModalController.close();
+      }
+
+      EventsController.sendEvent({
+        event: 'CLICK_CANCEL_SIWX',
+        type: 'track',
+        properties: this.getSIWXEventProperties()
+      });
+    } catch (error) {
+      // eslint-disable-next-line no-console
+      console.error('SIWXUtil:cancelSignMessage', error);
+    }
+  },
+  async getAllSessions() {
+    const siwx = this.getSIWX();
+    const allRequestedCaipNetworks = ConnectionsController.state.networks;
+    const sessions = [] as SIWXSession[];
+    await Promise.all(
+      allRequestedCaipNetworks.map(async caipNetwork => {
+        const session = await siwx?.getSessions(
+          caipNetwork.caipNetworkId,
+          CoreHelperUtil.getPlainAddress(ConnectionsController.state.activeAddress) || ''
+        );
+        if (session) {
+          sessions.push(...session);
+        }
+      })
+    );
+
+    return sessions;
+  },
+  async getSessions(args?: { address?: string; caipNetworkId?: CaipNetworkId }) {
+    const siwx = OptionsController.state.siwx;
+    let address = args?.address;
+    if (!address) {
+      const activeCaipAddress = ConnectionsController.state.activeAddress;
+      address = CoreHelperUtil.getPlainAddress(activeCaipAddress);
+    }
+
+    let network = args?.caipNetworkId;
+    if (!network) {
+      const activeCaipNetwork = ConnectionsController.state.activeNetwork;
+      network = activeCaipNetwork?.caipNetworkId;
+    }
+
+    if (!siwx || !address || !network) {
+      return [];
+    }
+
+    return siwx.getSessions(network, address);
+  },
+  async isSIWXCloseDisabled() {
+    const siwx = this.getSIWX();
+
+    if (siwx) {
+      const isSiwxSignMessage = RouterController.state.view === 'SIWXSignMessage';
+
+      if (isSiwxSignMessage) {
+        return siwx.getRequired?.() && (await this.getSessions()).length === 0;
+      }
+    }
+
+    return false;
+  },
+
+  async universalProviderAuthenticate({
+    universalProvider,
+    chains,
+    methods,
+    universalLink
+  }: {
+    universalProvider: UniversalProvider;
+    chains: CaipNetworkId[];
+    methods: string[];
+    universalLink?: string;
+  }) {
+    const siwx = SIWXUtil.getSIWX();
+    const namespaces = new Set(chains.map(chain => chain.split(':')[0] as ChainNamespace));
+
+    if (!siwx || namespaces.size !== 1 || !namespaces.has('eip155')) {
+      return undefined;
+    }
+
+    // Ignores chainId and account address to get other message data
+    const siwxMessage = await siwx.createMessage({
+      chainId: OptionsController.state.defaultNetwork?.caipNetworkId || ('' as CaipNetworkId),
+      accountAddress: ''
+    });
+
+    let messageChains = chains;
+
+    if (OptionsController.state.defaultNetwork?.caipNetworkId) {
+      // The first chainId is what is used for universal provider to build the message
+      messageChains = [
+        OptionsController.state.defaultNetwork?.caipNetworkId,
+        ...chains.filter(chain => chain !== OptionsController.state.defaultNetwork?.caipNetworkId)
+      ];
+    }
+
+    const result = await universalProvider.authenticate(
+      {
+        nonce: siwxMessage.nonce,
+        domain: siwxMessage.domain,
+        uri: siwxMessage.uri,
+        exp: siwxMessage.expirationTime,
+        iat: siwxMessage.issuedAt,
+        nbf: siwxMessage.notBefore,
+        requestId: siwxMessage.requestId,
+        version: siwxMessage.version,
+        resources: siwxMessage.resources,
+        statement: siwxMessage.statement,
+        chainId: siwxMessage.chainId,
+        methods,
+        chains: messageChains
+      },
+      universalLink
+    );
+
+    if (result?.auths?.length) {
+      const sessions = result.auths.map<SIWXSession>(cacao => {
+        const message = universalProvider.client.formatAuthMessage({
+          request: cacao.p,
+          iss: cacao.p.iss
+        });
+
+        return {
+          data: {
+            ...cacao.p,
+            accountAddress: cacao.p.iss.split(':').slice(-1).join(''),
+            chainId: cacao.p.iss.split(':').slice(2, 4).join(':') as CaipNetworkId,
+            uri: cacao.p.aud,
+            version: cacao.p.version || siwxMessage.version,
+            expirationTime: cacao.p.exp,
+            issuedAt: cacao.p.iat,
+            notBefore: cacao.p.nbf
+          },
+          message,
+          signature: cacao.s.s,
+          cacao
+        };
+      });
+
+      try {
+        SnackController.showLoading('Authenticating...', true);
+        await siwx.setSessions(sessions);
+
+        EventsController.sendEvent({
+          type: 'track',
+          event: 'SIWX_AUTH_SUCCESS',
+          properties: SIWXUtil.getSIWXEventProperties()
+        });
+      } catch (error) {
+        // eslint-disable-next-line no-console
+        console.error('SIWX:universalProviderAuth - failed to set sessions', error);
+
+        EventsController.sendEvent({
+          type: 'track',
+          event: 'SIWX_AUTH_ERROR',
+          properties: SIWXUtil.getSIWXEventProperties(error)
+        });
+
+        // eslint-disable-next-line no-console
+        await universalProvider.disconnect().catch(console.error);
+        throw error;
+      } finally {
+        SnackController.hide();
+      }
+    }
+
+    return result?.session;
+  },
+  getSIWXEventProperties(error?: unknown) {
+    return {
+      network: ConnectionsController.state.activeNetwork?.caipNetworkId,
+      isSmartAccount: ConnectionsController.state.accountType === 'smartAccount',
+      message: error ? CoreHelperUtil.parseError(error) : undefined
+    };
+  },
+  async clearSessions() {
+    const siwx = this.getSIWX();
+
+    if (siwx) {
+      await siwx.setSessions([]);
+    }
+  }
+};

package/src/views/w3m-account-default-view/index.tsx

@@ -14,7 +14,8 @@ import {
   OnRampController,
   ConnectionsController,
   AssetController,
-  AssetUtil
+  AssetUtil,
+  LogController
 } from '@reown/appkit-core-react-native';
 // import { ConstantsUtil as CommonConstantsUtil } from '@reown/appkit-common-react-native';
 import {
@@ -94,6 +95,7 @@ export function AccountDefaultView() {
         switchAccountType(namespace, newType, network);
       }
     } catch (error) {
+      LogController.sendError(error, 'AccountDefaultView.tsx', 'onSwitchAccountType');
       SnackController.showError('Error switching account type');
     }
   };
@@ -120,7 +122,7 @@ export function AccountDefaultView() {
       type: 'track',
       event: 'OPEN_SWAP',
       properties: {
-        network: ConnectionsController.state.activeNetwork?.caipNetworkId || '',
+        network: ConnectionsController.state.activeNetwork?.caipNetworkId,
         isSmartAccount: false
       }
     });
@@ -156,7 +158,7 @@ export function AccountDefaultView() {
   };
 
   const onSendPress = () => {
-    const network = ConnectionsController.state.activeNetwork?.caipNetworkId || '';
+    const network = ConnectionsController.state.activeNetwork?.caipNetworkId;
     const isSmartAccount = ConnectionsController.state.accountType === 'smartAccount';
 
     EventsController.sendEvent({