@web3auth/no-modal 11.1.0 → 11.3.0

package/dist/lib.esm/connectors/base-account-connector/baseAccountConnector.js

@@ -0,0 +1,198 @@
+import _objectSpread from '@babel/runtime/helpers/objectSpread2';
+import _defineProperty from '@babel/runtime/helpers/defineProperty';
+import { getSiteName, getSiteIcon } from '../utils.js';
+import { BaseEvmConnector } from '../base-evm-connector/baseEvmConnector.js';
+import { CONNECTOR_NAMESPACES } from '../../base/chain/IChainInterface.js';
+import { WALLET_CONNECTORS } from '../../base/wallet/index.js';
+import { WalletLoginError, Web3AuthError } from '../../base/errors/index.js';
+import { CHAIN_NAMESPACES } from '@toruslabs/base-controllers';
+import { CONNECTOR_CATEGORY, CONNECTOR_STATUS, CONNECTOR_EVENTS } from '../../base/connector/constants.js';
+
+class BaseAccountConnector extends BaseEvmConnector {
+  constructor(connectorOptions) {
+    super(connectorOptions);
+    _defineProperty(this, "connectorNamespace", CONNECTOR_NAMESPACES.EIP155);
+    _defineProperty(this, "currentChainNamespace", CHAIN_NAMESPACES.EIP155);
+    _defineProperty(this, "type", CONNECTOR_CATEGORY.EXTERNAL);
+    _defineProperty(this, "name", WALLET_CONNECTORS.BASE_ACCOUNT);
+    _defineProperty(this, "status", CONNECTOR_STATUS.NOT_READY);
+    _defineProperty(this, "baseAccountProvider", null);
+    _defineProperty(this, "baseAccountOptions", {
+      appName: "Web3Auth"
+    });
+    this.baseAccountOptions = _objectSpread(_objectSpread({}, this.baseAccountOptions), connectorOptions.connectorSettings);
+  }
+  get provider() {
+    if (this.status !== CONNECTOR_STATUS.NOT_READY && this.baseAccountProvider) {
+      return this.baseAccountProvider;
+    }
+    return null;
+  }
+  set provider(_) {
+    throw new Error("Not implemented");
+  }
+  async init(options) {
+    await super.init(options);
+    const chainConfig = this.coreOptions.chains.find(x => x.chainId === options.chainId);
+    super.checkInitializationRequirements({
+      chainConfig
+    });
+    const {
+      createBaseAccountSDK
+    } = await import('@base-org/account');
+    let appName = this.baseAccountOptions.appName || "Web3Auth";
+    let appLogoUrl = this.baseAccountOptions.appLogoUrl || "";
+    if (typeof window !== "undefined") {
+      if (!this.baseAccountOptions.appName) {
+        appName = getSiteName(window) || "Web3Auth";
+      }
+      if (!this.baseAccountOptions.appLogoUrl) {
+        appLogoUrl = (await getSiteIcon(window)) || "";
+      }
+    }
+    const appChainIds = this.coreOptions.chains.filter(x => x.chainNamespace === CHAIN_NAMESPACES.EIP155).map(x => Number.parseInt(x.chainId, 16));
+    const sdk = createBaseAccountSDK(_objectSpread(_objectSpread({}, this.baseAccountOptions), {}, {
+      appName,
+      appLogoUrl: appLogoUrl || null,
+      appChainIds: this.baseAccountOptions.appChainIds || appChainIds
+    }));
+    this.baseAccountProvider = sdk.getProvider();
+    this.status = CONNECTOR_STATUS.READY;
+    this.emit(CONNECTOR_EVENTS.READY, WALLET_CONNECTORS.BASE_ACCOUNT);
+    try {
+      if (options.autoConnect) {
+        this.rehydrated = true;
+        const connection = await this.connect({
+          chainId: options.chainId,
+          getAuthTokenInfo: options.getAuthTokenInfo
+        });
+        if (!connection) {
+          this.rehydrated = false;
+          throw WalletLoginError.connectionError("Failed to rehydrate.");
+        }
+      }
+    } catch (error) {
+      this.emit(CONNECTOR_EVENTS.REHYDRATION_ERROR, error);
+    }
+  }
+  async connect({
+    chainId,
+    getAuthTokenInfo
+  }) {
+    super.checkConnectionRequirements();
+    if (!this.baseAccountProvider) throw WalletLoginError.notConnectedError("Connector is not initialized");
+    this.status = CONNECTOR_STATUS.CONNECTING;
+    this.emit(CONNECTOR_EVENTS.CONNECTING, {
+      connector: WALLET_CONNECTORS.BASE_ACCOUNT
+    });
+    try {
+      const chainConfig = this.coreOptions.chains.find(x => x.chainId === chainId);
+      if (!chainConfig) throw WalletLoginError.connectionError("Chain config is not available");
+      await this.baseAccountProvider.request({
+        method: "eth_requestAccounts"
+      });
+      const currentChainId = await this.baseAccountProvider.request({
+        method: "eth_chainId"
+      });
+      if (currentChainId !== chainConfig.chainId) {
+        await this.switchChain(chainConfig, true);
+      }
+      this.status = CONNECTOR_STATUS.CONNECTED;
+      if (!this.provider) throw WalletLoginError.notConnectedError("Failed to connect with provider");
+      this.provider.once("disconnect", () => {
+        this.disconnect();
+      });
+      this.emit(CONNECTOR_EVENTS.CONNECTED, {
+        connectorName: WALLET_CONNECTORS.BASE_ACCOUNT,
+        reconnected: this.rehydrated,
+        ethereumProvider: this.provider,
+        solanaWallet: null,
+        connectorNamespace: this.connectorNamespace
+      });
+      await this.authorizeOrDisconnect(getAuthTokenInfo);
+      return {
+        ethereumProvider: this.provider,
+        solanaWallet: null,
+        connectorName: this.name,
+        connectorNamespace: this.connectorNamespace
+      };
+    } catch (error) {
+      this.status = CONNECTOR_STATUS.READY;
+      if (!this.rehydrated) this.emit(CONNECTOR_EVENTS.ERRORED, error);
+      this.rehydrated = false;
+      if (error instanceof Web3AuthError) throw error;
+      throw WalletLoginError.connectionError("Failed to login with Base Account", error);
+    }
+  }
+  async disconnect(options = {
+    cleanup: false
+  }) {
+    var _this$provider;
+    await super.disconnectSession();
+    (_this$provider = this.provider) === null || _this$provider === void 0 || _this$provider.removeAllListeners();
+    if (options.cleanup) {
+      this.status = CONNECTOR_STATUS.NOT_READY;
+      this.baseAccountProvider = null;
+    } else {
+      this.status = CONNECTOR_STATUS.READY;
+    }
+    await super.disconnect();
+  }
+  async getUserInfo() {
+    if (!this.canAuthorize) throw WalletLoginError.notConnectedError("Not connected with wallet, Please login/connect first");
+    return {};
+  }
+  async switchChain(params, init = false) {
+    super.checkSwitchChainRequirements(params, init);
+    try {
+      var _this$baseAccountProv;
+      await ((_this$baseAccountProv = this.baseAccountProvider) === null || _this$baseAccountProv === void 0 ? void 0 : _this$baseAccountProv.request({
+        method: "wallet_switchEthereumChain",
+        params: [{
+          chainId: params.chainId
+        }]
+      }));
+    } catch (switchError) {
+      if (switchError.code === 4902) {
+        var _this$baseAccountProv2;
+        const chainConfig = this.coreOptions.chains.find(x => x.chainId === params.chainId);
+        if (!chainConfig) throw WalletLoginError.connectionError("Chain config is not available");
+        await ((_this$baseAccountProv2 = this.baseAccountProvider) === null || _this$baseAccountProv2 === void 0 ? void 0 : _this$baseAccountProv2.request({
+          method: "wallet_addEthereumChain",
+          params: [{
+            chainId: chainConfig.chainId,
+            rpcUrls: [chainConfig.rpcTarget],
+            chainName: chainConfig.displayName,
+            nativeCurrency: {
+              name: chainConfig.tickerName,
+              symbol: chainConfig.ticker,
+              decimals: chainConfig.decimals || 18
+            },
+            blockExplorerUrls: [chainConfig.blockExplorerUrl],
+            iconUrls: [chainConfig.logo]
+          }]
+        }));
+        return;
+      }
+      throw switchError;
+    }
+  }
+  async enableMFA() {
+    throw new Error("Method Not implemented");
+  }
+  async manageMFA() {
+    throw new Error("Method Not implemented");
+  }
+}
+const baseAccountConnector = params => {
+  return ({
+    coreOptions
+  }) => {
+    return new BaseAccountConnector({
+      connectorSettings: params,
+      coreOptions
+    });
+  };
+};
+
+export { baseAccountConnector };

