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

package/lib/commonjs/AppKit.js

@@ -0,0 +1,690 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.AppKit = void 0;
+exports.createAppKit = createAppKit;
+var _utils = require("valtio/utils");
+var _appkitCoreReactNative = require("@reown/appkit-core-react-native");
+var _appkitCommonReactNative = require("@reown/appkit-common-react-native");
+var _WalletConnectConnector = require("./connectors/WalletConnectConnector");
+var _HelpersUtil = require("./utils/HelpersUtil");
+var _NetworkUtil = require("./utils/NetworkUtil");
+var _RouterUtil = require("./utils/RouterUtil");
+var _SIWXUtil = require("./utils/SIWXUtil");
+const APPKIT_INSTANCE_KEY = Symbol.for('__REOWN_APPKIT_INSTANCE__');
+
+// Type helper to access the symbol-keyed property on globalThis
+
+class AppKit {
+  constructor(config) {
+    this.projectId = config.projectId;
+    this.adapters = config.adapters ?? [];
+
+    // Validate adapters to ensure no duplicate chainNamespaces
+    const namespaceMap = new Map();
+    for (const adapter of this.adapters) {
+      const chainNamespace = adapter.supportedNamespace;
+      const adapterName = adapter.constructor.name;
+      if (namespaceMap.has(chainNamespace)) {
+        throw new Error(`Duplicate adapter for namespace '${chainNamespace}'. Adapter "${adapterName}" conflicts with adapter "${namespaceMap.get(chainNamespace)}". Please provide only one adapter per chain namespace.`);
+      }
+      namespaceMap.set(chainNamespace, adapterName);
+    }
+    const formattedNetworks = _NetworkUtil.NetworkUtil.formatNetworks(config.networks, this.projectId);
+
+    // Use only networks that have adapters
+    const networksWithAdapters = formattedNetworks.filter(network => {
+      return this.adapters.some(adapter => adapter.getSupportedNamespace() === network.chainNamespace);
+    });
+    config.networks.forEach(network => {
+      if (!networksWithAdapters.some(n => n.id === network.id)) {
+        console.warn(`AppKit: missing adapter for network ${network.name} - ${network.id}`);
+      }
+    });
+    this.networks = networksWithAdapters;
+    this.namespaces = _HelpersUtil.WcHelpersUtil.createNamespaces(this.networks, config.universalProviderConfigOverride);
+    this.config = config;
+    this.extraConnectors = config.extraConnectors || [];
+    this.initControllers(config);
+    this.initConnectors();
+    this.watchBalance();
+  }
+
+  /**
+   * Handles the full connection flow for a given connector type.
+   * @param type - The type of connector to use.
+   * @param options - Optional connection options.
+   */
+  async connect(options) {
+    try {
+      const {
+        wallet,
+        walletId
+      } = options ?? {};
+      let targetWallet;
+      if (walletId) {
+        targetWallet = _appkitCoreReactNative.WalletUtil.getWallet(walletId);
+      } else if (wallet) {
+        targetWallet = wallet;
+      }
+      const connectorType = _HelpersUtil.WcHelpersUtil.getConnectorTypeByWallet(targetWallet);
+      const connector = await this.createConnector(connectorType);
+      const chain = _NetworkUtil.NetworkUtil.getDefaultNetwork(this.namespaces, _appkitCoreReactNative.OptionsController.state.defaultNetwork);
+      const approvedNamespaces = await connector.connect({
+        namespaces: this.namespaces,
+        defaultNetwork: chain,
+        universalLink: targetWallet?.link_mode ?? undefined
+      });
+      this.processConnection(connector, approvedNamespaces);
+
+      // Save connector type and namespaces in storage
+      if (approvedNamespaces && Object.keys(approvedNamespaces).length > 0) {
+        await _appkitCoreReactNative.StorageUtil.setConnectedConnectors({
+          type: connector.type,
+          namespaces: Object.keys(approvedNamespaces)
+        });
+      }
+    } catch (error) {
+      _appkitCoreReactNative.LogController.sendError(error, 'AppKit.ts', 'connect');
+      throw error;
+    }
+  }
+  async processConnection(connector, namespaces) {
+    if (!namespaces || Object.keys(namespaces).length === 0) {
+      throw new Error('No namespaces provided');
+    }
+    const walletInfo = connector.getWalletInfo();
+    const properties = connector.getProperties();
+    const initializedAdapters = this.setupAdaptersAndSubscribe(connector, Object.keys(namespaces));
+    if (initializedAdapters.length === 0) {
+      console.warn('No compatible adapters found for namespaces:', Object.keys(namespaces));
+      return;
+    }
+
+    // Store the connection details
+    this.setConnection(initializedAdapters, namespaces, walletInfo, properties);
+
+    // Sync accounts
+    await this.syncAccounts(initializedAdapters);
+    await _SIWXUtil.SIWXUtil.initializeIfEnabled({
+      onDisconnect: this.disconnect,
+      closeModal: true
+    });
+  }
+
+  /**
+   * Disconnects from a given namespace.
+   * @param namespace - The namespace to disconnect from.
+   * @param isInternal - Whether the disconnect is internal (i.e. from the AppKit) or external (i.e. from wallet side).
+   */
+  async disconnect(namespace, isInternal) {
+    try {
+      const activeNamespace = namespace ?? _appkitCoreReactNative.ConnectionsController.state.activeNamespace;
+      if (!activeNamespace) {
+        return;
+      }
+      const connection = _appkitCoreReactNative.ConnectionsController.state.connections.get(activeNamespace);
+      const connectorType = connection?.adapter?.connector?.type;
+      await _appkitCoreReactNative.ConnectionsController.disconnect(activeNamespace, isInternal);
+      if (connectorType) {
+        await _appkitCoreReactNative.StorageUtil.removeConnectedConnectors(connectorType);
+      }
+      _appkitCoreReactNative.ModalController.close();
+      _appkitCoreReactNative.RouterController.reset('Connect');
+      _appkitCoreReactNative.TransactionsController.resetState();
+      _appkitCoreReactNative.SwapController.resetState();
+      _appkitCoreReactNative.SendController.resetState();
+      _appkitCoreReactNative.OnRampController.resetState();
+      _appkitCoreReactNative.WcController.resetState();
+      _appkitCoreReactNative.EventsController.resetState();
+      if (_appkitCoreReactNative.ConnectionsController.state.activeNamespace === undefined) {
+        _appkitCoreReactNative.ConnectionsController.setActiveNamespace(_appkitCoreReactNative.OptionsController.state.defaultNetwork?.chainNamespace);
+      }
+      if (_SIWXUtil.SIWXUtil.getSIWX()?.signOutOnDisconnect) {
+        await _SIWXUtil.SIWXUtil.clearSessions();
+      }
+      _appkitCoreReactNative.EventsController.sendEvent({
+        type: 'track',
+        event: 'DISCONNECT_SUCCESS',
+        properties: {
+          namespace: activeNamespace
+        }
+      });
+    } catch (error) {
+      _appkitCoreReactNative.LogController.sendError(error, 'AppKit.ts', 'disconnect');
+      _appkitCoreReactNative.EventsController.sendEvent({
+        type: 'track',
+        event: 'DISCONNECT_ERROR'
+      });
+    }
+  }
+
+  /**
+   * Returns the provider for a given namespace.
+   * @param namespace - The namespace to get the provider for.
+   * @returns The provider for the given namespace, or null if not available or not yet initialized.
+   */
+  getProvider(namespace) {
+    const activeNamespace = namespace ?? _appkitCoreReactNative.ConnectionsController.state.activeNamespace;
+    if (!activeNamespace) return null;
+    const connection = _appkitCoreReactNative.ConnectionsController.state.connections.get(activeNamespace);
+    if (!connection || !connection.adapter || !connection.adapter.connector) return null;
+    try {
+      return connection.adapter.connector.getProvider();
+    } catch (error) {
+      // Provider not initialized yet during session restoration
+      // This can happen on app restart when restoring a previous connection
+      _appkitCoreReactNative.LogController.sendError(error, 'AppKit.ts', 'getProvider');
+      return null;
+    }
+  }
+  getNetworks() {
+    return this.networks;
+  }
+  async switchNetwork(network) {
+    const {
+      isConnected
+    } = _appkitCoreReactNative.ConnectionsController.state;
+    if (!isConnected) {
+      _appkitCoreReactNative.OptionsController.setDefaultNetwork(network);
+      return Promise.resolve();
+    }
+    const adapter = this.getAdapterByNamespace(network.chainNamespace);
+    if (!adapter) throw new Error('No active adapter');
+    await adapter.switchNetwork(network);
+    _appkitCoreReactNative.EventsController.sendEvent({
+      type: 'track',
+      event: 'SWITCH_NETWORK',
+      properties: {
+        network: network.caipNetworkId
+      }
+    });
+    _appkitCoreReactNative.ConnectionsController.setActiveNetwork(network.chainNamespace, network.caipNetworkId);
+  }
+  open(options) {
+    _appkitCoreReactNative.ModalController.open(options);
+  }
+  async close() {
+    _appkitCoreReactNative.ModalController.close();
+    const isSIWXRequired = _SIWXUtil.SIWXUtil.getSIWX()?.getRequired?.();
+    if (isSIWXRequired && _appkitCoreReactNative.ConnectionsController.state.isConnected) {
+      const sessions = await _SIWXUtil.SIWXUtil.getSessions();
+      if (!sessions.length) {
+        return await this.disconnect();
+      }
+    }
+    if (_appkitCoreReactNative.RouterController.state.view === 'UnsupportedChain') {
+      return await this.disconnect();
+    }
+    _RouterUtil.RouterUtil.checkOnRampBack();
+    _RouterUtil.RouterUtil.checkSocialLoginBack();
+    _appkitCoreReactNative.EventsController.sendWalletImpressions();
+  }
+  back() {
+    if (_appkitCoreReactNative.RouterController.state.history.length > 1) {
+      _RouterUtil.RouterUtil.checkBack();
+      return _appkitCoreReactNative.RouterController.goBack();
+    }
+    const isSIWXRequired = _SIWXUtil.SIWXUtil.getSIWX()?.getRequired?.();
+    if (isSIWXRequired) {
+      // Don't close the modal if SIWX is required
+      return;
+    }
+    return this.close();
+  }
+  async switchAccountType(namespace, type, network) {
+    const adapter = this.getAdapterByNamespace(namespace);
+    if (!adapter) throw new Error('No active adapter');
+    const address = _appkitCoreReactNative.ConnectionsController.setAccountType(namespace, type);
+
+    // Get balances from API
+    _appkitCoreReactNative.ConnectionsController.fetchBalance();
+
+    // Fetch transactions for the new account
+    if (address) {
+      _appkitCoreReactNative.TransactionsController.fetchTransactions(address, true);
+    }
+
+    // Sync balances from adapter
+    this.syncNativeBalance(adapter, network);
+    _appkitCoreReactNative.EventsController.sendEvent({
+      type: 'track',
+      event: 'SET_PREFERRED_ACCOUNT_TYPE',
+      properties: {
+        accountType: type,
+        network: network?.caipNetworkId || ''
+      }
+    });
+  }
+  async createConnector(type) {
+    // Check if an extra connector was provided by the developer
+    const CustomConnector = this.extraConnectors.find(connector => connector.type.toLowerCase() === type.toLowerCase());
+    if (CustomConnector) {
+      await CustomConnector.init({
+        storage: this.config.storage,
+        metadata: this.config.metadata
+      });
+      return CustomConnector;
+    }
+
+    // Default to WalletConnectConnector if no custom connector matches
+    return this.createWalletConnectConnector();
+  }
+  async createWalletConnectConnector() {
+    if (this.walletConnectConnector) {
+      return this.walletConnectConnector;
+    }
+    this.walletConnectConnector = new _WalletConnectConnector.WalletConnectConnector({
+      projectId: this.projectId
+    });
+    await this.walletConnectConnector.init({
+      storage: this.config.storage,
+      metadata: this.config.metadata
+    });
+    return this.walletConnectConnector;
+  }
+
+  /**
+   * Initializes connectors based on stored connection data.
+   * This attempts to restore previous sessions.
+   */
+  async initConnectors() {
+    _appkitCoreReactNative.ModalController.setLoading(true);
+
+    //Always init the walletconnect connector
+    await this.createWalletConnectConnector();
+    const connectedConnectors = await _appkitCoreReactNative.StorageUtil.getConnectedConnectors();
+    if (connectedConnectors.length > 0) {
+      for (const connected of connectedConnectors) {
+        try {
+          const connector = await this.createConnector(connected.type);
+          const namespaces = connector.getNamespaces();
+          await this.processConnection(connector, namespaces);
+        } catch (error) {
+          _appkitCoreReactNative.LogController.sendError(error, 'AppKit.ts', 'initializeConnector', {
+            connectorType: connected.type
+          });
+          await _appkitCoreReactNative.StorageUtil.removeConnectedConnectors(connected.type);
+        }
+      }
+      const address = _appkitCoreReactNative.ConnectionsController.state.activeAddress;
+      const walletInfo = _appkitCoreReactNative.ConnectionsController.state.walletInfo;
+      if (address) {
+        _appkitCoreReactNative.EventsController.sendEvent({
+          type: 'track',
+          event: 'CONNECT_SUCCESS',
+          address: _appkitCoreReactNative.CoreHelperUtil.getPlainAddress(address),
+          properties: {
+            name: walletInfo?.name ?? 'Unknown',
+            reconnect: true
+          }
+        });
+      }
+    }
+    _appkitCoreReactNative.ModalController.setLoading(false);
+  }
+  setupAdaptersAndSubscribe(connector, namespaces) {
+    const adapters = this.adapters.filter(adapter => namespaces.includes(adapter.getSupportedNamespace()));
+    if (adapters.length === 0) {
+      // Log or handle cases where no adapters match
+      console.warn(`No compatible adapters found for namespaces: ${namespaces.join(', ')}`);
+      return [];
+    }
+    adapters.forEach(adapter => {
+      adapter.init({
+        connector
+      });
+      this.subscribeToAdapterEvents(adapter);
+    });
+    return adapters;
+  }
+  getAdapterByNamespace(namespace) {
+    const namespaceConnection = _appkitCoreReactNative.ConnectionsController.state.connections.get(namespace);
+    if (namespaceConnection) {
+      return namespaceConnection.adapter;
+    }
+    return null;
+  }
+  async syncAccounts(adapters) {
+    adapters.forEach(async adapter => {
+      const namespace = adapter.getSupportedNamespace();
+      const connection = _appkitCoreReactNative.ConnectionsController.state.connections.get(namespace);
+      const network = this.networks.find(n => n.id?.toString() === connection?.caipNetwork?.split(':')[1]);
+      this.syncNativeBalance(adapter, network);
+      this.syncIdentity(namespace, connection);
+    });
+  }
+  syncNativeBalance(adapter, network) {
+    if (adapter && network) {
+      const accounts = adapter.getAccounts();
+      if (accounts && accounts.length > 0) {
+        const addresses = accounts.filter(a => a.split(':')[1] === network?.id?.toString());
+        if (addresses.length > 0) {
+          addresses.forEach(address => {
+            adapter.getBalance({
+              address,
+              network,
+              tokens: this.config.tokens
+            });
+          });
+        }
+      }
+    }
+  }
+  async syncIdentity(namespace, connection) {
+    if (namespace !== 'eip155' || !connection?.accounts?.length) return;
+    const uniqueAddresses = [...new Set(connection.accounts.map(account => _appkitCoreReactNative.CoreHelperUtil.getPlainAddress(account)))];
+
+    // Process addresses sequentially to avoid race conditions
+    for (const plainAddress of uniqueAddresses) {
+      try {
+        // Validate address format before type assertion
+        if (!plainAddress || !_appkitCoreReactNative.CoreHelperUtil.isAddress(plainAddress, 'eip155')) {
+          console.warn(`Invalid Ethereum address format: ${plainAddress}`);
+          continue;
+        }
+        const identity = await _appkitCoreReactNative.BlockchainApiController.fetchIdentity({
+          address: plainAddress
+        });
+        if (identity?.name) {
+          _appkitCoreReactNative.ConnectionsController.updateIdentity(namespace, connection, plainAddress, identity);
+        }
+      } catch (error) {
+        _appkitCoreReactNative.LogController.sendError(error, 'AppKit.ts', 'syncIdentity');
+        // Continue processing other addresses even if one fails
+      }
+    }
+  }
+  refreshBalance(fetchAllBalances = false) {
+    try {
+      if (fetchAllBalances) {
+        _appkitCoreReactNative.ConnectionsController.fetchBalance();
+      }
+      const ns = _appkitCoreReactNative.ConnectionsController.state.activeNamespace;
+      const network = _appkitCoreReactNative.ConnectionsController.state.activeNetwork;
+      if (ns && network) {
+        const adapter = this.getAdapterByNamespace(ns);
+        if (adapter) {
+          this.syncNativeBalance(adapter, network);
+        }
+      }
+    } catch (error) {
+      // ignore
+      _appkitCoreReactNative.LogController.sendError(error, 'AppKit.ts', 'refreshBalance');
+    }
+  }
+  startBalancePolling(fetchAllBalances = false) {
+    if (this.balanceIntervalId) return;
+    // immediate fetch
+    this.refreshBalance(fetchAllBalances);
+    this.balanceIntervalId = setInterval(() => this.refreshBalance(fetchAllBalances), 10000);
+  }
+  stopBalancePolling() {
+    if (this.balanceIntervalId) {
+      clearInterval(this.balanceIntervalId);
+      this.balanceIntervalId = undefined;
+    }
+  }
+  watchBalance() {
+    // watch balance when user is on account or account default view
+    const recomputePolling = () => {
+      const open = _appkitCoreReactNative.ModalController.state.open;
+      const view = _appkitCoreReactNative.RouterController.state.view;
+      if (open && (view === 'Account' || view === 'AccountDefault')) {
+        // fetch all balances when user is using embedded wallet
+        this.startBalancePolling(view === 'Account');
+      } else {
+        this.stopBalancePolling();
+      }
+    };
+    recomputePolling();
+    (0, _utils.subscribeKey)(_appkitCoreReactNative.RouterController.state, 'view', () => recomputePolling());
+    (0, _utils.subscribeKey)(_appkitCoreReactNative.ModalController.state, 'open', () => recomputePolling());
+  }
+  setConnection(adapters, approvedNamespaces, wallet, properties) {
+    adapters.forEach(async adapter => {
+      const namespace = adapter.getSupportedNamespace();
+      const namespaceDetails = approvedNamespaces[namespace];
+      if (!namespaceDetails) return;
+      const accounts = namespaceDetails.accounts ?? [];
+      const chains = namespaceDetails.chains ?? [];
+      const caipNetwork = adapter?.connector?.getChainId(namespace);
+      const namespaceProperties = {
+        ...properties,
+        smartAccounts: properties?.smartAccounts?.filter(account => account.startsWith(namespace)),
+        canAddEvmChain: wallet?.name === 'MetaMask Wallet' // MetaMask allows adding EVM chains after connecting
+      };
+      _appkitCoreReactNative.ConnectionsController.setConnection({
+        accounts,
+        adapter,
+        caipNetwork: caipNetwork ?? chains[0],
+        namespace,
+        properties: namespaceProperties,
+        wallet
+      });
+    });
+    const updateActiveNamespace = !Object.keys(approvedNamespaces).some(namespace => namespace === _appkitCoreReactNative.ConnectionsController.state.activeNamespace);
+
+    // If the active namespace is not in the approved namespaces or is undefined, set the first connected adapter's namespace as active
+    if (updateActiveNamespace && adapters[0]) {
+      _appkitCoreReactNative.ConnectionsController.setActiveNamespace(adapters[0].getSupportedNamespace());
+    }
+  }
+  subscribeToAdapterEvents(adapter) {
+    adapter.on('accountsChanged', ({
+      accounts
+    }) => {
+      const namespace = adapter.getSupportedNamespace();
+      _appkitCoreReactNative.ConnectionsController.updateAccounts(namespace, accounts);
+    });
+    adapter.on('chainChanged', async ({
+      chainId
+    }) => {
+      const isSupported = this.networks.some(network => network.id?.toString() === chainId);
+      if (!isSupported) {
+        return this.navigate('UnsupportedChain');
+      }
+      const namespace = adapter.getSupportedNamespace();
+      const chain = `${namespace}:${chainId}`;
+      _appkitCoreReactNative.ConnectionsController.setActiveNetwork(namespace, chain);
+      const connection = _appkitCoreReactNative.ConnectionsController.state.connections.get(namespace);
+      const isAuth = !!connection?.properties?.provider;
+      const network = this.networks.find(n => n.id?.toString() === chainId);
+      this.syncNativeBalance(adapter, network);
+      _appkitCoreReactNative.SendController.resetState();
+
+      // Refresh balance for embedded wallets
+      if (isAuth) {
+        _appkitCoreReactNative.ConnectionsController.fetchBalance();
+      }
+      const address = connection?.accounts?.find(account => account.startsWith(`${namespace}:${chainId}`));
+      if (address) {
+        _appkitCoreReactNative.TransactionsController.fetchTransactions(address, true);
+      }
+      const closeModal = _appkitCoreReactNative.RouterController.state.view === 'UnsupportedChain';
+      _SIWXUtil.SIWXUtil.initializeIfEnabled({
+        onDisconnect: this.disconnect,
+        caipAddress: address,
+        closeModal
+      });
+    });
+    adapter.on('disconnect', () => {
+      const namespace = adapter.getSupportedNamespace();
+      this.disconnect(namespace, false);
+    });
+    adapter.on('balanceChanged', ({
+      address,
+      balance
+    }) => {
+      const namespace = adapter.getSupportedNamespace();
+      _appkitCoreReactNative.ConnectionsController.updateBalance(namespace, address, balance);
+    });
+  }
+  async initControllers(options) {
+    await this.initStorageAndValues(options);
+    let defaultNetwork;
+    _appkitCoreReactNative.OptionsController.setProjectId(options.projectId);
+    _appkitCoreReactNative.OptionsController.setMetadata(options.metadata);
+    _appkitCoreReactNative.OptionsController.setIncludeWalletIds(options.includeWalletIds);
+    this.setExcludedWallets(options);
+    this.setCustomWallets(options);
+    _appkitCoreReactNative.OptionsController.setFeaturedWalletIds(options.featuredWalletIds);
+    _appkitCoreReactNative.OptionsController.setEnableAnalytics(options.enableAnalytics);
+    _appkitCoreReactNative.OptionsController.setDebug(options.debug);
+    _appkitCoreReactNative.LogController.sendInfo('AppKit initialization started', 'AppKit.ts', 'initControllers', {
+      projectId: options.projectId,
+      adapters: this.adapters.map(a => a.constructor.name),
+      networks: this.networks.map(n => n.name),
+      debug: options.debug
+    });
+    _appkitCoreReactNative.OptionsController.setFeatures(options.features);
+    _appkitCoreReactNative.OptionsController.setRequestedNetworks(this.networks);
+    if (options.defaultNetwork) {
+      defaultNetwork = _NetworkUtil.NetworkUtil.formatNetwork(options.defaultNetwork, this.projectId);
+      _appkitCoreReactNative.OptionsController.setDefaultNetwork(defaultNetwork);
+    }
+    _appkitCoreReactNative.ThemeController.setDefaultThemeMode(options.themeMode);
+    _appkitCoreReactNative.ThemeController.setThemeVariables(options.themeVariables);
+    _appkitCoreReactNative.OptionsController.setSdkVersion(_appkitCoreReactNative.CoreHelperUtil.generateSdkVersion(this.adapters, _appkitCommonReactNative.ConstantsUtil.VERSION));
+    if (options.clipboardClient) {
+      _appkitCoreReactNative.OptionsController.setClipboardClient(options.clipboardClient);
+    }
+    _appkitCoreReactNative.ConnectionsController.setNetworks(this.networks);
+    if (options.siwx) {
+      _appkitCoreReactNative.OptionsController.setSiwx(options.siwx);
+    }
+    if ((options.features?.onramp === true || options.features?.onramp === undefined) && (options.metadata?.redirect?.universal || options.metadata?.redirect?.native)) {
+      _appkitCoreReactNative.OptionsController.setIsOnRampEnabled(true);
+    }
+    _appkitCoreReactNative.EventsController.sendEvent({
+      type: 'track',
+      event: 'INITIALIZE',
+      properties: {
+        showWallets: options.features?.showWallets,
+        themeMode: options.themeMode,
+        themeVariables: options.themeVariables,
+        networks: this.networks.map(network => network.caipNetworkId).filter(Boolean),
+        defaultNetwork: defaultNetwork?.caipNetworkId,
+        metadata: options.metadata,
+        enableAnalytics: options.enableAnalytics,
+        features: options.features,
+        adapters: this.adapters.map(adapter => adapter?.constructor?.name).filter(Boolean),
+        extraConnectors: this.extraConnectors.map(connector => connector?.type).filter(Boolean),
+        siwx: !!options.siwx
+      }
+    });
+  }
+  async initActiveNamespace() {
+    const activeNamespace = await _appkitCoreReactNative.StorageUtil.getActiveNamespace();
+    if (activeNamespace) {
+      _appkitCoreReactNative.ConnectionsController.setActiveNamespace(activeNamespace);
+    } else if (_appkitCoreReactNative.OptionsController.state.defaultNetwork) {
+      _appkitCoreReactNative.ConnectionsController.setActiveNamespace(_appkitCoreReactNative.OptionsController.state.defaultNetwork?.chainNamespace);
+    }
+  }
+  async initRecentWallets(options) {
+    const wallets = await _appkitCoreReactNative.StorageUtil.getRecentWallets();
+    const filteredWallets = wallets.filter(wallet => {
+      const {
+        includeWalletIds,
+        excludeWalletIds
+      } = options;
+      if (includeWalletIds?.length) {
+        return includeWalletIds.includes(wallet.id);
+      }
+      if (excludeWalletIds?.length) {
+        return !excludeWalletIds.includes(wallet.id);
+      }
+      return this.networks.some(network => wallet.chains?.some(chain => network.caipNetworkId === chain));
+    });
+    _appkitCoreReactNative.WcController.setRecentWallets(filteredWallets);
+  }
+  setExcludedWallets(options) {
+    const excludedWallets = options.excludeWalletIds || [];
+
+    // Exclude Coinbase if the connector is not implemented
+    const excludeCoinbase = !this.extraConnectors.some(connector => connector.type === 'coinbase');
+    if (excludeCoinbase) {
+      excludedWallets.push(_appkitCommonReactNative.ConstantsUtil.COINBASE_CUSTOM_WALLET.id);
+    }
+    _appkitCoreReactNative.OptionsController.setExcludeWalletIds(excludedWallets);
+  }
+  setCustomWallets(options) {
+    const {
+      customWallets,
+      extraConnectors,
+      adapters
+    } = options;
+    const customList = [...(customWallets ?? [])];
+    const isSolanaEnabled = adapters.some(adapter => adapter.getSupportedNamespace() === 'solana') && this.networks.some(network => network.chainNamespace === 'solana');
+    const addPhantom = isSolanaEnabled && extraConnectors?.some(connector => connector.type.toLowerCase() === 'phantom') && !customList.some(wallet => wallet.id === _appkitCommonReactNative.ConstantsUtil.PHANTOM_CUSTOM_WALLET.id);
+    if (addPhantom) {
+      customList.push(_appkitCommonReactNative.ConstantsUtil.PHANTOM_CUSTOM_WALLET);
+    }
+    const addSolflare = isSolanaEnabled && extraConnectors?.some(connector => connector.type.toLowerCase() === 'solflare') && !customList.some(wallet => wallet.id === _appkitCommonReactNative.ConstantsUtil.SOLFLARE_CUSTOM_WALLET.id);
+    if (addSolflare) {
+      customList.push(_appkitCommonReactNative.ConstantsUtil.SOLFLARE_CUSTOM_WALLET);
+    }
+    _appkitCoreReactNative.OptionsController.setCustomWallets(customList);
+  }
+  async initStorageAndValues(options) {
+    if (!options.storage) {
+      throw new Error('AppKit: Storage is not set');
+    }
+    _appkitCoreReactNative.OptionsController.setStorage(options.storage);
+    await this.initActiveNamespace();
+    await this.initRecentWallets(options);
+  }
+  navigate = routeName => {
+    if (_appkitCoreReactNative.RouterController.state.view === routeName) {
+      return;
+    }
+    if (_appkitCoreReactNative.ModalController.state.open) {
+      _appkitCoreReactNative.RouterController.push(routeName);
+    } else {
+      _appkitCoreReactNative.ModalController.open({
+        view: routeName
+      });
+    }
+  };
+}
+
+/**
+ * Creates or returns the existing AppKit singleton instance.
+ *
+ * @warning This function implements a singleton pattern. If an instance already exists,
+ * it will be returned and the provided config parameter will be IGNORED. If you need to
+ * change configuration, you must reload your application or clear the singleton manually.
+ *
+ * @param config - AppKit configuration options
+ * @returns The AppKit singleton instance
+ * @throws Error if configuration validation fails
+ */
+exports.AppKit = AppKit;
+function createAppKit(config) {
+  try {
+    const globalWithAppKit = globalThis;
+    if (!globalWithAppKit[APPKIT_INSTANCE_KEY]) {
+      if (config.debug && __DEV__) {
+        // using console.log to avoid possible issues with LogController not being initialized
+        //eslint-disable-next-line no-console
+        console.log('AppKit: Creating new instance - AppKit.ts:createAppKit');
+      }
+      globalWithAppKit[APPKIT_INSTANCE_KEY] = new AppKit(config);
+    } else if (config.debug && __DEV__) {
+      //eslint-disable-next-line no-console
+      console.log('AppKit: Reusing existing instance - AppKit.ts:createAppKit');
+    }
+    return globalWithAppKit[APPKIT_INSTANCE_KEY];
+  } catch (error) {
+    if (__DEV__) {
+      // using console.error to avoid possible issues with LogController not being initialized
+      //eslint-disable-next-line no-console
+      console.error('AppKit: Failed to create instance - AppKit.ts:createAppKit', error);
+    }
+    throw error;
+  }
+}
+//# sourceMappingURL=AppKit.js.map