@web3auth/no-modal 10.14.1 → 11.0.0-beta.0

package/dist/lib.esm/connectors/metamask-connector/metamaskConnector.js

@@ -1,103 +1,219 @@
 import _objectSpread from '@babel/runtime/helpers/objectSpread2';
 import _defineProperty from '@babel/runtime/helpers/defineProperty';
-import { MetaMaskSDK } from '@metamask/sdk';
-import { CHAIN_NAMESPACES, getErrorAnalyticsProperties } from '@toruslabs/base-controllers';
-import deepmerge from 'deepmerge';
-import { getSiteIcon, getSiteName } from '../utils.js';
-import { getCaipChainId } from '../../base/utils.js';
+import { createEVMClient } from '@metamask/connect-evm';
+import { createMultichainClient, hasExtension } from '@metamask/connect-multichain';
+import { createSolanaClient } from '@metamask/connect-solana';
+import { CHAIN_NAMESPACES, getErrorAnalyticsProperties, signChallenge } from '@toruslabs/base-controllers';
+import { bytesToHexPrefixedString, utf8ToBytes } from '@toruslabs/metadata-helpers';
+import { StandardConnect } from '@wallet-standard/features';
+import { EVM_METHOD_TYPES } from '@web3auth/ws-embed';
+import { generateSiweNonce } from 'viem/siwe';
+import { getSiteName } from '../utils.js';
 import { ANALYTICS_EVENTS } from '../../base/analytics.js';
-import { BaseEvmConnector } from '../base-evm-connector/baseEvmConnector.js';
+import { BaseConnector } from '../../base/connector/baseConnector.js';
 import { CONNECTOR_NAMESPACES } from '../../base/chain/IChainInterface.js';
 import { CONNECTOR_CATEGORY, CONNECTOR_STATUS, CONNECTOR_EVENTS } from '../../base/connector/constants.js';
 import { WALLET_CONNECTORS } from '../../base/wallet/index.js';
+import { getCaipChainId, citadelServerUrl } from '../../base/utils.js';
+import { getSolanaChainByChainConfig, walletSignMessage } from '../../base/wallet/solana.js';
 import { WalletLoginError, Web3AuthError } from '../../base/errors/index.js';
 
