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

package/src/utils/HelpersUtil.ts

@@ -0,0 +1,242 @@
+import type { Namespace, NamespaceConfig } from '@walletconnect/universal-provider';
+import {
+  type AppKitNetwork,
+  type CaipNetworkId,
+  type ChainNamespace,
+  ConstantsUtil,
+  type UniversalProviderConfigOverride,
+  type WcWallet,
+  solana,
+  solanaDevnet
+} from '@reown/appkit-common-react-native';
+
+export const DEFAULT_METHODS = {
+  solana: [
+    'solana_signMessage',
+    'solana_signTransaction',
+    'solana_requestAccounts',
+    'solana_getAccounts',
+    'solana_signAllTransactions',
+    'solana_signAndSendTransaction'
+  ],
+  eip155: [
+    'eth_accounts',
+    'eth_requestAccounts',
+    'eth_sendRawTransaction',
+    'eth_sign',
+    'eth_signTransaction',
+    'eth_signTypedData',
+    'eth_signTypedData_v3',
+    'eth_signTypedData_v4',
+    'eth_sendTransaction',
+    'personal_sign',
+    'wallet_switchEthereumChain',
+    'wallet_addEthereumChain',
+    'wallet_getPermissions',
+    'wallet_requestPermissions',
+    'wallet_registerOnboarding',
+    'wallet_watchAsset',
+    'wallet_scanQRCode',
+    // EIP-5792
+    'wallet_getCallsStatus',
+    'wallet_showCallsStatus',
+    'wallet_sendCalls',
+    'wallet_getCapabilities',
+    // EIP-7715
+    'wallet_grantPermissions',
+    'wallet_revokePermissions',
+    //EIP-7811
+    'wallet_getAssets'
+  ],
+  bip122: ['sendTransfer', 'signMessage', 'signPsbt', 'getAccountAddresses']
+};
+
+export const WcHelpersUtil = {
+  getMethodsByChainNamespace(chainNamespace: ChainNamespace): string[] {
+    return DEFAULT_METHODS[chainNamespace as keyof typeof DEFAULT_METHODS] || [];
+  },
+
+  createDefaultNamespace(chainNamespace: ChainNamespace): Namespace {
+    return {
+      methods: this.getMethodsByChainNamespace(chainNamespace),
+      events: ['accountsChanged', 'chainChanged'],
+      chains: [],
+      rpcMap: {}
+    };
+  },
+
+  applyNamespaceOverrides(
+    baseNamespaces: NamespaceConfig,
+    overrides?: UniversalProviderConfigOverride
+  ): NamespaceConfig {
+    if (!overrides) {
+      return { ...baseNamespaces };
+    }
+
+    const result = { ...baseNamespaces };
+
+    const namespacesToOverride = new Set<string>();
+
+    if (overrides.methods) {
+      Object.keys(overrides.methods).forEach(ns => namespacesToOverride.add(ns));
+    }
+
+    if (overrides.chains) {
+      Object.keys(overrides.chains).forEach(ns => namespacesToOverride.add(ns));
+    }
+
+    if (overrides.events) {
+      Object.keys(overrides.events).forEach(ns => namespacesToOverride.add(ns));
+    }
+
+    if (overrides.rpcMap) {
+      Object.keys(overrides.rpcMap).forEach(chainId => {
+        const [ns] = chainId.split(':');
+        if (ns) {
+          namespacesToOverride.add(ns);
+        }
+      });
+    }
+
+    namespacesToOverride.forEach(ns => {
+      if (!result[ns]) {
+        result[ns] = this.createDefaultNamespace(ns as ChainNamespace);
+      }
+    });
+
+    if (overrides.methods) {
+      Object.entries(overrides.methods).forEach(([ns, methods]) => {
+        if (result[ns]) {
+          //@ts-ignore
+          result[ns].methods = methods;
+        }
+      });
+    }
+
+    if (overrides.chains) {
+      Object.entries(overrides.chains).forEach(([ns, chains]) => {
+        if (result[ns]) {
+          //@ts-ignore
+          result[ns].chains = chains;
+        }
+      });
+    }
+
+    if (overrides.events) {
+      Object.entries(overrides.events).forEach(([ns, events]) => {
+        if (result[ns]) {
+          //@ts-ignore
+          result[ns].events = events;
+        }
+      });
+    }
+
+    if (overrides.rpcMap) {
+      const processedNamespaces = new Set<string>();
+
+      Object.entries(overrides.rpcMap).forEach(([chainId, rpcUrl]) => {
+        const [ns, id] = chainId.split(':');
+        if (!ns || !id || !result[ns]) {
+          return;
+        }
+
+        //@ts-ignore
+        if (!result[ns].rpcMap) {
+          //@ts-ignore
+          result[ns].rpcMap = {};
+        }
+
+        //@ts-ignore
+        if (!processedNamespaces.has(ns)) {
+          //@ts-ignore
+          result[ns].rpcMap = {};
+          processedNamespaces.add(ns);
+        }
+
+        //@ts-ignore
+        result[ns].rpcMap[id] = rpcUrl;
+      });
+    }
+
+    return result;
+  },
+
+  createNamespaces(
+    caipNetworks: AppKitNetwork[],
+    configOverride?: UniversalProviderConfigOverride
+  ): NamespaceConfig {
+    const defaultNamespaces = caipNetworks.reduce<NamespaceConfig>((acc, chain) => {
+      const { id, rpcUrls } = chain;
+      const chainNamespace = chain.chainNamespace || 'eip155';
+      const rpcUrl = rpcUrls.default.http[0];
+
+      if (!acc[chainNamespace]) {
+        acc[chainNamespace] = this.createDefaultNamespace(chainNamespace);
+      }
+
+      const caipNetworkId: CaipNetworkId = `${chainNamespace}:${id}`;
+
+      const namespace = acc[chainNamespace];
+
+      if (namespace) {
+        //@ts-ignore
+        namespace.chains.push(caipNetworkId);
+
+        // Workaround for wallets that only support deprecated Solana network ID
+        switch (caipNetworkId) {
+          case solana.caipNetworkId:
+            namespace.chains.push(solana.deprecatedCaipNetworkId as string);
+            break;
+          case solanaDevnet.caipNetworkId:
+            namespace.chains.push(solanaDevnet.deprecatedCaipNetworkId as string);
+            break;
+          default:
+        }
+
+        if (namespace?.rpcMap && rpcUrl) {
+          namespace.rpcMap[id] = rpcUrl;
+        }
+      }
+
+      return acc;
+    }, {});
+
+    return this.applyNamespaceOverrides(defaultNamespaces, configOverride);
+  },
+
+  isExternalWallet(wallet?: WcWallet) {
+    if (!wallet) {
+      return false;
+    }
+
+    return (
+      wallet.id === ConstantsUtil.PHANTOM_CUSTOM_WALLET.id ||
+      wallet.id === ConstantsUtil.SOLFLARE_CUSTOM_WALLET.id ||
+      wallet.id === ConstantsUtil.COINBASE_CUSTOM_WALLET.id
+    );
+  },
+
+  getConnectorTypeByWallet(wallet?: WcWallet) {
+    if (!wallet) {
+      return 'walletconnect';
+    }
+
+    if (wallet.id === ConstantsUtil.PHANTOM_CUSTOM_WALLET.id) {
+      return 'phantom';
+    } else if (wallet.id === ConstantsUtil.COINBASE_CUSTOM_WALLET.id) {
+      return 'coinbase';
+    } else if (wallet.id === ConstantsUtil.SOLFLARE_CUSTOM_WALLET.id) {
+      return 'solflare';
+    } else {
+      return 'walletconnect';
+    }
+  }
+};
+
+export namespace WcHelpersUtil {
+  export type SessionEventData = {
+    id: string;
+    topic: string;
+    params: { chainId: string; event: { data: unknown; name: string } };
+  };
+}

