@web3auth/no-modal 9.7.0 → 10.0.0-alpha.1

package/dist/lib.cjs/noModal.js

@@ -3,356 +3,416 @@
 var _objectSpread = require('@babel/runtime/helpers/objectSpread2');
 var _defineProperty = require('@babel/runtime/helpers/defineProperty');
 var auth = require('@web3auth/auth');
-var authAdapter = require('@web3auth/auth-adapter');
-var base = require('@web3auth/base');
-var baseProvider = require('@web3auth/base-provider');
-var deepmerge = require('deepmerge');
+var authConnector = require('./connectors/auth-connector/authConnector.js');
+var config = require('./base/chain/config.js');
+var IChainInterface = require('./base/chain/IChainInterface.js');
+var index = require('./base/errors/index.js');
+var loglevel = require('./base/loglevel.js');
+var utils = require('./base/utils.js');
+var index$1 = require('./base/wallet/index.js');
+var CommonJRPCProvider = require('./providers/base-provider/CommonJRPCProvider.js');
+var utils$1 = require('./base/connector/utils.js');
+var IPlugin = require('./base/plugin/IPlugin.js');
+var constants = require('./base/connector/constants.js');
 
-const ADAPTER_CACHE_KEY = "Web3Auth-cachedAdapter";
+const CONNECTOR_CACHE_KEY = "Web3Auth-cachedConnector";
+const CURRENT_CHAIN_CACHE_KEY = "Web3Auth-currentChain";
 class Web3AuthNoModal extends auth.SafeEventEmitter {
   constructor(options) {
-    var _options$chainConfig, _options$chainConfig2, _options$chainConfig3, _options$chainConfig4;
     super();
     _defineProperty(this, "coreOptions", void 0);
-    _defineProperty(this, "connectedAdapterName", null);
-    _defineProperty(this, "status", base.ADAPTER_STATUS.NOT_READY);
-    _defineProperty(this, "cachedAdapter", null);
-    _defineProperty(this, "walletAdapters", {});
+    _defineProperty(this, "connectedConnectorName", null);
+    _defineProperty(this, "status", constants.CONNECTOR_STATUS.NOT_READY);
+    _defineProperty(this, "cachedConnector", null);
+    _defineProperty(this, "currentChainId", void 0);
+    _defineProperty(this, "connectors", []);
     _defineProperty(this, "commonJRPCProvider", null);
     _defineProperty(this, "plugins", {});
     _defineProperty(this, "storage", "localStorage");
-    if (!options.clientId) throw base.WalletInitializationError.invalidParams("Please provide a valid clientId in constructor");
-    if (options.enableLogging) base.log.enableAll();else base.log.setLevel("error");
-    if (!options.privateKeyProvider && !options.chainConfig) {
-      throw base.WalletInitializationError.invalidParams("Please provide chainConfig or privateKeyProvider");
+    if (!options.clientId) throw index.WalletInitializationError.invalidParams("Please provide a valid clientId in constructor");
+    if (options.enableLogging) loglevel.log.enableAll();else loglevel.log.setLevel("error");
+    // TODO: This is fine. we get chains from project config. we can throw in init instead
+    if (!options.chains || options.chains.length === 0) {
+      throw index.WalletInitializationError.invalidParams("Please provide chains");
     }
-    options.chainConfig = options.chainConfig || options.privateKeyProvider.currentChainConfig;
-    if (!((_options$chainConfig = options.chainConfig) !== null && _options$chainConfig !== void 0 && _options$chainConfig.chainNamespace) || !Object.values(base.CHAIN_NAMESPACES).includes((_options$chainConfig2 = options.chainConfig) === null || _options$chainConfig2 === void 0 ? void 0 : _options$chainConfig2.chainNamespace)) throw base.WalletInitializationError.invalidParams("Please provide a valid chainNamespace in chainConfig");
-    if (options.storageKey === "session") this.storage = "sessionStorage";
-    this.cachedAdapter = base.storageAvailable(this.storage) ? window[this.storage].getItem(ADAPTER_CACHE_KEY) : null;
+    const {
+      chains
+    } = options;
+    // validate chain namespace of each chain config
+    for (const chain of chains) {
+      if (!chain.chainNamespace || !Object.values(IChainInterface.CHAIN_NAMESPACES).includes(chain.chainNamespace)) throw index.WalletInitializationError.invalidParams("Please provide a valid chainNamespace in chains");
+    }
+    if (options.storageType === "session") this.storage = "sessionStorage";
     this.coreOptions = _objectSpread(_objectSpread({}, options), {}, {
-      chainConfig: _objectSpread(_objectSpread({}, base.getChainConfig((_options$chainConfig3 = options.chainConfig) === null || _options$chainConfig3 === void 0 ? void 0 : _options$chainConfig3.chainNamespace, (_options$chainConfig4 = options.chainConfig) === null || _options$chainConfig4 === void 0 ? void 0 : _options$chainConfig4.chainId, options.clientId) || {}), options.chainConfig)
+      chains: chains.map(chain => _objectSpread(_objectSpread({}, config.getChainConfig(chain === null || chain === void 0 ? void 0 : chain.chainNamespace, chain === null || chain === void 0 ? void 0 : chain.chainId, options.clientId) || {}), chain))
     });
-    this.subscribeToAdapterEvents = this.subscribeToAdapterEvents.bind(this);
+    this.currentChainId = options.defaultChainId || chains[0].chainId;
+  }
+  get currentChain() {
+    return this.coreOptions.chains.find(chain => chain.chainId === this.currentChainId);
   }
   get connected() {
-    return Boolean(this.connectedAdapterName);
+    return Boolean(this.connectedConnector);
   }
   get provider() {
-    if (this.status !== base.ADAPTER_STATUS.NOT_READY && this.commonJRPCProvider) {
+    if (this.status !== constants.CONNECTOR_STATUS.NOT_READY && this.commonJRPCProvider) {
       return this.commonJRPCProvider;
     }
     return null;
   }
+  get connectedConnector() {
+    return this.connectors.find(connector => connector.name === this.connectedConnectorName) || null;
+  }
   set provider(_) {
     throw new Error("Not implemented");
   }
   async init() {
-    this.commonJRPCProvider = await baseProvider.CommonJRPCProvider.getProviderInstance({
-      chainConfig: this.coreOptions.chainConfig
-    });
+    this.initCachedConnectorAndChainId();
+
+    // get project config
     let projectConfig;
     try {
       var _this$coreOptions$acc;
-      projectConfig = await base.fetchProjectConfig(this.coreOptions.clientId, this.coreOptions.web3AuthNetwork, (_this$coreOptions$acc = this.coreOptions.accountAbstractionProvider) === null || _this$coreOptions$acc === void 0 ? void 0 : _this$coreOptions$acc.config.smartAccountInit.name);
+      projectConfig = await utils.fetchProjectConfig(this.coreOptions.clientId, this.coreOptions.web3AuthNetwork, (_this$coreOptions$acc = this.coreOptions.accountAbstractionConfig) === null || _this$coreOptions$acc === void 0 ? void 0 : _this$coreOptions$acc.smartAccountType);
     } catch (e) {
-      base.log.error("Failed to fetch project configurations", e);
-      throw base.WalletInitializationError.notReady("failed to fetch project configurations", e);
+      loglevel.log.error("Failed to fetch project configurations", e);
+      throw index.WalletInitializationError.notReady("failed to fetch project configurations", e);
     }
-    const initPromises = Object.keys(this.walletAdapters).map(async adapterName => {
-      this.subscribeToAdapterEvents(this.walletAdapters[adapterName]);
-      // if adapter doesn't have any chain config yet then set it based on provided namespace and chainId.
-      // if no chainNamespace or chainId is being provided, it will connect with mainnet.
-      if (!this.walletAdapters[adapterName].chainConfigProxy) {
-        const providedChainConfig = this.coreOptions.chainConfig;
-        if (!providedChainConfig.chainNamespace) throw base.WalletInitializationError.invalidParams("Please provide chainNamespace in chainConfig");
-        this.walletAdapters[adapterName].setAdapterSettings({
-          chainConfig: providedChainConfig,
-          sessionTime: this.coreOptions.sessionTime,
-          clientId: this.coreOptions.clientId,
-          web3AuthNetwork: this.coreOptions.web3AuthNetwork,
-          useCoreKitKey: this.coreOptions.useCoreKitKey
-        });
-      } else {
-        this.walletAdapters[adapterName].setAdapterSettings({
-          sessionTime: this.coreOptions.sessionTime,
-          clientId: this.coreOptions.clientId,
-          web3AuthNetwork: this.coreOptions.web3AuthNetwork,
-          useCoreKitKey: this.coreOptions.useCoreKitKey
-        });
-      }
-      if (adapterName === base.WALLET_ADAPTERS.AUTH) {
-        const authAdapter$1 = this.walletAdapters[adapterName];
-        const {
-          whitelabel
-        } = projectConfig;
-        this.coreOptions.uiConfig = deepmerge(base.cloneDeep(whitelabel || {}), this.coreOptions.uiConfig || {});
-        if (!this.coreOptions.uiConfig.mode) this.coreOptions.uiConfig.mode = "light";
-        const {
-          sms_otp_enabled: smsOtpEnabled,
-          whitelist,
-          key_export_enabled: keyExportEnabled
-        } = projectConfig;
-        if (smsOtpEnabled !== undefined) {
-          authAdapter$1.setAdapterSettings({
-            loginConfig: {
-              [authAdapter.LOGIN_PROVIDER.SMS_PASSWORDLESS]: {
-                showOnModal: smsOtpEnabled,
-                showOnDesktop: smsOtpEnabled,
-                showOnMobile: smsOtpEnabled,
-                showOnSocialBackupFactor: smsOtpEnabled
-              }
-            }
-          });
-        }
-        if (whitelist) {
-          authAdapter$1.setAdapterSettings({
-            originData: whitelist.signed_urls
-          });
-        }
-        if (typeof keyExportEnabled === "boolean") {
-          this.coreOptions.privateKeyProvider.setKeyExportFlag(keyExportEnabled);
-          // dont know if this is required or not.
-          this.commonJRPCProvider.setKeyExportFlag(keyExportEnabled);
-        }
-        if (this.coreOptions.privateKeyProvider) {
-          if (authAdapter$1.currentChainNamespace !== this.coreOptions.privateKeyProvider.currentChainConfig.chainNamespace) {
-            throw base.WalletInitializationError.incompatibleChainNameSpace("private key provider is not compatible with provided chainNamespace for auth adapter");
-          }
-          authAdapter$1.setAdapterSettings({
-            privateKeyProvider: this.coreOptions.privateKeyProvider
-          });
-        }
-        authAdapter$1.setAdapterSettings({
-          whiteLabel: this.coreOptions.uiConfig
-        });
-        if (!authAdapter$1.privateKeyProvider) {
-          throw base.WalletInitializationError.invalidParams("privateKeyProvider is required for auth adapter");
-        }
-      } else if (adapterName === base.WALLET_ADAPTERS.WALLET_CONNECT_V2) {
-        const walletConnectAdapter = this.walletAdapters[adapterName];
-        const {
-          wallet_connect_enabled: walletConnectEnabled,
-          wallet_connect_project_id: walletConnectProjectId
-        } = projectConfig;
-        if (walletConnectEnabled === false) {
-          throw base.WalletInitializationError.invalidParams("Please enable wallet connect v2 addon on dashboard");
-        }
-        if (!walletConnectProjectId) throw base.WalletInitializationError.invalidParams("Invalid wallet connect project id. Please configure it on the dashboard");
-        walletConnectAdapter.setAdapterSettings({
-          adapterSettings: {
-            walletConnectInitOptions: {
-              projectId: walletConnectProjectId
-            }
-          }
-        });
+
+    // setup common JRPC provider
+    await this.setupCommonJRPCProvider();
+
+    // initialize connectors
+    this.on(constants.CONNECTOR_EVENTS.CONNECTORS_UPDATED, async ({
+      connectors: newConnectors
+    }) => {
+      await Promise.all(newConnectors.map(this.setupConnector));
+
+      // emit connector ready event
+      if (this.status === constants.CONNECTOR_STATUS.NOT_READY) {
+        this.status = constants.CONNECTOR_STATUS.READY;
+        this.emit(constants.CONNECTOR_EVENTS.READY);
       }
-      return this.walletAdapters[adapterName].init({
-        autoConnect: this.cachedAdapter === adapterName
-      }).catch(e => base.log.error(e, adapterName));
     });
-    await Promise.all(initPromises);
-    if (this.status === base.ADAPTER_STATUS.NOT_READY) {
-      this.status = base.ADAPTER_STATUS.READY;
-      this.emit(base.ADAPTER_EVENTS.READY);
-    }
+    await this.loadConnectors({
+      projectConfig
+    });
+    await this.initPlugins();
   }
-  getAdapter(adapterName) {
-    return this.walletAdapters[adapterName] || null;
-  }
-  configureAdapter(adapter) {
-    this.checkInitRequirements();
-    const providedChainConfig = this.coreOptions.chainConfig;
-    if (!providedChainConfig.chainNamespace) throw base.WalletInitializationError.invalidParams("Please provide chainNamespace in chainConfig");
-    const adapterAlreadyExists = this.walletAdapters[adapter.name];
-    if (adapterAlreadyExists) throw base.WalletInitializationError.duplicateAdapterError(`Wallet adapter for ${adapter.name} already exists`);
-    if (adapter.adapterNamespace !== base.ADAPTER_NAMESPACES.MULTICHAIN && adapter.adapterNamespace !== providedChainConfig.chainNamespace) throw base.WalletInitializationError.incompatibleChainNameSpace(`This wallet adapter belongs to ${adapter.adapterNamespace} which is incompatible with currently used namespace: ${providedChainConfig.chainNamespace}`);
-    if (adapter.adapterNamespace === base.ADAPTER_NAMESPACES.MULTICHAIN && adapter.currentChainNamespace && providedChainConfig.chainNamespace !== adapter.currentChainNamespace) {
-      // chainConfig checks are already validated in constructor so using typecast is safe here.
-      adapter.setAdapterSettings({
-        chainConfig: providedChainConfig
-      });
-    }
-    this.walletAdapters[adapter.name] = adapter;
-    return this;
+  getConnector(connectorName) {
+    return this.connectors.find(connector => connector.name === connectorName) || null;
   }
   clearCache() {
-    if (!base.storageAvailable(this.storage)) return;
-    window[this.storage].removeItem(ADAPTER_CACHE_KEY);
-    this.cachedAdapter = null;
-  }
-  async addChain(chainConfig) {
-    if (this.status === base.ADAPTER_STATUS.CONNECTED && this.connectedAdapterName) return this.walletAdapters[this.connectedAdapterName].addChain(chainConfig);
-    if (this.commonJRPCProvider) {
-      return this.commonJRPCProvider.addChain(chainConfig);
-    }
-    throw base.WalletInitializationError.notReady(`No wallet is ready`);
+    if (!utils$1.storageAvailable(this.storage)) return;
+    window[this.storage].removeItem(CONNECTOR_CACHE_KEY);
+    window[this.storage].removeItem(CURRENT_CHAIN_CACHE_KEY);
+    this.cachedConnector = null;
   }
   async switchChain(params) {
-    if (this.status === base.ADAPTER_STATUS.CONNECTED && this.connectedAdapterName) return this.walletAdapters[this.connectedAdapterName].switchChain(params);
+    if (params.chainId === this.currentChain.chainId) return;
+    const newChainConfig = this.coreOptions.chains.find(x => x.chainId === params.chainId);
+    if (!newChainConfig) throw index.WalletInitializationError.invalidParams("Invalid chainId");
+    if (this.status === constants.CONNECTOR_STATUS.CONNECTED && this.connectedConnector) {
+      await this.connectedConnector.switchChain(params);
+      this.setCurrentChain(params.chainId);
+      return;
+    }
     if (this.commonJRPCProvider) {
-      return this.commonJRPCProvider.switchChain(params);
+      await this.commonJRPCProvider.switchChain(params);
+      this.setCurrentChain(params.chainId);
+      return;
     }
-    throw base.WalletInitializationError.notReady(`No wallet is ready`);
+    throw index.WalletInitializationError.notReady(`No wallet is ready`);
   }
 
   /**
-   * Connect to a specific wallet adapter
-   * @param walletName - Key of the walletAdapter to use.
+   * Connect to a specific wallet connector
+   * @param connectorName - Key of the wallet connector to use.
    */
-  async connectTo(walletName, loginParams) {
-    if (!this.walletAdapters[walletName] || !this.commonJRPCProvider) throw base.WalletInitializationError.notFound(`Please add wallet adapter for ${walletName} wallet, before connecting`);
+  async connectTo(connectorName, loginParams) {
+    if (!this.getConnector(connectorName) || !this.commonJRPCProvider) throw index.WalletInitializationError.notFound(`Please add wallet connector for ${connectorName} wallet, before connecting`);
     return new Promise((resolve, reject) => {
-      this.once(base.ADAPTER_EVENTS.CONNECTED, _ => {
+      this.once(constants.CONNECTOR_EVENTS.CONNECTED, _ => {
         resolve(this.provider);
       });
-      this.once(base.ADAPTER_EVENTS.ERRORED, err => {
+      this.once(constants.CONNECTOR_EVENTS.ERRORED, err => {
         reject(err);
       });
-      this.walletAdapters[walletName].connect(loginParams);
+      const connector = this.getConnector(connectorName);
+      const initialChain = this.getInitialChainIdForConnector(connector);
+      const finalLoginParams = _objectSpread(_objectSpread({}, loginParams), {}, {
+        chainId: initialChain.chainId
+      });
+      connector.connect(finalLoginParams);
+      this.setCurrentChain(initialChain.chainId);
     });
   }
   async logout(options = {
     cleanup: false
   }) {
-    if (this.status !== base.ADAPTER_STATUS.CONNECTED || !this.connectedAdapterName) throw base.WalletLoginError.notConnectedError(`No wallet is connected`);
-    await this.walletAdapters[this.connectedAdapterName].disconnect(options);
+    if (this.status !== constants.CONNECTOR_STATUS.CONNECTED || !this.connectedConnector) throw index.WalletLoginError.notConnectedError(`No wallet is connected`);
+    await this.connectedConnector.disconnect(options);
   }
   async getUserInfo() {
-    base.log.debug("Getting user info", this.status, this.connectedAdapterName);
-    if (this.status !== base.ADAPTER_STATUS.CONNECTED || !this.connectedAdapterName) throw base.WalletLoginError.notConnectedError(`No wallet is connected`);
-    return this.walletAdapters[this.connectedAdapterName].getUserInfo();
+    var _this$connectedConnec;
+    loglevel.log.debug("Getting user info", this.status, (_this$connectedConnec = this.connectedConnector) === null || _this$connectedConnec === void 0 ? void 0 : _this$connectedConnec.name);
+    if (this.status !== constants.CONNECTOR_STATUS.CONNECTED || !this.connectedConnector) throw index.WalletLoginError.notConnectedError(`No wallet is connected`);
+    return this.connectedConnector.getUserInfo();
   }
   async enableMFA(loginParams) {
-    if (this.status !== base.ADAPTER_STATUS.CONNECTED || !this.connectedAdapterName) throw base.WalletLoginError.notConnectedError(`No wallet is connected`);
-    if (this.connectedAdapterName !== base.WALLET_ADAPTERS.AUTH) throw base.WalletLoginError.unsupportedOperation(`EnableMFA is not supported for this adapter.`);
-    return this.walletAdapters[this.connectedAdapterName].enableMFA(loginParams);
+    if (this.status !== constants.CONNECTOR_STATUS.CONNECTED || !this.connectedConnector) throw index.WalletLoginError.notConnectedError(`No wallet is connected`);
+    if (this.connectedConnector.name !== index$1.WALLET_CONNECTORS.AUTH) throw index.WalletLoginError.unsupportedOperation(`EnableMFA is not supported for this connector.`);
+    return this.connectedConnector.enableMFA(loginParams);
   }
   async manageMFA(loginParams) {
-    if (this.status !== base.ADAPTER_STATUS.CONNECTED || !this.connectedAdapterName) throw base.WalletLoginError.notConnectedError(`No wallet is connected`);
-    if (this.connectedAdapterName !== base.WALLET_ADAPTERS.AUTH) throw base.WalletLoginError.unsupportedOperation(`ManageMFA is not supported for this adapter.`);
-    return this.walletAdapters[this.connectedAdapterName].manageMFA(loginParams);
+    if (this.status !== constants.CONNECTOR_STATUS.CONNECTED || !this.connectedConnector) throw index.WalletLoginError.notConnectedError(`No wallet is connected`);
+    if (this.connectedConnector.name !== index$1.WALLET_CONNECTORS.AUTH) throw index.WalletLoginError.unsupportedOperation(`ManageMFA is not supported for this connector.`);
+    return this.connectedConnector.manageMFA(loginParams);
   }
   async authenticateUser() {
-    if (this.status !== base.ADAPTER_STATUS.CONNECTED || !this.connectedAdapterName) throw base.WalletLoginError.notConnectedError(`No wallet is connected`);
-    return this.walletAdapters[this.connectedAdapterName].authenticateUser();
+    if (this.status !== constants.CONNECTOR_STATUS.CONNECTED || !this.connectedConnector) throw index.WalletLoginError.notConnectedError(`No wallet is connected`);
+    return this.connectedConnector.authenticateUser();
   }
-  addPlugin(plugin) {
-    if (this.plugins[plugin.name]) throw base.WalletInitializationError.duplicateAdapterError(`Plugin ${plugin.name} already exist`);
-    if (plugin.pluginNamespace !== base.PLUGIN_NAMESPACES.MULTICHAIN && plugin.pluginNamespace !== this.coreOptions.chainConfig.chainNamespace) throw base.WalletInitializationError.incompatibleChainNameSpace(`This plugin belongs to ${plugin.pluginNamespace} namespace which is incompatible with currently used namespace: ${this.coreOptions.chainConfig.chainNamespace}`);
-    this.plugins[plugin.name] = plugin;
-    if (this.status === base.ADAPTER_STATUS.CONNECTED && this.connectedAdapterName) {
-      // web3auth is already connected. can initialize plugins
-      this.connectToPlugins({
-        adapter: this.connectedAdapterName
+  getPlugin(name) {
+    return this.plugins[name] || null;
+  }
+  initCachedConnectorAndChainId() {
+    this.cachedConnector = utils$1.storageAvailable(this.storage) ? window[this.storage].getItem(CONNECTOR_CACHE_KEY) : null;
+    // init chainId using cached chainId if it exists and is valid, otherwise use the defaultChainId or the first chain
+    const cachedChainId = utils$1.storageAvailable(this.storage) ? window[this.storage].getItem(CURRENT_CHAIN_CACHE_KEY) : null;
+    const isCachedChainIdValid = cachedChainId && this.coreOptions.chains.some(chain => chain.chainId === cachedChainId);
+    this.currentChainId = isCachedChainIdValid ? cachedChainId : this.coreOptions.defaultChainId || this.coreOptions.chains[0].chainId;
+  }
+  async setupCommonJRPCProvider() {
+    this.commonJRPCProvider = await CommonJRPCProvider.CommonJRPCProvider.getProviderInstance({
+      chain: this.currentChain,
+      chains: this.coreOptions.chains
+    });
+
+    // sync chainId
+    this.commonJRPCProvider.on("chainChanged", chainId => this.setCurrentChain(chainId));
+  }
+  async setupConnector(connector) {
+    this.subscribeToConnectorEvents(connector);
+    try {
+      const initialChain = this.getInitialChainIdForConnector(connector);
+      await connector.init({
+        autoConnect: this.cachedConnector === connector.name,
+        chainId: initialChain.chainId
       });
+    } catch (e) {
+      loglevel.log.error(e, connector.name);
     }
-    return this;
   }
-  getPlugin(name) {
-    return this.plugins[name] || null;
+  async loadConnectors({
+    projectConfig
+  }) {
+    var _this$coreOptions$mul;
+    // always add auth connector
+    const connectorFns = [...(this.coreOptions.connectors || []), authConnector.authConnector()];
+    const config = {
+      projectConfig,
+      coreOptions: this.coreOptions
+    };
+
+    // add injected connectors
+    const isMipdEnabled = (_this$coreOptions$mul = this.coreOptions.multiInjectedProviderDiscovery) !== null && _this$coreOptions$mul !== void 0 ? _this$coreOptions$mul : true;
+    const chainNamespaces = new Set(this.coreOptions.chains.map(chain => chain.chainNamespace));
+    if (isMipdEnabled) {
+      // Solana chains
+      if (chainNamespaces.has(IChainInterface.CHAIN_NAMESPACES.SOLANA)) {
+        const {
+          createSolanaMipd,
+          hasSolanaWalletStandardFeatures,
+          walletStandardConnector
+        } = await Promise.resolve().then(function () { return require('./connectors/injected-solana-connector/index.js'); });
+        const solanaMipd = createSolanaMipd();
+        // subscribe to new injected connectors
+        solanaMipd.on("register", async (...wallets) => {
+          const newConnectors = wallets.filter(hasSolanaWalletStandardFeatures).map(wallet => walletStandardConnector(wallet)(config));
+          this.setConnectors(newConnectors);
+        });
+        connectorFns.push(...solanaMipd.get().filter(wallet => hasSolanaWalletStandardFeatures(wallet)).map(walletStandardConnector));
+      }
+      // EVM chains
+      if (chainNamespaces.has(IChainInterface.CHAIN_NAMESPACES.EIP155)) {
+        const {
+          createMipd,
+          injectedEvmConnector
+        } = await Promise.resolve().then(function () { return require('./connectors/injected-evm-connector/index.js'); });
+        const evmMipd = createMipd();
+        // subscribe to new injected connectors
+        evmMipd.subscribe(providerDetails => {
+          const newConnectors = providerDetails.map(providerDetail => injectedEvmConnector(providerDetail)(config));
+          this.setConnectors(newConnectors);
+        });
+        connectorFns.push(...evmMipd.getProviders().map(injectedEvmConnector));
+      }
+    }
+
+    // add WalletConnectV2 connector if enabled
+    if (projectConfig.wallet_connect_enabled && projectConfig.wallet_connect_project_id && (chainNamespaces.has(IChainInterface.CHAIN_NAMESPACES.SOLANA) || chainNamespaces.has(IChainInterface.CHAIN_NAMESPACES.EIP155))) {
+      const {
+        walletConnectV2Connector
+      } = await Promise.resolve().then(function () { return require('./connectors/wallet-connect-v2-connector/index.js'); });
+      connectorFns.push(walletConnectV2Connector());
+    }
+    const connectors = connectorFns.map(connectorFn => connectorFn(config));
+    this.setConnectors(connectors);
+  }
+  async initPlugins() {
+    const pluginFns = this.coreOptions.plugins || [];
+    for (const pluginFn of pluginFns) {
+      const plugin = pluginFn();
+      if (!this.plugins[plugin.name]) this.plugins[plugin.name] = plugin;
+    }
   }
-  subscribeToAdapterEvents(walletAdapter) {
-    walletAdapter.on(base.ADAPTER_EVENTS.CONNECTED, async data => {
-      if (!this.commonJRPCProvider) throw base.WalletInitializationError.notFound(`CommonJrpcProvider not found`);
+  setConnectors(connectors) {
+    const connectorSet = new Set(this.connectors.map(connector => connector.name));
+    const newConnectors = connectors.map(connector => {
+      if (connectorSet.has(connector.name)) return null;
+      connectorSet.add(connector.name);
+      return connector;
+    }).filter(connector => connector !== null);
+    if (newConnectors.length > 0) {
+      this.connectors = [...this.connectors, ...newConnectors];
+      // only emit new connectors
+      this.emit(constants.CONNECTOR_EVENTS.CONNECTORS_UPDATED, {
+        connectors: newConnectors
+      });
+    }
+  }
+  subscribeToConnectorEvents(connector) {
+    connector.on(constants.CONNECTOR_EVENTS.CONNECTED, async data => {
+      if (!this.commonJRPCProvider) throw index.WalletInitializationError.notFound(`CommonJrpcProvider not found`);
       const {
         provider
       } = data;
       let finalProvider = provider.provider || provider;
-      // setup aa provider after adapter is connected and private key provider is setup
-      if (this.coreOptions.accountAbstractionProvider && (data.adapter === base.WALLET_ADAPTERS.AUTH || data.adapter !== base.WALLET_ADAPTERS.AUTH && this.coreOptions.useAAWithExternalWallet)) {
-        await this.coreOptions.accountAbstractionProvider.setupProvider(provider); // Don't change this to finalProvider
-        finalProvider = this.coreOptions.accountAbstractionProvider;
+      // setup aa provider for external wallets on EVM chains, for in app wallet, it uses WS provider which already supports AA
+      const {
+        accountAbstractionConfig
+      } = this.coreOptions;
+      if (this.currentChain.chainNamespace === IChainInterface.CHAIN_NAMESPACES.EIP155 && accountAbstractionConfig && data.connector !== index$1.WALLET_CONNECTORS.AUTH && this.coreOptions.useAAWithExternalWallet) {
+        const {
+          accountAbstractionProvider
+        } = await Promise.resolve().then(function () { return require('./providers/account-abstraction-provider/index.js'); });
+        const aaProvider = await accountAbstractionProvider({
+          accountAbstractionConfig,
+          provider,
+          chain: this.currentChain,
+          chains: this.coreOptions.chains
+        });
+        finalProvider = aaProvider;
+        // TODO: when switching chains to Solana or other chains, we need to switch to the non-AA provider
       }
       this.commonJRPCProvider.updateProviderEngineProxy(finalProvider);
-      this.connectedAdapterName = data.adapter;
-      this.status = base.ADAPTER_STATUS.CONNECTED;
-      this.cacheWallet(data.adapter);
-      base.log.debug("connected", this.status, this.connectedAdapterName);
+      this.connectedConnectorName = data.connector;
+      this.status = constants.CONNECTOR_STATUS.CONNECTED;
+      this.cacheWallet(data.connector);
+      loglevel.log.debug("connected", this.status, this.connectedConnectorName);
       this.connectToPlugins(data);
-      this.emit(base.ADAPTER_EVENTS.CONNECTED, _objectSpread({}, data));
+      this.emit(constants.CONNECTOR_EVENTS.CONNECTED, _objectSpread({}, data));
     });
-    walletAdapter.on(base.ADAPTER_EVENTS.DISCONNECTED, async () => {
+    connector.on(constants.CONNECTOR_EVENTS.DISCONNECTED, async () => {
       // get back to ready state for rehydrating.
-      this.status = base.ADAPTER_STATUS.READY;
-      if (base.storageAvailable(this.storage)) {
-        const cachedAdapter = window[this.storage].getItem(ADAPTER_CACHE_KEY);
-        if (this.connectedAdapterName === cachedAdapter) {
+      this.status = constants.CONNECTOR_STATUS.READY;
+      if (utils$1.storageAvailable(this.storage)) {
+        const cachedConnector = window[this.storage].getItem(CONNECTOR_CACHE_KEY);
+        if (this.connectedConnectorName === cachedConnector) {
           this.clearCache();
         }
       }
-      base.log.debug("disconnected", this.status, this.connectedAdapterName);
-      await Promise.all(Object.values(this.plugins).map(plugin => {
+      loglevel.log.debug("disconnected", this.status, this.connectedConnectorName);
+      await Promise.all(Object.values(this.plugins).map(async plugin => {
+        if (!plugin.SUPPORTED_CONNECTORS.includes("all") && !plugin.SUPPORTED_CONNECTORS.includes(connector.name)) return;
+        if (plugin.status !== IPlugin.PLUGIN_STATUS.CONNECTED) return;
         return plugin.disconnect().catch(error => {
-          // swallow error if adapter doesn't supports this plugin.
+          // swallow error if connector doesn't supports this plugin.
           if (error.code === 5211) {
             return;
           }
           // throw error;
-          base.log.error(error);
+          loglevel.log.error(error);
         });
       }));
-      this.connectedAdapterName = null;
-      this.emit(base.ADAPTER_EVENTS.DISCONNECTED);
+      this.connectedConnectorName = null;
+      this.emit(constants.CONNECTOR_EVENTS.DISCONNECTED);
     });
-    walletAdapter.on(base.ADAPTER_EVENTS.CONNECTING, data => {
-      this.status = base.ADAPTER_STATUS.CONNECTING;
-      this.emit(base.ADAPTER_EVENTS.CONNECTING, data);
-      base.log.debug("connecting", this.status, this.connectedAdapterName);
+    connector.on(constants.CONNECTOR_EVENTS.CONNECTING, data => {
+      this.status = constants.CONNECTOR_STATUS.CONNECTING;
+      this.emit(constants.CONNECTOR_EVENTS.CONNECTING, data);
+      loglevel.log.debug("connecting", this.status, this.connectedConnectorName);
     });
-    walletAdapter.on(base.ADAPTER_EVENTS.ERRORED, data => {
-      this.status = base.ADAPTER_STATUS.ERRORED;
+    connector.on(constants.CONNECTOR_EVENTS.ERRORED, data => {
+      this.status = constants.CONNECTOR_STATUS.ERRORED;
       this.clearCache();
-      this.emit(base.ADAPTER_EVENTS.ERRORED, data);
-      base.log.debug("errored", this.status, this.connectedAdapterName);
+      this.emit(constants.CONNECTOR_EVENTS.ERRORED, data);
+      loglevel.log.debug("errored", this.status, this.connectedConnectorName);
     });
-    walletAdapter.on(base.ADAPTER_EVENTS.ADAPTER_DATA_UPDATED, data => {
-      base.log.debug("adapter data updated", data);
-      this.emit(base.ADAPTER_EVENTS.ADAPTER_DATA_UPDATED, data);
+    connector.on(constants.CONNECTOR_EVENTS.CONNECTOR_DATA_UPDATED, data => {
+      loglevel.log.debug("connector data updated", data);
+      this.emit(constants.CONNECTOR_EVENTS.CONNECTOR_DATA_UPDATED, data);
     });
-    walletAdapter.on(base.ADAPTER_EVENTS.CACHE_CLEAR, data => {
-      base.log.debug("adapter cache clear", data);
-      if (base.storageAvailable(this.storage)) {
+    connector.on(constants.CONNECTOR_EVENTS.CACHE_CLEAR, data => {
+      loglevel.log.debug("connector cache clear", data);
+      if (utils$1.storageAvailable(this.storage)) {
         this.clearCache();
       }
     });
   }
   checkInitRequirements() {
-    if (this.status === base.ADAPTER_STATUS.CONNECTING) throw base.WalletInitializationError.notReady("Already pending connection");
-    if (this.status === base.ADAPTER_STATUS.CONNECTED) throw base.WalletInitializationError.notReady("Already connected");
-    if (this.status === base.ADAPTER_STATUS.READY) throw base.WalletInitializationError.notReady("Adapter is already initialized");
+    if (this.status === constants.CONNECTOR_STATUS.CONNECTING) throw index.WalletInitializationError.notReady("Already pending connection");
+    if (this.status === constants.CONNECTOR_STATUS.CONNECTED) throw index.WalletInitializationError.notReady("Already connected");
+    if (this.status === constants.CONNECTOR_STATUS.READY) throw index.WalletInitializationError.notReady("Connector is already initialized");
+  }
+
+  /**
+   * Gets the initial chain configuration for a connector
+   * @throws WalletInitializationError If no chain is found for the connector's namespace
+   */
+  getInitialChainIdForConnector(connector) {
+    let initialChain = this.currentChain;
+    if (initialChain.chainNamespace !== connector.connectorNamespace && connector.connectorNamespace !== IChainInterface.CONNECTOR_NAMESPACES.MULTICHAIN) {
+      initialChain = this.coreOptions.chains.find(x => x.chainNamespace === connector.connectorNamespace);
+      if (!initialChain) throw index.WalletInitializationError.invalidParams(`No chain found for ${connector.connectorNamespace}`);
+    }
+    return initialChain;
   }
   cacheWallet(walletName) {
-    if (!base.storageAvailable(this.storage)) return;
-    window[this.storage].setItem(ADAPTER_CACHE_KEY, walletName);
-    this.cachedAdapter = walletName;
+    if (!utils$1.storageAvailable(this.storage)) return;
+    // TODO: use the key from user + this
+    window[this.storage].setItem(CONNECTOR_CACHE_KEY, walletName);
+    this.cachedConnector = walletName;
+  }
+  setCurrentChain(chainId) {
+    if (chainId === this.currentChainId) return;
+    const newChain = this.coreOptions.chains.find(chain => chain.chainId === chainId);
+    if (!newChain) throw index.WalletInitializationError.invalidParams(`Invalid chainId: ${chainId}`);
+    this.currentChainId = chainId;
+    this.cacheCurrentChain(chainId);
+  }
+  cacheCurrentChain(chainId) {
+    if (!utils$1.storageAvailable(this.storage)) return;
+    window[this.storage].setItem(CURRENT_CHAIN_CACHE_KEY, chainId);
   }
   connectToPlugins(data) {
     Object.values(this.plugins).map(async plugin => {
       try {
-        if (!plugin.SUPPORTED_ADAPTERS.includes("all") && !plugin.SUPPORTED_ADAPTERS.includes(data.adapter)) {
-          return;
-        }
-        if (plugin.status === base.PLUGIN_STATUS.CONNECTED) return;
-        const {
-          authInstance
-        } = this.walletAdapters[this.connectedAdapterName];
-        const {
-          options,
-          sessionId,
-          sessionNamespace
-        } = authInstance || {};
-        await plugin.initWithWeb3Auth(this, options === null || options === void 0 ? void 0 : options.whiteLabel);
-        await plugin.connect({
-          sessionId,
-          sessionNamespace
-        });
+        // skip if it's not compatible with the connector
+        if (!plugin.SUPPORTED_CONNECTORS.includes("all") && !plugin.SUPPORTED_CONNECTORS.includes(data.connector)) return;
+        // skip if it's not compatible with the current chain
+        if (plugin.pluginNamespace !== IPlugin.PLUGIN_NAMESPACES.MULTICHAIN && plugin.pluginNamespace !== this.currentChain.chainNamespace) return;
+        // skip if it's already connected
+        if (plugin.status === IPlugin.PLUGIN_STATUS.CONNECTED) return;
+        await plugin.initWithWeb3Auth(this, this.coreOptions.uiConfig);
+        await plugin.connect();
       } catch (error) {
-        // swallow error if connector adapter doesn't supports this plugin.
+        // swallow error if connector connector doesn't supports this plugin.
         if (error.code === 5211) {
           return;
         }
-        base.log.error(error);
+        loglevel.log.error(error);
       }
     });
   }