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

package/dist/lib.esm/connectors/auth-connector/authConnector.js

@@ -0,0 +1,390 @@
+import _objectSpread from '@babel/runtime/helpers/objectSpread2';
+import _defineProperty from '@babel/runtime/helpers/defineProperty';
+import { LOGIN_PROVIDER, UX_MODE, WEB3AUTH_NETWORK, Auth, SUPPORTED_KEY_CURVES } from '@web3auth/auth';
+import deepmerge from 'deepmerge';
+import { CONNECTOR_NAMESPACES, CHAIN_NAMESPACES } from '../../base/chain/IChainInterface.js';
+import { WalletInitializationError, WalletLoginError, Web3AuthError } from '../../base/errors/index.js';
+import { log } from '../../base/loglevel.js';
+import { cloneDeep } from '@toruslabs/base-controllers';
+import '@toruslabs/constants';
+import '@toruslabs/http-helpers';
+import { WALLET_CONNECTORS } from '../../base/wallet/index.js';
+import { BaseConnector } from '../../base/connector/baseConnector.js';
+import { CONNECTOR_CATEGORY, CONNECTOR_STATUS, CONNECTOR_EVENTS } from '../../base/connector/constants.js';
+
+class AuthConnector extends BaseConnector {
+  constructor(params) {
+    super(params);
+    _defineProperty(this, "name", WALLET_CONNECTORS.AUTH);
+    _defineProperty(this, "connectorNamespace", CONNECTOR_NAMESPACES.MULTICHAIN);
+    _defineProperty(this, "type", CONNECTOR_CATEGORY.IN_APP);
+    _defineProperty(this, "authInstance", null);
+    _defineProperty(this, "status", CONNECTOR_STATUS.NOT_READY);
+    _defineProperty(this, "privateKeyProvider", null);
+    _defineProperty(this, "authOptions", void 0);
+    _defineProperty(this, "loginSettings", {
+      loginProvider: ""
+    });
+    _defineProperty(this, "wsSettings", {});
+    _defineProperty(this, "wsEmbedInstance", null);
+    this.authOptions = params.connectorSettings;
+    this.loginSettings = params.loginSettings || {
+      loginProvider: ""
+    };
+    this.wsSettings = params.walletServicesSettings || {};
+  }
+  get provider() {
+    if (this.status !== CONNECTOR_STATUS.NOT_READY) {
+      var _this$wsEmbedInstance;
+      if ((_this$wsEmbedInstance = this.wsEmbedInstance) !== null && _this$wsEmbedInstance !== void 0 && _this$wsEmbedInstance.provider) {
+        return this.wsEmbedInstance.provider;
+      } else if (this.privateKeyProvider) return this.privateKeyProvider;
+    }
+    return null;
+  }
+  get wsEmbed() {
+    return this.wsEmbedInstance;
+  }
+  set provider(_) {
+    throw new Error("Not implemented");
+  }
+  async init(options) {
+    const chainConfig = this.coreOptions.chains.find(x => x.chainId === options.chainId);
+    super.checkInitializationRequirements({
+      chainConfig
+    });
+    if (!this.coreOptions.clientId) throw WalletInitializationError.invalidParams("clientId is required before auth's initialization");
+    if (!this.authOptions) throw WalletInitializationError.invalidParams("authOptions is required before auth's initialization");
+    const isRedirectResult = this.authOptions.uxMode === UX_MODE.REDIRECT;
+    this.authOptions = _objectSpread(_objectSpread({}, this.authOptions), {}, {
+      replaceUrlOnRedirect: isRedirectResult,
+      useCoreKitKey: this.coreOptions.useCoreKitKey
+    });
+    const web3AuthNetwork = this.coreOptions.web3AuthNetwork || WEB3AUTH_NETWORK.SAPPHIRE_MAINNET;
+    this.authInstance = new Auth(_objectSpread(_objectSpread({}, this.authOptions), {}, {
+      clientId: this.coreOptions.clientId,
+      network: web3AuthNetwork
+    }));
+    log.debug("initializing auth connector init");
+    await this.authInstance.init();
+
+    // Use this for xrpl, mpc cases
+    if (this.coreOptions.privateKeyProvider) {
+      this.privateKeyProvider = this.coreOptions.privateKeyProvider;
+    } else {
+      // initialize ws embed or private key provider based on chain namespace
+      switch (chainConfig.chainNamespace) {
+        case CHAIN_NAMESPACES.EIP155:
+        case CHAIN_NAMESPACES.SOLANA:
+          {
+            const {
+              default: WsEmbed
+            } = await import('@web3auth/ws-embed');
+            this.wsEmbedInstance = new WsEmbed({
+              web3AuthClientId: this.coreOptions.clientId,
+              web3AuthNetwork,
+              modalZIndex: this.wsSettings.modalZIndex
+            });
+            // TODO: once support multiple chains, only pass chains of solana and EVM
+            await this.wsEmbedInstance.init(_objectSpread(_objectSpread({}, this.wsSettings), {}, {
+              chainConfig: chainConfig,
+              // TODO: upgrade ws-embed to support custom chain config
+              whiteLabel: _objectSpread(_objectSpread({}, this.authOptions.whiteLabel), this.wsSettings.whiteLabel)
+            }));
+            break;
+          }
+        case CHAIN_NAMESPACES.XRPL:
+          throw WalletLoginError.connectionError("Private key provider is required for XRPL");
+        default:
+          {
+            const {
+              CommonPrivateKeyProvider
+            } = await import('../../providers/base-provider/index.js');
+            this.privateKeyProvider = new CommonPrivateKeyProvider({
+              config: {
+                chain: chainConfig,
+                chains: this.coreOptions.chains
+              }
+            });
+          }
+      }
+    }
+    this.status = CONNECTOR_STATUS.READY;
+    this.emit(CONNECTOR_EVENTS.READY, WALLET_CONNECTORS.AUTH);
+    try {
+      log.debug("initializing auth connector");
+      const {
+        sessionId
+      } = this.authInstance || {};
+      // connect only if it is redirect result or if connect (connector is cached/already connected in same session) is true
+      if (sessionId && (options.autoConnect || isRedirectResult)) {
+        this.rehydrated = true;
+        await this.connect({
+          chainId: options.chainId
+        });
+      }
+    } catch (error) {
+      log.error("Failed to connect with cached auth provider", error);
+      this.emit(CONNECTOR_EVENTS.ERRORED, error);
+    }
+  }
+  async connect(params) {
+    super.checkConnectionRequirements();
+    this.status = CONNECTOR_STATUS.CONNECTING;
+    this.emit(CONNECTOR_EVENTS.CONNECTING, _objectSpread(_objectSpread({}, params), {}, {
+      connector: WALLET_CONNECTORS.AUTH
+    }));
+    try {
+      await this.connectWithProvider(params);
+      return this.provider;
+    } catch (error) {
+      log.error("Failed to connect with auth provider", error);
+      // ready again to be connected
+      this.status = CONNECTOR_STATUS.READY;
+      this.emit(CONNECTOR_EVENTS.ERRORED, error);
+      if (error !== null && error !== void 0 && error.message.includes("user closed popup")) {
+        throw WalletLoginError.popupClosed();
+      } else if (error instanceof Web3AuthError) {
+        throw error;
+      }
+      throw WalletLoginError.connectionError("Failed to login with auth", error);
+    }
+  }
+  async enableMFA(params = {
+    loginProvider: ""
+  }) {
+    if (this.status !== CONNECTOR_STATUS.CONNECTED) throw WalletLoginError.notConnectedError("Not connected with wallet");
+    if (!this.authInstance) throw WalletInitializationError.notReady("authInstance is not ready");
+    try {
+      await this.authInstance.enableMFA(params);
+    } catch (error) {
+      log.error("Failed to enable MFA with auth provider", error);
+      if (error instanceof Web3AuthError) {
+        throw error;
+      }
+      throw WalletLoginError.connectionError("Failed to enable MFA with auth", error);
+    }
+  }
+  async manageMFA(params = {
+    loginProvider: ""
+  }) {
+    if (this.status !== CONNECTOR_STATUS.CONNECTED) throw WalletLoginError.notConnectedError("Not connected with wallet");
+    if (!this.authInstance) throw WalletInitializationError.notReady("authInstance is not ready");
+    try {
+      await this.authInstance.manageMFA(params);
+    } catch (error) {
+      log.error("Failed to manage MFA with auth provider", error);
+      if (error instanceof Web3AuthError) {
+        throw error;
+      }
+      throw WalletLoginError.connectionError("Failed to manage MFA with auth", error);
+    }
+  }
+  async disconnect(options = {
+    cleanup: false
+  }) {
+    if (this.status !== CONNECTOR_STATUS.CONNECTED) throw WalletLoginError.notConnectedError("Not connected with wallet");
+    if (!this.authInstance) throw WalletInitializationError.notReady("authInstance is not ready");
+    this.status = CONNECTOR_STATUS.DISCONNECTING;
+    await this.authInstance.logout();
+    if (this.wsEmbedInstance) await this.wsEmbedInstance.logout();
+    if (options.cleanup) {
+      this.status = CONNECTOR_STATUS.NOT_READY;
+      this.authInstance = null;
+      if (this.wsEmbedInstance) this.wsEmbedInstance = null;
+      if (this.privateKeyProvider) this.privateKeyProvider = null;
+    } else {
+      // ready to be connected again
+      this.status = CONNECTOR_STATUS.READY;
+    }
+    this.rehydrated = false;
+    this.emit(CONNECTOR_EVENTS.DISCONNECTED);
+  }
+  async authenticateUser() {
+    if (this.status !== CONNECTOR_STATUS.CONNECTED) throw WalletLoginError.notConnectedError("Not connected with wallet, Please login/connect first");
+    const userInfo = await this.getUserInfo();
+    return {
+      idToken: userInfo.idToken
+    };
+  }
+  async getUserInfo() {
+    if (this.status !== CONNECTOR_STATUS.CONNECTED) throw WalletLoginError.notConnectedError("Not connected with wallet");
+    if (!this.authInstance) throw WalletInitializationError.notReady("authInstance is not ready");
+    const userInfo = this.authInstance.getUserInfo();
+    return userInfo;
+  }
+
+  // we don't support switching between different namespaces, except for solana and evm
+  async switchChain(params, init = false) {
+    super.checkSwitchChainRequirements(params, init);
+    // get chains and namespaces
+    const {
+      chainId: newChainId
+    } = params;
+    const {
+      chainId: currentChainId
+    } = this.provider;
+    const {
+      chainNamespace: currentNamespace
+    } = this.getChain(currentChainId);
+    const {
+      chainNamespace: newNamespace
+    } = this.getChain(newChainId);
+
+    // skip if chainId is the same
+    if (currentChainId === newChainId) return;
+    if (currentNamespace === CHAIN_NAMESPACES.SOLANA || currentNamespace === CHAIN_NAMESPACES.EIP155) {
+      var _this$wsEmbedInstance2;
+      // can only switch to solana or evm
+      if (newNamespace !== CHAIN_NAMESPACES.SOLANA && newNamespace !== CHAIN_NAMESPACES.EIP155) throw WalletLoginError.connectionError("Cannot switch to other chain namespace");
+      const fullChainId = `${newNamespace}:${Number(params.chainId)}`;
+      await ((_this$wsEmbedInstance2 = this.wsEmbedInstance.provider) === null || _this$wsEmbedInstance2 === void 0 ? void 0 : _this$wsEmbedInstance2.request({
+        method: "wallet_switchChain",
+        params: {
+          chainId: fullChainId
+        }
+      }));
+    } else {
+      var _this$privateKeyProvi;
+      // cannot switch to other namespaces
+      if (currentNamespace !== newNamespace) throw WalletLoginError.connectionError("Cannot switch to other chain namespace");
+      await ((_this$privateKeyProvi = this.privateKeyProvider) === null || _this$privateKeyProvi === void 0 ? void 0 : _this$privateKeyProvi.switchChain(params));
+    }
+  }
+  getChain(chainId) {
+    return this.coreOptions.chains.find(x => x.chainId === chainId);
+  }
+  _getFinalPrivKey() {
+    if (!this.authInstance) return "";
+    let finalPrivKey = this.authInstance.privKey;
+    // coreKitKey is available only for custom verifiers by default
+    if (this.coreOptions.useCoreKitKey) {
+      // this is to check if the user has already logged in but coreKitKey is not available.
+      // when useCoreKitKey is set to true.
+      // This is to ensure that when there is no user session active, we don't throw an exception.
+      if (this.authInstance.privKey && !this.authInstance.coreKitKey) {
+        throw WalletLoginError.coreKitKeyNotFound();
+      }
+      finalPrivKey = this.authInstance.coreKitKey;
+    }
+    return finalPrivKey;
+  }
+  async connectWithProvider(params) {
+    var _this$authInstance, _params$extraLoginOpt;
+    if (!this.authInstance) throw WalletInitializationError.notReady("authInstance is not ready");
+    const chainConfig = this.coreOptions.chains.find(x => x.chainId === params.chainId);
+    if (!chainConfig) throw WalletLoginError.connectionError("Chain config is not available");
+    const {
+      chainNamespace
+    } = chainConfig;
+
+    // if not logged in then login
+    const keyAvailable = chainNamespace === CHAIN_NAMESPACES.EIP155 || chainNamespace === CHAIN_NAMESPACES.SOLANA ? (_this$authInstance = this.authInstance) === null || _this$authInstance === void 0 ? void 0 : _this$authInstance.sessionId : this._getFinalPrivKey();
+    if (!keyAvailable || (_params$extraLoginOpt = params.extraLoginOptions) !== null && _params$extraLoginOpt !== void 0 && _params$extraLoginOpt.id_token) {
+      var _params$extraLoginOpt2;
+      // always use "other" curve to return token with all keys encoded so wallet service can switch between evm and solana namespace
+      this.loginSettings.curve = SUPPORTED_KEY_CURVES.OTHER;
+      if (!params.loginProvider && !this.loginSettings.loginProvider) throw WalletInitializationError.invalidParams("loginProvider is required for login");
+      await this.authInstance.login(deepmerge.all([this.loginSettings, params, {
+        extraLoginOptions: _objectSpread(_objectSpread({}, params.extraLoginOptions || {}), {}, {
+          login_hint: params.login_hint || ((_params$extraLoginOpt2 = params.extraLoginOptions) === null || _params$extraLoginOpt2 === void 0 ? void 0 : _params$extraLoginOpt2.login_hint)
+        })
+      }]));
+    }
+
+    // setup WS embed if chainNamespace is EIP155 or SOLANA
+    if (chainNamespace === CHAIN_NAMESPACES.EIP155 || chainNamespace === CHAIN_NAMESPACES.SOLANA) {
+      const {
+        sessionId,
+        sessionNamespace
+      } = this.authInstance || {};
+      if (sessionId) {
+        const isLoggedIn = await this.wsEmbedInstance.loginWithSessionId({
+          sessionId,
+          sessionNamespace
+        });
+        if (isLoggedIn) {
+          var _this$wsEmbedInstance3;
+          this.status = CONNECTOR_STATUS.CONNECTED;
+          this.emit(CONNECTOR_EVENTS.CONNECTED, {
+            connector: WALLET_CONNECTORS.AUTH,
+            reconnected: this.rehydrated,
+            provider: this.provider
+          });
+          // handle disconnect from ws embed
+          (_this$wsEmbedInstance3 = this.wsEmbedInstance) === null || _this$wsEmbedInstance3 === void 0 || _this$wsEmbedInstance3.provider.on("accountsChanged", (accounts = []) => {
+            if (accounts.length === 0 && this.status === CONNECTOR_STATUS.CONNECTED) this.disconnect({
+              cleanup: false
+            });
+          });
+        }
+      }
+    } else {
+      // setup private key provider if chainNamespace is other
+      const finalPrivKey = this._getFinalPrivKey();
+      if (finalPrivKey) {
+        await this.privateKeyProvider.setupProvider(finalPrivKey, params.chainId);
+        this.status = CONNECTOR_STATUS.CONNECTED;
+        this.emit(CONNECTOR_EVENTS.CONNECTED, {
+          connector: WALLET_CONNECTORS.AUTH,
+          reconnected: this.rehydrated,
+          provider: this.provider
+        });
+      }
+    }
+  }
+}
+const authConnector = params => {
+  return ({
+    projectConfig,
+    coreOptions
+  }) => {
+    var _coreOptions$uiConfig, _coreOptions$walletSe;
+    // Connector settings
+    const connectorSettings = {};
+    const {
+      sms_otp_enabled: smsOtpEnabled,
+      whitelist
+    } = projectConfig;
+    if (smsOtpEnabled !== undefined) {
+      connectorSettings.loginConfig = {
+        [LOGIN_PROVIDER.SMS_PASSWORDLESS]: {
+          showOnModal: smsOtpEnabled,
+          showOnDesktop: smsOtpEnabled,
+          showOnMobile: smsOtpEnabled,
+          showOnSocialBackupFactor: smsOtpEnabled
+        }
+      };
+    }
+    if (whitelist) connectorSettings.originData = whitelist.signed_urls;
+    if ((_coreOptions$uiConfig = coreOptions.uiConfig) !== null && _coreOptions$uiConfig !== void 0 && _coreOptions$uiConfig.uxMode) connectorSettings.uxMode = coreOptions.uiConfig.uxMode;
+    const uiConfig = deepmerge(cloneDeep((projectConfig === null || projectConfig === void 0 ? void 0 : projectConfig.whitelabel) || {}), coreOptions.uiConfig || {});
+    if (!uiConfig.mode) uiConfig.mode = "light";
+    connectorSettings.whiteLabel = uiConfig;
+    const finalConnectorSettings = deepmerge.all([{
+      uxMode: UX_MODE.POPUP
+    },
+    // default settings
+    (params === null || params === void 0 ? void 0 : params.connectorSettings) || {}, connectorSettings]);
+
+    // WS settings
+    const isKeyExportEnabled = typeof projectConfig.key_export_enabled === "boolean" ? projectConfig.key_export_enabled : true;
+    const finalWsSettings = _objectSpread(_objectSpread({}, coreOptions.walletServicesConfig), {}, {
+      whiteLabel: _objectSpread(_objectSpread({}, uiConfig), (_coreOptions$walletSe = coreOptions.walletServicesConfig) === null || _coreOptions$walletSe === void 0 ? void 0 : _coreOptions$walletSe.whiteLabel),
+      accountAbstractionConfig: coreOptions.accountAbstractionConfig,
+      enableLogging: coreOptions.enableLogging
+      // enableKeyExport: keyExportEnabled, TODO: add this to ws embed and implement in WS
+    });
+
+    // Core options
+    if (coreOptions.privateKeyProvider) coreOptions.privateKeyProvider.setKeyExportFlag(isKeyExportEnabled);
+    return new AuthConnector({
+      connectorSettings: finalConnectorSettings,
+      walletServicesSettings: finalWsSettings,
+      loginSettings: params === null || params === void 0 ? void 0 : params.loginSettings,
+      coreOptions
+    });
+  };
+};
+
+export { authConnector };