package/src/utils/NetworkUtil.ts

@@ -0,0 +1,60 @@
+import {
+  type AppKitNetwork,
+  type CaipNetworkId,
+  type CaipNamespaces,
+  ConstantsUtil,
+  type Network
+} from '@reown/appkit-common-react-native';
+
+export const NetworkUtil = {
+  formatNetwork(network: Network, projectId: string): AppKitNetwork {
+    const formattedNetwork = {
+      ...network,
+      rpcUrls: { ...network.rpcUrls },
+      chainNamespace: network.chainNamespace ?? 'eip155',
+      caipNetworkId: network.caipNetworkId ?? `${network.chainNamespace ?? 'eip155'}:${network.id}`
+    };
+
+    Object.keys(formattedNetwork.rpcUrls).forEach(key => {
+      const rpcConfig = formattedNetwork.rpcUrls[key];
+      if (rpcConfig?.http?.some(url => url.includes(ConstantsUtil.BLOCKCHAIN_API_RPC_URL))) {
+        formattedNetwork.rpcUrls[key] = {
+          ...rpcConfig,
+          http: [this.getBlockchainApiRpcUrl(formattedNetwork.caipNetworkId, projectId)]
+        };
+      }
+    });
+
+    return formattedNetwork;
+  },
+
+  formatNetworks(networks: Network[], projectId: string): AppKitNetwork[] {
+    const formattedNetworks = networks.map(network => this.formatNetwork(network, projectId));
+
+    return formattedNetworks;
+  },
+
+  getBlockchainApiRpcUrl(caipNetworkId: CaipNetworkId, projectId: string) {
+    const url = new URL(`${ConstantsUtil.BLOCKCHAIN_API_RPC_URL}/v1/`);
+    url.searchParams.set('chainId', caipNetworkId);
+    url.searchParams.set('projectId', projectId);
+
+    return url.toString();
+  },
+
+  getDefaultNetwork(
+    namespaces: CaipNamespaces,
+    defaultNetwork?: AppKitNetwork
+  ): AppKitNetwork | undefined {
+    if (!defaultNetwork) return undefined;
+
+    const isValidDefaultNetwork = Object.values(namespaces).some(
+      namespace => namespace?.chains?.some(chain => chain === defaultNetwork.caipNetworkId)
+    );
+    if (isValidDefaultNetwork) {
+      return defaultNetwork;
+    }
+
+    return undefined;
+  }
+};