-class MetaMaskConnector extends BaseEvmConnector {
+/**
+ * Configuration options for the MetaMask connector using \@metamask/connect-evm
+ */
+
+class MetaMaskConnector extends BaseConnector {
   constructor(connectorOptions) {
     super(connectorOptions);
-    _defineProperty(this, "connectorNamespace", CONNECTOR_NAMESPACES.EIP155);
-    _defineProperty(this, "currentChainNamespace", CHAIN_NAMESPACES.EIP155);
+    _defineProperty(this, "connectorNamespace", CONNECTOR_NAMESPACES.MULTICHAIN);
+    _defineProperty(this, "currentChainNamespace", CHAIN_NAMESPACES.OTHER);
     _defineProperty(this, "type", CONNECTOR_CATEGORY.EXTERNAL);
     _defineProperty(this, "name", WALLET_CONNECTORS.METAMASK);
     _defineProperty(this, "status", CONNECTOR_STATUS.NOT_READY);
-    _defineProperty(this, "metamaskProvider", null);
-    _defineProperty(this, "metamaskSDK", null);
-    _defineProperty(this, "metamaskOptions", void 0);
+    _defineProperty(this, "evmClient", null);
+    _defineProperty(this, "evmProvider", null);
+    _defineProperty(this, "solanaClient", null);
+    _defineProperty(this, "solanaProvider", null);
+    _defineProperty(this, "initializationPromise", null);
+    _defineProperty(this, "multichainClient", null);
+    _defineProperty(this, "connectorSettings", void 0);
     _defineProperty(this, "analytics", void 0);
-    this.metamaskOptions = connectorOptions.connectorSettings;
+    this.connectorSettings = connectorOptions.connectorSettings;
     this.analytics = connectorOptions.analytics;
   }
   get provider() {
-    if (this.status !== CONNECTOR_STATUS.NOT_READY && this.metamaskProvider) {
-      return this.metamaskProvider;
+    if (this.status !== CONNECTOR_STATUS.NOT_READY && this.evmProvider) {
+      return this.evmProvider;
     }
     return null;
   }
-  set provider(_) {
-    throw new Error("Not implemented");
+  get solanaWallet() {
+    return this.solanaProvider;
   }
   async init(options) {
-    await super.init(options);
+    var _this$connectorSettin, _this$connectorSettin2, _this$connectorSettin3, _this$connectorSettin4, _this$connectorSettin5, _this$connectorSettin6, _this$connectorSettin7, _this$connectorSettin8, _this$connectorSettin9;
     const chainConfig = this.coreOptions.chains.find(x => x.chainId === options.chainId);
     super.checkInitializationRequirements({
       chainConfig
     });
 
+    // Build supported networks in CAIP-2 format for multichain client
+    const caipSupportedNetworks = {};
+    for (const chain of this.coreOptions.chains) {
+      caipSupportedNetworks[getCaipChainId(chain)] = chain.rpcTarget;
+    }
+
+    // Build supported networks in hex format for EVM client
+    const hexSupportedNetworks = {};
+    for (const chain of this.coreOptions.chains) {
+      if (chain.chainNamespace === CHAIN_NAMESPACES.EIP155) {
+        hexSupportedNetworks[chain.chainId] = chain.rpcTarget;
+      }
+    }
+
+    // Build supported networks for Solana client (MetaMask expects mainnet | testnet | devnet keys)
+    const solanaSupportedNetworks = {};
+    for (const chain of this.coreOptions.chains) {
+      if (chain.chainNamespace !== CHAIN_NAMESPACES.SOLANA) continue;
+      const solanaChainId = getSolanaChainByChainConfig(chain);
+      if (!solanaChainId) continue;
+      const networkName = solanaChainId.split(":")[1];
+      if (networkName) solanaSupportedNetworks[networkName] = chain.rpcTarget;
+    }
+
     // Detect app metadata
-    const iconUrl = await getSiteIcon(window);
-    // TODO: handle ssr
-    const appMetadata = {
-      name: getSiteName(window) || "web3auth",
-      url: window.location.origin || "https://web3auth.io",
-      iconUrl: iconUrl !== null && iconUrl !== void 0 ? iconUrl : undefined
+    const appName = getSiteName(window) || ((_this$connectorSettin = this.connectorSettings) === null || _this$connectorSettin === void 0 || (_this$connectorSettin = _this$connectorSettin.dapp) === null || _this$connectorSettin === void 0 ? void 0 : _this$connectorSettin.name) || "web3auth";
+    const appUrl = ((_this$connectorSettin2 = this.connectorSettings) === null || _this$connectorSettin2 === void 0 || (_this$connectorSettin2 = _this$connectorSettin2.dapp) === null || _this$connectorSettin2 === void 0 ? void 0 : _this$connectorSettin2.url) || window.location.origin || "https://web3auth.io";
+    const appIconUrl = (_this$connectorSettin3 = this.connectorSettings) === null || _this$connectorSettin3 === void 0 || (_this$connectorSettin3 = _this$connectorSettin3.dapp) === null || _this$connectorSettin3 === void 0 ? void 0 : _this$connectorSettin3.iconUrl;
+    const dapp = _objectSpread({
+      name: appName,
+      url: appUrl
+    }, appIconUrl && {
+      iconUrl: appIconUrl
+    });
+    const ui = {
+      preferExtension: (_this$connectorSettin4 = (_this$connectorSettin5 = this.connectorSettings) === null || _this$connectorSettin5 === void 0 || (_this$connectorSettin5 = _this$connectorSettin5.ui) === null || _this$connectorSettin5 === void 0 ? void 0 : _this$connectorSettin5.preferExtension) !== null && _this$connectorSettin4 !== void 0 ? _this$connectorSettin4 : true,
+      showInstallModal: (_this$connectorSettin6 = (_this$connectorSettin7 = this.connectorSettings) === null || _this$connectorSettin7 === void 0 || (_this$connectorSettin7 = _this$connectorSettin7.ui) === null || _this$connectorSettin7 === void 0 ? void 0 : _this$connectorSettin7.showInstallModal) !== null && _this$connectorSettin6 !== void 0 ? _this$connectorSettin6 : false,
+      headless: (_this$connectorSettin8 = (_this$connectorSettin9 = this.connectorSettings) === null || _this$connectorSettin9 === void 0 || (_this$connectorSettin9 = _this$connectorSettin9.ui) === null || _this$connectorSettin9 === void 0 ? void 0 : _this$connectorSettin9.headless) !== null && _this$connectorSettin8 !== void 0 ? _this$connectorSettin8 : true
     };
-
-    // initialize the MetaMask SDK
-    const metamaskOptions = deepmerge(this.metamaskOptions || {}, {
-      dappMetadata: appMetadata
+    let initResolve;
+    let initReject;
+    this.initializationPromise = new Promise((resolve, reject) => {
+      initResolve = resolve;
+      initReject = reject;
     });
-    this.metamaskSDK = new MetaMaskSDK(_objectSpread(_objectSpread({}, metamaskOptions), {}, {
-      _source: "web3auth",
-      preferDesktop: true
-    }));
-    // Work around: in case there is an existing SDK instance in memory (window.mmsdk exists), it won't initialize the new SDK instance again
-    // and return the existing instance instead of undefined (this is an assumption, not sure if it's a bug or feature of the MetaMask SDK)
-    const initResult = await this.metamaskSDK.init();
-    if (initResult) {
-      this.metamaskSDK = initResult;
-    }
-    this.isInjected = this.metamaskSDK.isExtensionActive();
-    this.status = CONNECTOR_STATUS.READY;
-    this.emit(CONNECTOR_EVENTS.READY, WALLET_CONNECTORS.METAMASK);
+    const hasEvmChains = Object.keys(hexSupportedNetworks).length > 0;
+    const hasSolanaChains = Object.keys(solanaSupportedNetworks).length > 0;
     try {
-      if (options.autoConnect) {
-        this.rehydrated = true;
-        const provider = await this.connect({
-          chainId: options.chainId,
-          getIdentityToken: options.getIdentityToken
-        });
-        if (!provider) {
-          this.rehydrated = false;
-          throw WalletLoginError.connectionError("Failed to rehydrate.");
+      var _this$connectorSettin0;
+      // Initialize the multichain client (singleton) first
+      this.multichainClient = await createMultichainClient({
+        dapp,
+        api: {
+          supportedNetworks: caipSupportedNetworks
+        },
+        ui,
+        debug: (_this$connectorSettin0 = this.connectorSettings) === null || _this$connectorSettin0 === void 0 ? void 0 : _this$connectorSettin0.debug
+      });
+
+      // Listen for QR code URI from the multichain client (for mobile wallet connection)
+      this.multichainClient.on("display_uri", uri => {
+        if (uri) {
+          this.updateConnectorData({
+            uri
+          });
         }
+      });
+
+      // Create the EVM client only when EVM chains are configured
+      // (createEVMClient requires at least one entry in supportedNetworks)
+      if (hasEvmChains) {
+        var _this$connectorSettin1;
+        this.evmClient = await createEVMClient({
+          dapp,
+          eventHandlers: {
+            accountsChanged: _accounts => {
+              if (_accounts.length === 0) {
+                this.disconnect();
+              }
+            },
+            chainChanged: _chainId => {},
+            connect: _result => {},
+            disconnect: () => this.disconnect()
+          },
+          api: {
+            supportedNetworks: hexSupportedNetworks
+          },
+          ui,
+          debug: (_this$connectorSettin1 = this.connectorSettings) === null || _this$connectorSettin1 === void 0 ? void 0 : _this$connectorSettin1.debug
+        });
+        this.evmProvider = this.evmClient.getProvider();
+      }
+
+      // Create the Solana client only when Solana chains are configured
+      if (hasSolanaChains) {
+        this.solanaClient = await createSolanaClient({
+          dapp,
+          api: {
+            supportedNetworks: solanaSupportedNetworks
+          },
+          skipAutoRegister: true
+        });
+        this.solanaProvider = this.solanaClient.getWallet();
       }
+      this.isInjected = await hasExtension();
+      initResolve();
     } catch (error) {
-      this.emit(CONNECTOR_EVENTS.REHYDRATION_ERROR, error);
+      initReject(WalletLoginError.connectionError("Failed to initialize MetaMask Connect SDK", error));
+    }
+    if (!this.multichainClient) {
+      this.status = CONNECTOR_STATUS.ERRORED;
+      this.emit(CONNECTOR_EVENTS.ERRORED, new Error("Failed to initialize MetaMask Connect."));
+      return;
+    }
+    const coreStatus = this.multichainClient.status;
+    if (coreStatus === "connected") {
+      this.status = CONNECTOR_STATUS.CONNECTED;
+      this.rehydrated = true;
+      this.emit(CONNECTOR_EVENTS.CONNECTED, {
+        connectorName: WALLET_CONNECTORS.METAMASK,
+        reconnected: this.rehydrated,
+        ethereumProvider: this.evmProvider,
+        solanaWallet: this.solanaProvider
+      });
+      if (options.getAuthTokenInfo) {
+        await this.getAuthTokenInfo();
+      }
+    } else if (coreStatus === "loaded" || coreStatus === "disconnected") {
+      this.status = CONNECTOR_STATUS.READY;
+      this.emit(CONNECTOR_EVENTS.READY, WALLET_CONNECTORS.METAMASK);
+    } else if (coreStatus === "pending") {
+      // 'pending' implies that a transport failed to resume the connection
+      // if (options.autoConnect) {
+      //   this.rehydrated = false;
+      //   this.emit(CONNECTOR_EVENTS.REHYDRATION_ERROR, new Error("Failed to resume existing MetaMask Connect session.") as Web3AuthError);
+      // } else {
+      this.status = CONNECTOR_STATUS.READY;
+      this.emit(CONNECTOR_EVENTS.READY, WALLET_CONNECTORS.METAMASK);
+      // }
+    } else {
+      // Something unexpected happened
+      this.status = CONNECTOR_STATUS.ERRORED;
+      this.emit(CONNECTOR_EVENTS.ERRORED, new Error("Failed to initialize MetaMask Connect."));
     }
   }
   async connect({
     chainId,
-    getIdentityToken
+    getAuthTokenInfo
   }) {
     super.checkConnectionRequirements();
-    if (!this.metamaskSDK) throw WalletLoginError.notConnectedError("Connector is not initialized");
+    await this.ensureInitialized();
     const chainConfig = this.coreOptions.chains.find(x => x.chainId === chainId);
     if (!chainConfig) throw WalletLoginError.connectionError("Chain config is not available");
+    const scopes = this.coreOptions.chains.map(c => getCaipChainId(c));
 
-    // Skip tracking for injected MetaMask since it's handled in connectTo
     // Skip tracking for rehydration since only new connections are tracked
-    // Only track non-injected MetaMask when connection completes since it auto-initializes to generate QR code
-    const shouldTrack = !this.isInjected && !this.rehydrated;
+    const shouldTrack = !this.rehydrated;
     const startTime = Date.now();
     const eventData = {
       connector: this.name,
@@ -109,43 +225,50 @@ class MetaMaskConnector extends BaseEvmConnector {
     };
     try {
       if (this.status !== CONNECTOR_STATUS.CONNECTING) {
-        var _this$metamaskOptions;
         this.status = CONNECTOR_STATUS.CONNECTING;
         this.emit(CONNECTOR_EVENTS.CONNECTING, {
           connector: WALLET_CONNECTORS.METAMASK
         });
-        if (!this.metamaskSDK.isExtensionActive() && (_this$metamaskOptions = this.metamaskOptions) !== null && _this$metamaskOptions !== void 0 && _this$metamaskOptions.headless) {
-          // when metamask is not injected and headless is true, broadcast the uri to the login modal
-          this.metamaskSDK.getProvider().on("display_uri", uri => {
-            this.updateConnectorData({
-              uri
-            });
+        const evmConnectedPromise = new Promise(resolve => {
+          var _this$evmProvider;
+          // Wait for EVM provider to be ready
+          (_this$evmProvider = this.evmProvider) === null || _this$evmProvider === void 0 || _this$evmProvider.once("connect", () => {
+            resolve();
           });
+        });
+
+        // Connect using the multichain client
+        await this.multichainClient.connect(scopes, [], {
+          solana_accountChanged_notifications: true
+        });
+
+        // Solana wallet-standard: `standard:events` change is not emitted from multichain
+        // connect alone — MetamaskWallet syncs accounts via `standard:connect` → updateSession.
+        if (this.solanaProvider) {
+          await this.solanaProvider.features[StandardConnect].connect();
         }
-        await this.metamaskSDK.connect();
-      }
-      this.metamaskProvider = this.metamaskSDK.getProvider();
-      if (!this.metamaskProvider) throw WalletLoginError.notConnectedError("Failed to connect with provider");
 
-      // switch chain if not connected to the right chain
-      const currentChainId = await this.metamaskProvider.request({
-        method: "eth_chainId"
-      });
-      if (currentChainId !== chainConfig.chainId) {
-        await this.switchChain(chainConfig, true);
+        // Wait for EVM provider to be ready
+        if (this.evmProvider) {
+          await evmConnectedPromise;
+        }
       }
 
-      // handle disconnect event
-      const accountDisconnectHandler = accounts => {
-        if (accounts.length === 0) this.disconnect();
-      };
-      this.metamaskProvider.on("accountsChanged", accountDisconnectHandler);
-      this.metamaskProvider.once("disconnect", () => {
-        this.disconnect();
-      });
+      // // Switch EVM chain if not connected to the right one (Solana chains are handled by the wallet-standard provider)
+      // if (chainConfig.chainNamespace === CHAIN_NAMESPACES.EIP155) {
+      //   const currentChainId = this.evmClient!.getChainId();
+      //   if (currentChainId !== chainId) {
+      //     await this.switchChain(chainConfig, true);
+      //   }
+      // }
+
+      // check if connected
+      if (this.multichainClient.status !== "connected") {
+        throw WalletLoginError.notConnectedError("Failed to connect with MetaMask wallet");
+      }
       this.status = CONNECTOR_STATUS.CONNECTED;
 
-      // track connection events
+      // Track connection events
       if (shouldTrack) {
         var _this$analytics, _this$analytics2;
         (_this$analytics = this.analytics) === null || _this$analytics === void 0 || _this$analytics.track(ANALYTICS_EVENTS.CONNECTION_STARTED, eventData);
@@ -153,24 +276,27 @@ class MetaMaskConnector extends BaseEvmConnector {
           duration: Date.now() - startTime
         }));
       }
-      let identityTokenInfo;
       this.emit(CONNECTOR_EVENTS.CONNECTED, {
-        connector: WALLET_CONNECTORS.METAMASK,
+        connectorName: WALLET_CONNECTORS.METAMASK,
         reconnected: this.rehydrated,
-        provider: this.metamaskProvider,
-        identityTokenInfo
+        ethereumProvider: this.evmProvider,
+        solanaWallet: this.solanaProvider
       });
-      if (getIdentityToken) {
-        identityTokenInfo = await this.getIdentityToken();
+      if (getAuthTokenInfo) {
+        await this.getAuthTokenInfo();
       }
-      return this.metamaskProvider;
+      return {
+        ethereumProvider: this.evmProvider,
+        solanaWallet: this.solanaProvider,
+        connectorName: this.name
+      };
     } catch (error) {
-      // ready again to be connected
+      // Ready again to be connected
       this.status = CONNECTOR_STATUS.READY;
       if (!this.rehydrated) this.emit(CONNECTOR_EVENTS.ERRORED, error);
       this.rehydrated = false;
 
-      // track connection events
+      // Track connection events
       if (shouldTrack) {
         var _this$analytics3, _this$analytics4;
         (_this$analytics3 = this.analytics) === null || _this$analytics3 === void 0 || _this$analytics3.track(ANALYTICS_EVENTS.CONNECTION_STARTED, eventData);
@@ -185,18 +311,80 @@ class MetaMaskConnector extends BaseEvmConnector {
   async disconnect(options = {
     cleanup: false
   }) {
-    if (!this.metamaskProvider) throw WalletLoginError.connectionError("MetaMask provider is not available");
-    await super.disconnectSession();
-    if (typeof this.metamaskProvider.removeAllListeners !== "undefined") this.metamaskProvider.removeAllListeners();
-    await this.metamaskSDK.terminate();
+    if (!this.multichainClient) throw WalletLoginError.connectionError("Multichain client is not available");
+    this.checkDisconnectionRequirements();
+    await this.clearWalletSession();
+
+    // Disconnect using the multichain client
+    await this.multichainClient.disconnect();
     if (options.cleanup) {
       this.status = CONNECTOR_STATUS.NOT_READY;
-      this.metamaskProvider = null;
+      this.initializationPromise = null;
+      this.multichainClient = null;
+      this.evmClient = null;
+      this.evmProvider = null;
+      this.solanaClient = null;
+      this.solanaProvider = null;
     } else {
-      // ready to be connected again
+      // Ready to be connected again
       this.status = CONNECTOR_STATUS.READY;
     }
-    await super.disconnect();
+    this.rehydrated = false;
+    this.emit(CONNECTOR_EVENTS.DISCONNECTED);
+  }
+  async getAuthTokenInfo() {
+    var _this$evmProvider2, _this$coreOptions$cha;
+    if (!this.canAuthorize) throw WalletLoginError.notConnectedError();
+
+    // Determine the active chain: prefer Solana if no EVM provider, otherwise use EVM provider's chain
+    const evmChainId = ((_this$evmProvider2 = this.evmProvider) === null || _this$evmProvider2 === void 0 ? void 0 : _this$evmProvider2.chainId) || ((_this$coreOptions$cha = this.coreOptions.chains.find(x => x.chainNamespace === CHAIN_NAMESPACES.EIP155)) === null || _this$coreOptions$cha === void 0 ? void 0 : _this$coreOptions$cha.chainId);
+    const isSolanaOnly = !this.evmProvider && !!this.solanaProvider;
+    const activeChainConfig = isSolanaOnly ? this.coreOptions.chains.find(x => x.chainNamespace === CHAIN_NAMESPACES.SOLANA) : this.evmProvider ? this.coreOptions.chains.find(x => x.chainId === evmChainId) : undefined;
+    if (!activeChainConfig) throw WalletLoginError.connectionError("Chain config is not available");
+    this.status = CONNECTOR_STATUS.AUTHORIZING;
+    this.emit(CONNECTOR_EVENTS.AUTHORIZING, {
+      connector: WALLET_CONNECTORS.METAMASK
+    });
+    const {
+      chainNamespace
+    } = activeChainConfig;
+    const accounts = chainNamespace === CHAIN_NAMESPACES.SOLANA && this.solanaProvider ? this.solanaProvider.accounts.map(a => a.address) : this.evmProvider ? await this.evmProvider.request({
+      method: EVM_METHOD_TYPES.GET_ACCOUNTS
+    }) : [];
+    if (accounts && accounts.length > 0) {
+      const cached = await this.getCachedOrNullAuthTokenInfo(accounts[0]);
+      if (cached) return cached;
+      const authServer = citadelServerUrl(this.coreOptions.authBuildEnv);
+      const payload = {
+        domain: window.location.origin,
+        uri: window.location.href,
+        address: accounts[0],
+        chainId: parseInt(activeChainConfig.chainId, 16),
+        version: "1",
+        nonce: generateSiweNonce(),
+        issuedAt: new Date().toISOString()
+      };
+      const challenge = await signChallenge(payload, chainNamespace, authServer);
+      let signedMessage;
+      if (chainNamespace === CHAIN_NAMESPACES.SOLANA && this.solanaProvider) {
+        signedMessage = await walletSignMessage(this.solanaProvider, challenge, accounts[0]);
+      } else if (this.evmProvider) {
+        const hexChallenge = bytesToHexPrefixedString(utf8ToBytes(challenge));
+        signedMessage = await this.evmProvider.request({
+          method: EVM_METHOD_TYPES.PERSONAL_SIGN,
+          params: [hexChallenge, accounts[0]]
+        });
+      } else {
+        throw WalletLoginError.notConnectedError("No provider available for signing");
+      }
+      return this.verifyAndAuthorize({
+        chainNamespace,
+        signedMessage,
+        challenge,
+        authServer
+      });
+    }
+    throw WalletLoginError.notConnectedError("Not connected with wallet, Please login/connect first");
   }
   async getUserInfo() {
     if (!this.canAuthorize) throw WalletLoginError.notConnectedError("Not connected with wallet, Please login/connect first");
@@ -204,24 +392,32 @@ class MetaMaskConnector extends BaseEvmConnector {
   }
   async switchChain(params, init = false) {
     super.checkSwitchChainRequirements(params, init);
-    const requestSwitchChain = () => this.metamaskProvider.request({
-      method: "wallet_switchEthereumChain",
-      params: [{
-        chainId: params.chainId
-      }]
-    });
-    try {
-      await requestSwitchChain();
-    } catch (error) {
-      // If the error code is 4902, the network needs to be added
-      if ((error === null || error === void 0 ? void 0 : error.code) === 4902) {
-        const chainConfig = this.coreOptions.chains.find(x => x.chainId === params.chainId && [CHAIN_NAMESPACES.EIP155].includes(x.chainNamespace));
-        await this.addChain(chainConfig);
-        await requestSwitchChain();
-      } else {
-        throw error;
-      }
+    const targetChainConfig = this.coreOptions.chains.find(c => c.chainId === params.chainId);
+    if ((targetChainConfig === null || targetChainConfig === void 0 ? void 0 : targetChainConfig.chainNamespace) === CHAIN_NAMESPACES.SOLANA) {
+      // no need to switch chain for Solana
+      return;
+    }
+    await this.ensureInitialized();
+    if (!this.evmClient) {
+      throw WalletLoginError.unsupportedOperation("switchChain requires an EVM client, but no EVM chains are configured.");
     }
+    const chainConfig = this.coreOptions.chains.find(x => x.chainId === params.chainId && [CHAIN_NAMESPACES.EIP155].includes(x.chainNamespace));
+    const chainConfiguration = chainConfig ? {
+      chainId: params.chainId,
+      chainName: chainConfig.displayName,
+      rpcUrls: [chainConfig.rpcTarget],
+      blockExplorerUrls: chainConfig.blockExplorerUrl ? [chainConfig.blockExplorerUrl] : undefined,
+      nativeCurrency: {
+        name: chainConfig.tickerName,
+        symbol: chainConfig.ticker,
+        decimals: chainConfig.decimals || 18
+      },
+      iconUrls: chainConfig.logo ? [chainConfig.logo] : undefined
+    } : undefined;
+    await this.evmClient.switchChain({
+      chainId: params.chainId,
+      chainConfiguration
+    });
   }
   async enableMFA() {
     throw new Error("Method Not implemented");
@@ -229,25 +425,32 @@ class MetaMaskConnector extends BaseEvmConnector {
   async manageMFA() {
     throw new Error("Method Not implemented");
   }
-  async addChain(chainConfig) {
-    if (!this.metamaskProvider) throw WalletLoginError.connectionError("Injected provider is not available");
-    await this.metamaskProvider.request({
-      method: "wallet_addEthereumChain",
-      params: [{
-        chainId: chainConfig.chainId,
-        chainName: chainConfig.displayName,
-        rpcUrls: [chainConfig.rpcTarget],
-        blockExplorerUrls: [chainConfig.blockExplorerUrl],
-        nativeCurrency: {
-          name: chainConfig.tickerName,
-          symbol: chainConfig.ticker,
-          decimals: chainConfig.decimals || 18
-        },
-        iconUrls: [chainConfig.logo]
-      }]
-    });
+
+  /**
+   * Ensures the connector is initialized
+   */
+  async ensureInitialized() {
+    if (!this.initializationPromise) {
+      throw WalletLoginError.notConnectedError("Connector is not initialized. Call init() first.");
+    }
+    await this.initializationPromise;
   }
 }
+
+/**
+ * Factory function to create a MetaMask connector
+ *
+ * @param params - Configuration options for the MetaMask SDK
+ * @returns A connector function that creates a MetaMaskConnector instance
+ *
+ * @example
+ * ```typescript
+ * const connector = metaMaskConnector({
+ *   dapp: { name: 'My DApp', url: 'https://mydapp.com' },
+ *   debug: true,
+ * });
+ * ```
+ */
 const metaMaskConnector = params => {
   return ({
     coreOptions,

package/dist/lib.esm/connectors/utils.js

@@ -1,4 +1,6 @@
-import { safeatob } from '@web3auth/auth';
+import { generatePrivate } from '@toruslabs/eccrypto';
+import { bytesToHexPrefixedString } from '@toruslabs/metadata-helpers';
+import { base64toJSON } from '@web3auth/auth';
 
 /**
  * Extracts a name for the site from the DOM
@@ -63,9 +65,12 @@ async function getSiteIcon(window) {
 function parseToken(token) {
   const [header, payload] = token.split(".");
   return {
-    header: JSON.parse(safeatob(header)),
-    payload: JSON.parse(safeatob(payload))
+    header: base64toJSON(header),
+    payload: base64toJSON(payload)
   };
 }
+const generateNonce = () => {
+  return bytesToHexPrefixedString(generatePrivate());
+};
 
-export { getSiteIcon, getSiteName, parseToken };
+export { generateNonce, getSiteIcon, getSiteName, parseToken };