package/dist/lib.esm/connectors/base-account-connector/index.js

@@ -0,0 +1 @@
+export { baseAccountConnector } from './baseAccountConnector.js';

package/dist/lib.esm/connectors/coinbase-connector/coinbaseConnector.js

@@ -99,15 +99,15 @@ class CoinbaseConnector extends BaseEvmConnector {
         connectorName: WALLET_CONNECTORS.COINBASE,
         reconnected: this.rehydrated,
         ethereumProvider: this.provider,
-        solanaWallet: null
+        solanaWallet: null,
+        connectorNamespace: this.connectorNamespace
       });
-      if (getAuthTokenInfo) {
-        await this.getAuthTokenInfo();
-      }
+      await this.authorizeOrDisconnect(getAuthTokenInfo);
       return {
         ethereumProvider: this.provider,
         solanaWallet: null,
-        connectorName: this.name
+        connectorName: this.name,
+        connectorNamespace: this.connectorNamespace
       };
     } catch (error) {
       // ready again to be connected

package/dist/lib.esm/connectors/injected-evm-connector/injectedEvmConnector.js

@@ -89,19 +89,20 @@ class InjectedEvmConnector extends BaseEvmConnector {
         }
       };
       this.injectedProvider.on("accountsChanged", accountDisconnectHandler);