package/src/utils/RouterUtil.ts

@@ -0,0 +1,50 @@
+import {
+  EventsController,
+  OnRampController,
+  RouterController,
+  SendController,
+  SwapController
+} from '@reown/appkit-core-react-native';
+
+export const RouterUtil = {
+  checkBack() {
+    this.checkSwapBack();
+    this.checkSendBack();
+    this.checkOnRampBack();
+    this.checkSocialLoginBack();
+    this.checkOnRampBackLoading();
+  },
+  checkOnRampBackLoading() {
+    if (
+      RouterController.state.view === 'OnRampLoading' &&
+      EventsController.state.data.event === 'BUY_SUBMITTED'
+    ) {
+      // Send event only if the onramp url was already created
+      EventsController.sendEvent({ type: 'track', event: 'BUY_CANCEL' });
+    }
+  },
+  checkSocialLoginBack() {
+    if (RouterController.state.view === 'ConnectingSocial') {
+      EventsController.sendEvent({
+        type: 'track',
+        event: 'SOCIAL_LOGIN_CANCELED',
+        properties: { provider: RouterController.state.data?.socialProvider! }
+      });
+    }
+  },
+  checkSwapBack() {
+    if (RouterController.state.view === 'Swap') {
+      SwapController.clearTokens();
+    }
+  },
+  checkSendBack() {
+    if (RouterController.state.view === 'WalletSend') {
+      SendController.resetState();
+    }
+  },
+  checkOnRampBack() {
+    if (RouterController.state.view === 'OnRamp') {
+      OnRampController.resetState();
+    }
+  }
+};

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([]);
+    }
+  }
+};