package/dist/lib.esm/{adapters/base-evm-adapter/baseEvmAdapter.js → connectors/base-evm-connector/baseEvmConnector.js}

@@ -1,23 +1,18 @@
 import { signChallenge, verifySignedChallenge } from '@toruslabs/base-controllers';
-import { getChainConfig } from '../../base/chain/config.js';
-import { CHAIN_NAMESPACES } from '../../base/chain/IChainInterface.js';
-import { WalletLoginError } from '../../base/errors/index.js';
-import { getSavedToken, checkIfTokenIsExpired, saveToken, clearToken } from '../../base/adapter/utils.js';
-import { BaseAdapter } from '../../base/adapter/baseAdapter.js';
-import { ADAPTER_STATUS, ADAPTER_EVENTS } from '../../base/adapter/constants.js';
+import { EVM_METHOD_TYPES } from '@web3auth/ws-embed';
+import { WalletLoginError, WalletInitializationError } from '../../base/errors/index.js';
+import { getSavedToken, checkIfTokenIsExpired, saveToken, clearToken } from '../../base/connector/utils.js';
+import { BaseConnector } from '../../base/connector/baseConnector.js';
+import { CONNECTOR_STATUS, CONNECTOR_EVENTS } from '../../base/connector/constants.js';
 
-class BaseEvmAdapter extends BaseAdapter {
-  async init(_) {
-    if (!this.chainConfig) this.chainConfig = getChainConfig(CHAIN_NAMESPACES.EIP155, 1);
-  }
+class BaseEvmConnector extends BaseConnector {
+  // eslint-disable-next-line @typescript-eslint/no-empty-function
+  async init(_) {}
   async authenticateUser() {
-    if (!this.provider || this.status !== ADAPTER_STATUS.CONNECTED) throw WalletLoginError.notConnectedError();
-    const {
-      chainNamespace,
-      chainId
-    } = this.chainConfig;
+    if (!this.provider || this.status !== CONNECTOR_STATUS.CONNECTED) throw WalletLoginError.notConnectedError();
+    if (!this.coreOptions) throw WalletInitializationError.invalidParams("Please initialize Web3Auth with valid options");
     const accounts = await this.provider.request({
-      method: "eth_accounts"
+      method: EVM_METHOD_TYPES.GET_ACCOUNTS
     });
     if (accounts && accounts.length > 0) {
       const existingToken = getSavedToken(accounts[0], this.name);
@@ -29,6 +24,14 @@ class BaseEvmAdapter extends BaseAdapter {
           };
         }
       }
+      const chainId = await this.provider.request({
+        method: "eth_chainId"
+      });
+      const currentChainConfig = this.coreOptions.chains.find(x => x.chainId === chainId);
+      if (!currentChainConfig) throw WalletInitializationError.invalidParams("chainConfig is required before authentication");
+      const {
+        chainNamespace
+      } = currentChainConfig;
       const payload = {
         domain: window.location.origin,
         uri: window.location.href,
@@ -41,10 +44,10 @@ class BaseEvmAdapter extends BaseAdapter {
       const challenge = await signChallenge(payload, chainNamespace);
       const hexChallenge = `0x${Buffer.from(challenge, "utf8").toString("hex")}`;
       const signedMessage = await this.provider.request({
-        method: "personal_sign",
+        method: EVM_METHOD_TYPES.PERSONAL_SIGN,
         params: [hexChallenge, accounts[0]]
       });
-      const idToken = await verifySignedChallenge(chainNamespace, signedMessage, challenge, this.name, this.sessionTime, this.clientId, this.web3AuthNetwork);
+      const idToken = await verifySignedChallenge(chainNamespace, signedMessage, challenge, this.name, this.coreOptions.sessionTime, this.coreOptions.clientId, this.coreOptions.web3AuthNetwork);
       saveToken(accounts[0], this.name, idToken);
       return {
         idToken
@@ -63,8 +66,8 @@ class BaseEvmAdapter extends BaseAdapter {
   }
   async disconnect() {
     this.rehydrated = false;
-    this.emit(ADAPTER_EVENTS.DISCONNECTED);
+    this.emit(CONNECTOR_EVENTS.DISCONNECTED);
   }
 }
 
-export { BaseEvmAdapter };
+export { BaseEvmConnector };

package/dist/lib.esm/{adapters/base-solana-adapter/baseSolanaAdapter.js → connectors/base-solana-connector/baseSolanaConnector.js}

@@ -1,24 +1,18 @@
 import { signChallenge, verifySignedChallenge } from '@toruslabs/base-controllers';
-import bs58 from 'bs58';
-import { getChainConfig } from '../../base/chain/config.js';
-import { CHAIN_NAMESPACES } from '../../base/chain/IChainInterface.js';
-import { WalletLoginError } from '../../base/errors/index.js';
-import { BaseAdapter } from '../../base/adapter/baseAdapter.js';
-import { ADAPTER_STATUS, ADAPTER_EVENTS } from '../../base/adapter/constants.js';
-import { getSavedToken, checkIfTokenIsExpired, saveToken, clearToken } from '../../base/adapter/utils.js';
+import { SOLANA_METHOD_TYPES } from '@web3auth/ws-embed';
+import { WalletLoginError, WalletInitializationError } from '../../base/errors/index.js';
+import { BaseConnector } from '../../base/connector/baseConnector.js';
+import { CONNECTOR_STATUS, CONNECTOR_EVENTS } from '../../base/connector/constants.js';
+import { getSavedToken, checkIfTokenIsExpired, saveToken, clearToken } from '../../base/connector/utils.js';
 
-class BaseSolanaAdapter extends BaseAdapter {
-  async init(_) {
-    if (!this.chainConfig) this.chainConfig = getChainConfig(CHAIN_NAMESPACES.SOLANA, 1);
-  }
+class BaseSolanaConnector extends BaseConnector {
+  // eslint-disable-next-line @typescript-eslint/no-empty-function
+  async init(_) {}
   async authenticateUser() {
-    if (!this.provider || this.status !== ADAPTER_STATUS.CONNECTED) throw WalletLoginError.notConnectedError();
-    const {
-      chainNamespace,
-      chainId
-    } = this.chainConfig;
+    if (!this.provider || this.status !== CONNECTOR_STATUS.CONNECTED) throw WalletLoginError.notConnectedError();
+    if (!this.coreOptions) throw WalletInitializationError.invalidParams("Please initialize Web3Auth with a valid options");
     const accounts = await this.provider.request({
-      method: "getAccounts"
+      method: SOLANA_METHOD_TYPES.GET_ACCOUNTS
     });
     if (accounts && accounts.length > 0) {
       const existingToken = getSavedToken(accounts[0], this.name);
@@ -30,6 +24,14 @@ class BaseSolanaAdapter extends BaseAdapter {
           };
         }
       }
+      const chainId = await this.provider.request({
+        method: "solana_chainId"
+      });
+      const currentChainConfig = this.coreOptions.chains.find(x => x.chainId === chainId);
+      if (!currentChainConfig) throw WalletInitializationError.invalidParams("chainConfig is required before authentication");
+      const {
+        chainNamespace
+      } = currentChainConfig;
       const payload = {
         domain: window.location.origin,
         uri: window.location.href,
@@ -40,15 +42,14 @@ class BaseSolanaAdapter extends BaseAdapter {
         issuedAt: new Date().toISOString()
       };
       const challenge = await signChallenge(payload, chainNamespace);
-      const encodedMessage = new TextEncoder().encode(challenge);
       const signedMessage = await this.provider.request({
-        method: "signMessage",
+        method: SOLANA_METHOD_TYPES.SIGN_MESSAGE,
         params: {
-          message: encodedMessage,
+          data: challenge,
           display: "utf8"
         }
       });
-      const idToken = await verifySignedChallenge(chainNamespace, bs58.encode(signedMessage), challenge, this.name, this.sessionTime, this.clientId, this.web3AuthNetwork);
+      const idToken = await verifySignedChallenge(chainNamespace, signedMessage, challenge, this.name, this.coreOptions.sessionTime, this.coreOptions.clientId, this.coreOptions.web3AuthNetwork);
       saveToken(accounts[0], this.name, idToken);
       return {
         idToken
@@ -59,7 +60,7 @@ class BaseSolanaAdapter extends BaseAdapter {
   async disconnectSession() {
     super.checkDisconnectionRequirements();
     const accounts = await this.provider.request({
-      method: "getAccounts"
+      method: SOLANA_METHOD_TYPES.GET_ACCOUNTS
     });
     if (accounts && accounts.length > 0) {
       clearToken(accounts[0], this.name);
@@ -67,8 +68,8 @@ class BaseSolanaAdapter extends BaseAdapter {
   }
   async disconnect() {
     this.rehydrated = false;
-    this.emit(ADAPTER_EVENTS.DISCONNECTED);
+    this.emit(CONNECTOR_EVENTS.DISCONNECTED);
   }
 }
 
-export { BaseSolanaAdapter };
+export { BaseSolanaConnector };