+      const connectorNamespace = this.connectorNamespace;
       this.emit(CONNECTOR_EVENTS.CONNECTED, {
         connectorName: this.name,
         reconnected: this.rehydrated,
         ethereumProvider: this.injectedProvider,
-        solanaWallet: null
+        solanaWallet: null,
+        connectorNamespace
       });
-      if (getAuthTokenInfo) {
-        await this.getAuthTokenInfo();
-      }
+      await this.authorizeOrDisconnect(getAuthTokenInfo);
       return {
         ethereumProvider: this.injectedProvider,
         solanaWallet: null,
-        connectorName: this.name
+        connectorName: this.name,
+        connectorNamespace
       };
     } catch (error) {
       // ready again to be connected

package/dist/lib.esm/connectors/injected-solana-connector/walletStandardConnector.js

@@ -76,19 +76,20 @@ class WalletStandardConnector extends BaseSolanaConnector {
       }
       if (this.wallet.accounts.length === 0) throw WalletLoginError.connectionError();
       this.status = CONNECTOR_STATUS.CONNECTED;
+      const connectorNamespace = this.connectorNamespace;
       this.emit(CONNECTOR_EVENTS.CONNECTED, {
         connectorName: this.name,
         reconnected: this.rehydrated,
         ethereumProvider: null,
-        solanaWallet: this.solanaWallet
+        solanaWallet: this.solanaWallet,
+        connectorNamespace
       });
-      if (getAuthTokenInfo) {
-        await this.getAuthTokenInfo();
-      }
+      await this.authorizeOrDisconnect(getAuthTokenInfo);
       return {
         ethereumProvider: null,
         solanaWallet: this.solanaWallet,
-        connectorName: this.name
+        connectorName: this.name,
+        connectorNamespace
       };
     } catch (error) {
       // ready again to be connected

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

@@ -15,6 +15,7 @@ import { getCaipChainId, citadelServerUrl } from '../../base/utils.js';
 import { WalletLoginError, isUserRejectedError, WalletOperationsError, Web3AuthError } from '../../base/errors/index.js';
 import { ANALYTICS_EVENTS } from '../../base/analytics.js';
 import { getSolanaChainByChainConfig, walletSignMessage } from '../../base/wallet/solana.js';
+import { log } from '../../base/loglevel.js';
 import { BaseConnector } from '../../base/connector/baseConnector.js';
 import { CONNECTOR_CATEGORY, CONNECTOR_STATUS, CONNECTOR_EVENTS } from '../../base/connector/constants.js';
 
@@ -22,6 +23,11 @@ import { CONNECTOR_CATEGORY, CONNECTOR_STATUS, CONNECTOR_EVENTS } from '../../ba
  * Configuration options for the MetaMask connector using \@metamask/connect-evm
  */
 
+// `@metamask/connect-evm` announces its SDK-backed provider over EIP-6963 with this
+// RDNS value. Web3Auth uses the dedicated `metaMaskConnector` for MetaMask, so MIPD
+// discovery should ignore this provider to avoid treating the QR/deeplink transport
+// as a native injected wallet.
+const METAMASK_ERC_6963_PROVIDER_RDNS = "io.metamask.mmc";
 class MetaMaskConnector extends BaseConnector {
   constructor(connectorOptions) {
     super(connectorOptions);
@@ -197,13 +203,25 @@ class MetaMaskConnector extends BaseConnector {
     if (coreStatus === "connected" && options.autoConnect) {
       this.status = CONNECTOR_STATUS.CONNECTED;
       this.rehydrated = true;
+
+      // Force sync the chain state before connect with rehydrated state.
+      // during rehydration, `createEVMClient` (from above) cause re-creating session for connected the evm provider,
+      // triggering `switchChain` internally and unintentionally update the connector data with the new chain id.
+      // This creates issue in rehydration flow, where Web3Auth connects to the incorrect chain id, not the rehydrated chain id.
+      // Force sync the chain state with the rehydrated chain id to avoid this issue.
+      await this.forceSyncChainState(chainConfig);
       this.emit(CONNECTOR_EVENTS.CONNECTED, {
         connectorName: WALLET_CONNECTORS.METAMASK,
         reconnected: true,
         ethereumProvider: this.evmProvider,
-        solanaWallet: this.solanaProvider
+        solanaWallet: this.solanaProvider,
+        connectorNamespace: this.connectorNamespace
       });
-      if (options.getAuthTokenInfo) await this.getAuthTokenInfo(options.chainId);
+      try {
+        await this.authorizeOrDisconnect(options.getAuthTokenInfo, options.chainId);
+      } catch (error) {
+        this.emit(CONNECTOR_EVENTS.REHYDRATION_ERROR, error);
+      }
     } else if (coreStatus === "connected" || coreStatus === "loaded" || coreStatus === "disconnected" || coreStatus === "pending") {
       this.status = CONNECTOR_STATUS.READY;
       this.emit(CONNECTOR_EVENTS.READY, WALLET_CONNECTORS.METAMASK);
@@ -273,7 +291,7 @@ class MetaMaskConnector extends BaseConnector {
 
       // sync the chain state after connect
       // metamask might not be connected to the requested chain, so we need to sync the chain state to/from Web3Auth state after connect.
-      await this.syncChainStateAfterConnect(chainConfig);
+      await this.forceSyncChainState(chainConfig);
 
       // check if connected
       if (this.multichainClient.status !== "connected") {
@@ -293,15 +311,15 @@ class MetaMaskConnector extends BaseConnector {
         connectorName: WALLET_CONNECTORS.METAMASK,
         reconnected: this.rehydrated,
         ethereumProvider: this.evmProvider,
-        solanaWallet: this.solanaProvider
+        solanaWallet: this.solanaProvider,
+        connectorNamespace: this.connectorNamespace
       });
-      if (getAuthTokenInfo) {
-        await this.getAuthTokenInfo(chainId);
-      }
+      await this.authorizeOrDisconnect(getAuthTokenInfo, chainId);
       return {
         ethereumProvider: this.evmProvider,
         solanaWallet: this.solanaProvider,
-        connectorName: this.name
+        connectorName: this.name,
+        connectorNamespace: this.connectorNamespace
       };
     } catch (error) {
       // Ready again to be connected
@@ -327,10 +345,12 @@ class MetaMaskConnector extends BaseConnector {
   }) {
     if (!this.multichainClient) throw WalletLoginError.connectionError("Multichain client is not available");
     this.checkDisconnectionRequirements();
-    await this.clearWalletSession();
+    await this.clearMultichainWalletSessions();
 
     // Disconnect using the multichain client
-    await this.multichainClient.disconnect();
+    if (this.multichainClient.status === "connected") {
+      await this.multichainClient.disconnect();
+    }
     if (options.cleanup) {
       this.status = CONNECTOR_STATUS.NOT_READY;
       this.initializationPromise = null;
@@ -386,32 +406,41 @@ class MetaMaskConnector extends BaseConnector {
   }
   async switchChain(params, init = false) {
     super.checkSwitchChainRequirements(params, init);
+    await this.ensureInitialized();
     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
+    if (!targetChainConfig) throw WalletLoginError.connectionError("Chain config is not available");
+    if (targetChainConfig.chainNamespace === CHAIN_NAMESPACES.SOLANA) {
+      if (!this.solanaWallet) {
+        throw WalletLoginError.unsupportedOperation("switchChain requires a Solana client, but no Solana chains are configured.");
+      }
+
+      // For solana case, we don't have the `switchChain` method like `evmClient`.
+      // So, we just need to sync with the connected solana chain to the Web3Auth state.
+      await this.forceSyncChainState(targetChainConfig);
       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 ? {
+    const chainConfiguration = targetChainConfig ? {
       chainId: params.chainId,
-      chainName: chainConfig.displayName,
-      rpcUrls: [chainConfig.rpcTarget],
-      blockExplorerUrls: chainConfig.blockExplorerUrl ? [chainConfig.blockExplorerUrl] : undefined,
+      chainName: targetChainConfig.displayName,
+      rpcUrls: [targetChainConfig.rpcTarget],
+      blockExplorerUrls: targetChainConfig.blockExplorerUrl ? [targetChainConfig.blockExplorerUrl] : undefined,
       nativeCurrency: {
-        name: chainConfig.tickerName,
-        symbol: chainConfig.ticker,
-        decimals: chainConfig.decimals || 18
+        name: targetChainConfig.tickerName,
+        symbol: targetChainConfig.ticker,
+        decimals: targetChainConfig.decimals || 18
       },
-      iconUrls: chainConfig.logo ? [chainConfig.logo] : undefined
+      iconUrls: targetChainConfig.logo ? [targetChainConfig.logo] : undefined
     } : undefined;
     await this.evmClient.switchChain({
       chainId: params.chainId,
       chainConfiguration
     });
+    this.updateConnectorData({
+      chainId: params.chainId
+    });
   }
   async generateChallengeAndSign(authServerUrl, accounts, chainId) {
     const activeChainConfig = this.resolveAuthChainConfig(chainId);
@@ -470,7 +499,12 @@ class MetaMaskConnector extends BaseConnector {
     }
     await this.initializationPromise;
   }
-  async syncChainStateAfterConnect(chainConfig) {
+
+  /**
+   * Syncs the chain state with the Web3Auth state.
+   * @param chainConfig - The chain config to sync.
+   */
+  async forceSyncChainState(chainConfig) {
     var _this$evmProvider2;
     // EVM connectors can switch chains, so align the wallet with the requested chain
     // before Web3Auth persists the active chain in controller state.
@@ -491,13 +525,9 @@ class MetaMaskConnector extends BaseConnector {
         if (!connectedChainConfig) {
           throw WalletLoginError.connectionError("Connected chain is not available in the chains config");
         }
-        if (connectedChainConfig.chainId !== chainConfig.chainId) {
-          // since, switchChain is not supported for solana (in metamask connect),
-          // we will make use of the connector data to update the Web3Auth state.
-          this.updateConnectorData({
-            chainId: connectedChainConfig.chainId
-          });
-        }
+        this.updateConnectorData({
+          chainId: chainConfig.chainId
+        });
       }
     }
   }
@@ -512,6 +542,31 @@ class MetaMaskConnector extends BaseConnector {
     // Keep the old fallback for callers that do not pass a chainId yet.
     return isSolanaOnly ? this.coreOptions.chains.find(x => x.chainNamespace === CHAIN_NAMESPACES.SOLANA) : this.evmProvider ? this.coreOptions.chains.find(x => x.chainId === evmChainId) : undefined;
   }
+  async clearMultichainWalletSessions() {
+    const addresses = new Set();
+    if (this.evmProvider) {
+      const evmAccounts = await this.evmProvider.request({
+        method: EVM_METHOD_TYPES.GET_ACCOUNTS
+      });
+      evmAccounts.forEach(account => addresses.add(account));
+    }
+    if (this.solanaProvider) {
+      this.solanaProvider.accounts.forEach(account => addresses.add(account.address));
+    }
+    if (addresses.size === 0) {
+      await this.clearWalletSession();
+      return;
+    }
+
+    // MetaMask can authorize both EVM and Solana accounts in one session, but BaseConnector
+    // caches SIWW tokens under one address at a time. Clear every connected address on disconnect.
+    for (const address of addresses) {
+      this.initSessionManager(address);
+      await this.clearWalletSession().catch(error => {
+        log.error("Failed to clear multichain wallet session", error);
+      });
+    }
+  }
 }
 
 /**
@@ -541,4 +596,4 @@ const metaMaskConnector = params => {
   };
 };
 
-export { metaMaskConnector };
+export { METAMASK_ERC_6963_PROVIDER_RDNS, metaMaskConnector };

package/dist/lib.esm/connectors/wallet-connect-v2-connector/walletConnectV2Connector.js

@@ -169,7 +169,7 @@ class WalletConnectV2Connector extends BaseConnector {
           }));
         }
       };
-
+      const connectorNamespace = this.connectorNamespace;
       // if already connected
       if (this.connected) {
         await this.onConnectHandler({
@@ -179,7 +179,8 @@ class WalletConnectV2Connector extends BaseConnector {
         return {
           ethereumProvider: this.provider,
           solanaWallet: this._solanaWallet,
-          connectorName: this.name
+          connectorName: this.name,
+          connectorNamespace
         };
       }
       if (this.status !== CONNECTOR_STATUS.CONNECTING) {
@@ -192,7 +193,8 @@ class WalletConnectV2Connector extends BaseConnector {
       return {
         ethereumProvider: this.provider,
         solanaWallet: this._solanaWallet,
-        connectorName: this.name
+        connectorName: this.name,
+        connectorNamespace
       };
     } catch (error) {
       log.error("Wallet connect v2 connector error while connecting", error);
@@ -473,11 +475,10 @@ class WalletConnectV2Connector extends BaseConnector {
       connectorName: WALLET_CONNECTORS.WALLET_CONNECT_V2,
       reconnected: this.rehydrated,
       ethereumProvider: this.provider,
-      solanaWallet: this._solanaWallet
+      solanaWallet: this._solanaWallet,
+      connectorNamespace: this.connectorNamespace
     });
-    if (getAuthTokenInfo) {
-      await this.getAuthTokenInfo();
-    }
+    await this.authorizeOrDisconnect(getAuthTokenInfo);
   }
   subscribeEvents() {
     if (!this.connector) throw WalletInitializationError.notReady("Wallet connector is not ready yet");

package/dist/lib.esm/index.js

@@ -19,6 +19,7 @@ export { DEFAULT_EIP155_METHODS, DEFAULT_EIP_155_EVENTS, DEFAULT_SOLANA_EVENTS,
 export { EIP1193_EVENTS } from './providers/base-provider/utils.js';
 export { EIP_7702_SUPPORTED_SMART_ACCOUNTS, LOGIN_MODE, MODAL_SIGN_IN_METHODS, SMART_ACCOUNT_WALLET_SCOPE, SOLANA_CAIP_CHAIN_MAP, WALLET_REGISTRY_URL, WEB3AUTH_STATE_STORAGE_KEY, WIDGET_TYPE } from './base/constants.js';
 export { EVM_PLUGINS, PLUGIN_EVENTS, PLUGIN_NAMESPACES, PLUGIN_STATUS, SOLANA_PLUGINS, WALLET_PLUGINS } from './base/plugin/IPlugin.js';
+export { METAMASK_ERC_6963_PROVIDER_RDNS, metaMaskConnector } from './connectors/metamask-connector/metamaskConnector.js';
 export { PROVIDER_EVENTS } from './base/provider/IProvider.js';
 export { WalletConnectV2Provider } from './connectors/wallet-connect-v2-connector/WalletConnectV2Provider.js';
 export { WalletInitializationError, WalletLoginError, WalletOperationsError, WalletProviderError, Web3AuthError, isUserRejectedError } from './base/errors/index.js';
@@ -39,7 +40,6 @@ export { hasSolanaWalletStandardFeatures } from './connectors/injected-solana-co
 export { injectedEvmConnector } from './connectors/injected-evm-connector/injectedEvmConnector.js';
 export { log } from './base/loglevel.js';
 export { makeAccountLinkingRequest, makeAccountUnlinkingRequest } from './account-linking/rest.js';
-export { metaMaskConnector } from './connectors/metamask-connector/metamaskConnector.js';
 export { walletConnectV2Connector } from './connectors/wallet-connect-v2-connector/walletConnectV2Connector.js';
 export { walletServicesPlugin } from './plugins/wallet-services-plugin/plugin.js';
 export { walletStandardConnector } from './connectors/injected-solana-connector/walletStandardConnector.js';