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

package/dist/lib.esm/providers/solana-provider/solanaWallet.js

@@ -1,4 +1,6 @@
 import _defineProperty from '@babel/runtime/helpers/defineProperty';
+import { VersionedTransaction } from '@solana/web3.js';
+import { SOLANA_METHOD_TYPES } from '@web3auth/ws-embed';
 
 class SolanaWallet {
   constructor(provider) {
@@ -7,46 +9,59 @@ class SolanaWallet {
   }
   async requestAccounts() {
     const accounts = await this.provider.request({
-      method: "requestAccounts"
+      method: SOLANA_METHOD_TYPES.SOLANA_REQUEST_ACCOUNTS
     });
     return accounts;
   }
   async signAndSendTransaction(transaction) {
-    const {
-      signature
-    } = await this.provider.request({
-      method: "signAndSendTransaction",
+    const signature = await this.provider.request({
+      method: SOLANA_METHOD_TYPES.SEND_TRANSACTION,
       params: {
-        message: transaction
+        message: this.serializeTransaction(transaction)
       }
     });
-    return {
-      signature
-    };
+    return signature;
   }
+  /**
+   * Signs a transaction and returns the signature
+   * @param transaction - The transaction to sign
+   * @returns The signature of the transaction encoded in base58
+   */
   async signTransaction(transaction) {
-    const signedTransaction = await this.provider.request({
-      method: "signTransaction",
+    const signature = await this.provider.request({
+      method: SOLANA_METHOD_TYPES.SIGN_TRANSACTION,
       params: {
-        message: transaction
+        message: this.serializeTransaction(transaction)
       }
     });
-    return signedTransaction;
+    return signature;
   }
+  /**
+   * Signs multiple transactions and returns the serialized transactions
+   * @param transactions - The transactions to sign
+   * @returns The serialized transactions encoded in base64
+   */
   async signAllTransactions(transactions) {
+    const serializedTransactions = transactions.map(tx => this.serializeTransaction(tx));
     const signedTransactions = await this.provider.request({
-      method: "signAllTransactions",
+      method: SOLANA_METHOD_TYPES.SIGN_ALL_TRANSACTIONS,
       params: {
-        message: transactions
+        message: serializedTransactions
       }
     });
     return signedTransactions;
   }
-  async signMessage(data) {
+  /**
+   * Signs a message and returns the signature
+   * @param message - The message to sign
+   * @returns The signature of the message encoded in base58
+   */
+  async signMessage(message, pubKey) {
     const response = await this.provider.request({
-      method: "signMessage",
+      method: SOLANA_METHOD_TYPES.SIGN_MESSAGE,
       params: {
-        message: data
+        data: message,
+        from: pubKey
       }
     });
     return response;
@@ -55,6 +70,14 @@ class SolanaWallet {
     const result = await this.provider.request(args);
     return result;
   }
+  serializeTransaction(transaction) {
+    if (transaction instanceof VersionedTransaction) {
+      return Buffer.from(transaction.serialize()).toString("base64");
+    }
+    return Buffer.from(transaction.serialize({
+      requireAllSignatures: false
+    })).toString("base64");
+  }
 }
 
 export { SolanaWallet };

package/dist/lib.esm/providers/xrpl-provider/providers/privateKeyProviders/xrplPrivateKeyProvider.js

@@ -1,11 +1,22 @@
 import _defineProperty from '@babel/runtime/helpers/defineProperty';
 import { providerErrors, JRPCEngine, providerFromEngine, rpcErrors } from '@web3auth/auth';
-import { CHAIN_NAMESPACES } from '../../../../base/chain/IChainInterface.js';
 import { WalletInitializationError } from '../../../../base/errors/index.js';
+import { CHAIN_NAMESPACES } from '@toruslabs/base-controllers';
+import '../../../../base/wallet/index.js';
+import '../../../../base/connector/constants.js';
+import 'jwt-decode';
+import '../../../../base/loglevel.js';
+import '../../../../base/plugin/errors.js';
+import '../../../../base/plugin/IPlugin.js';
+import '@toruslabs/constants';
+import '@toruslabs/http-helpers';
+import { BaseProvider } from '../../../base-provider/baseProvider.js';
+import '../../../base-provider/CommonJRPCProvider.js';
+import '../../../base-provider/commonPrivateKeyProvider.js';
+import '../../../base-provider/utils.js';
 import { createXrplJsonRpcClient } from '../../rpc/JrpcClient.js';
 import { RPC_METHODS, createXRPLMiddleware, creatXrplChainSwitchMiddleware } from '../../rpc/xrplRpcMiddlewares.js';
 import { getProviderHandlers } from './xrplWalletUtils.js';
-import { BaseProvider } from '../../../base-provider/baseProvider.js';
 
 var _XrplPrivateKeyProvider;
 class XrplPrivateKeyProvider extends BaseProvider {
@@ -24,114 +35,78 @@ class XrplPrivateKeyProvider extends BaseProvider {
       message: "Private key is not found in state, plz pass it in constructor state param",
       code: 4902
     });
-    await this.setupProvider(this.state.privateKey);
+    await this.setupProvider(this.state.privateKey, this.chainId);
     return this._providerEngineProxy.request({
       method: RPC_METHODS.GET_ACCOUNTS
     });
   }
-  async setupProvider(privKey) {
+  async setupProvider(privKey, chainId) {
+    const chain = this.getChain(chainId);
     const {
       wsTarget,
       chainNamespace
-    } = this.config.chainConfig;
+    } = chain;
     if (chainNamespace !== this.PROVIDER_CHAIN_NAMESPACE) throw WalletInitializationError.incompatibleChainNameSpace("Invalid chain namespace");
     if (!wsTarget) {
       throw WalletInitializationError.invalidParams(`wsTarget is required in chainConfig for xrplProvider`);
     }
     const providerHandlers = await getProviderHandlers({
       privKey,
-      chainConfig: this.config.chainConfig,
+      chainConfig: chain,
       keyExportEnabled: this.config.keyExportEnabled
     });
     const xrplWalletMiddleware = createXRPLMiddleware(providerHandlers);
     const engine = new JRPCEngine();
     const {
       networkMiddleware
-    } = createXrplJsonRpcClient(this.config.chainConfig);
+    } = createXrplJsonRpcClient(chain);
     engine.push(this.getChainSwitchMiddleware());
     engine.push(xrplWalletMiddleware);
     engine.push(networkMiddleware);
     const provider = providerFromEngine(engine);
     this.updateProviderEngineProxy(provider);
-    await this.lookupNetwork();
+    await this.lookupNetwork(privKey, chainId);
+    this.emit("chainChanged", chainId);
+    this.emit("connect", {
+      chainId
+    });
+    this.update({
+      chainId
+    });
   }
   async switchChain(params) {
     if (!this._providerEngineProxy) throw providerErrors.custom({
       message: "Provider is not initialized",
       code: 4902
     });
-    const chainConfig = this.getChainConfig(params.chainId);
+    if (this.chainId === params.chainId) return;
     this.update({
       chainId: "loading"
     });
-    this.configure({
-      chainConfig
-    });
     const {
       privateKey
     } = await this._providerEngineProxy.request({
       method: RPC_METHODS.GET_KEY_PAIR
     });
-    await this.setupProvider(privateKey);
+    await this.setupProvider(privateKey, params.chainId);
   }
-  async lookupNetwork() {
+  async lookupNetwork(_privKey, chainId) {
     if (!this._providerEngineProxy) throw providerErrors.custom({
       message: "Provider is not initialized",
       code: 4902
     });
-    const {
-      chainId
-    } = this.config.chainConfig;
     if (!chainId) throw rpcErrors.invalidParams("chainId is required while lookupNetwork");
     const pingResponse = await this._providerEngineProxy.request({
       method: "ping",
       params: []
     });
     if ((pingResponse === null || pingResponse === void 0 ? void 0 : pingResponse.status) !== "success") {
-      const {
-        chainConfig
-      } = this.config;
-      throw WalletInitializationError.rpcConnectionError(`Failed to ping network for following rpc target: ${chainConfig.rpcTarget}`);
+      const chain = this.getChain(chainId);
+      throw WalletInitializationError.rpcConnectionError(`Failed to ping network for following rpc target: ${chain.rpcTarget}`);
     }
-    if (this.state.chainId !== chainId) {
-      this.emit("chainChanged", chainId);
-      this.emit("connect", {
-        chainId
-      });
-    }
-    this.update({
-      chainId
-    });
   }
   getChainSwitchMiddleware() {
     const chainSwitchHandlers = {
-      addChainConfig: async req => {
-        if (!req.params) throw rpcErrors.invalidParams("Missing request params");
-        const {
-          chainId,
-          ticker,
-          tickerName,
-          displayName,
-          rpcTarget,
-          wsTarget,
-          blockExplorerUrl,
-          logo
-        } = req.params;
-        if (!chainId) throw rpcErrors.invalidParams("Missing chainId in chainParams");
-        if (!rpcTarget) throw rpcErrors.invalidParams("Missing rpcTarget in chainParams");
-        if (!wsTarget) throw rpcErrors.invalidParams("Missing wsTarget in chainParams");
-        this.addChain({
-          chainNamespace: CHAIN_NAMESPACES.XRPL,
-          chainId,
-          ticker: ticker || "XRP",
-          tickerName: tickerName || "XRPL",
-          displayName: displayName || "XRPL",
-          rpcTarget,
-          wsTarget,
-          blockExplorerUrl,
-          logo
-        });
-      },
       switchChain: async req => {
         if (!req.params) throw rpcErrors.invalidParams("Missing request params");
         if (!req.params.chainId) throw rpcErrors.invalidParams("Missing chainId");
@@ -146,10 +121,11 @@ _XrplPrivateKeyProvider = XrplPrivateKeyProvider;
 _defineProperty(XrplPrivateKeyProvider, "getProviderInstance", async params => {
   const providerFactory = new _XrplPrivateKeyProvider({
     config: {
-      chainConfig: params.chainConfig
+      chain: params.chain,
+      chains: params.chains
     }
   });
-  await providerFactory.setupProvider(params.privKey);
+  await providerFactory.setupProvider(params.privKey, params.chain.chainId);
   return providerFactory;
 });
 

package/dist/lib.esm/providers/xrpl-provider/rpc/xrplRpcMiddlewares.js

@@ -8,7 +8,6 @@ const RPC_METHODS = {
   SIGN_MESSAGE: "xrpl_signMessage",
   SIGN_TRANSACTION: "xrpl_signTransaction",
   SUBMIT_TRANSACTION: "xrpl_submitTransaction",
-  ADD_CHAIN: "xrpl_addChain",
   SWITCH_CHAIN: "xrpl_switchChain",
   CHAIN_ID: "xrpl_chainId",
   PROVIDER_CHAIN_CONFIG: "xrpl_providerChainConfig"
@@ -20,7 +19,6 @@ function createGetAccountsMiddleware({
     const {
       method
     } = request;
-
     // hack to override big ids from fetch middleware which are not supported in xrpl servers
     // TODO: fix this for xrpl controllers.
     request.id = randomId();
@@ -58,10 +56,9 @@ function createXRPLMiddleware(providerHandlers) {
   }), createGenericJRPCMiddleware(RPC_METHODS.SIGN_TRANSACTION, signTransaction), createGenericJRPCMiddleware(RPC_METHODS.SUBMIT_TRANSACTION, submitTransaction), createGenericJRPCMiddleware(RPC_METHODS.SIGN_MESSAGE, signMessage), createGenericJRPCMiddleware(RPC_METHODS.GET_KEY_PAIR, getKeyPair), createGenericJRPCMiddleware(RPC_METHODS.GET_PUBLIC_KEY, getPublicKey)]);
 }
 function creatXrplChainSwitchMiddleware({
-  addChainConfig,
   switchChain
 }) {
-  return mergeMiddleware([createGenericJRPCMiddleware(RPC_METHODS.ADD_CHAIN, addChainConfig), createGenericJRPCMiddleware(RPC_METHODS.SWITCH_CHAIN, switchChain)]);
+  return mergeMiddleware([createGenericJRPCMiddleware(RPC_METHODS.SWITCH_CHAIN, switchChain)]);
 }
 
 export { RPC_METHODS, creatXrplChainSwitchMiddleware, createGenericJRPCMiddleware, createGetAccountsMiddleware, createXRPLMiddleware };

package/dist/lib.esm/react/no-modal/Web3AuthInnerContext.js

@@ -1,7 +1,17 @@
 import { createContext, useState, useCallback, useEffect, useMemo, createElement } from 'react';
 import { WalletInitializationError, WalletLoginError } from '../../base/errors/index.js';
+import '@toruslabs/base-controllers';
+import '@babel/runtime/helpers/defineProperty';
+import '@web3auth/auth';
+import '../../base/wallet/index.js';
+import { CONNECTOR_EVENTS, CONNECTOR_STATUS } from '../../base/connector/constants.js';
+import 'jwt-decode';
+import '../../base/loglevel.js';
+import '../../base/plugin/errors.js';
+import '../../base/plugin/IPlugin.js';
+import '@toruslabs/constants';
+import '@toruslabs/http-helpers';
 import { Web3AuthNoModal } from '../../noModal.js';
-import { ADAPTER_EVENTS, ADAPTER_STATUS } from '../../base/adapter/constants.js';
 
 const Web3AuthInnerContext = createContext(null);
 function Web3AuthInnerProvider(params) {
@@ -20,10 +30,6 @@ function Web3AuthInnerProvider(params) {
   const [isMFAEnabled, setIsMFAEnabled] = useState(false);
   const [isInitialized, setIsInitialized] = useState(false);
   const [status, setStatus] = useState(null);
-  const addPlugin = useCallback(plugin => {
-    if (!web3Auth) throw WalletInitializationError.notReady();
-    return web3Auth.addPlugin(plugin);
-  }, [web3Auth]);
   const getPlugin = useCallback(name => {
     if (!web3Auth) throw WalletInitializationError.notReady();
     return web3Auth.getPlugin(name);
@@ -38,15 +44,9 @@ function Web3AuthInnerProvider(params) {
     };
     resetHookState();
     const {
-      web3AuthOptions,
-      adapters = [],
-      plugins = []
+      web3AuthOptions
     } = config;
     const web3Instance = new Web3AuthNoModal(web3AuthOptions);
-    if (adapters.length) adapters.map(adapter => web3Instance.configureAdapter(adapter));
-    if (plugins.length) plugins.forEach(plugin => {
-      web3Instance.addPlugin(plugin);
-    });
     setWeb3Auth(web3Instance);
   }, [config]);
   useEffect(() => {
@@ -79,11 +79,9 @@ function Web3AuthInnerProvider(params) {
       if (isConnected) addState();else resetState();
     }
   }, [web3Auth, isConnected]);
-
   // TODO: don't throw error in init, connect in v9
-
   useEffect(() => {
-    const notReadyListener = () => setStatus(ADAPTER_STATUS.NOT_READY);
+    const notReadyListener = () => setStatus(CONNECTOR_STATUS.NOT_READY);
     const readyListener = () => {
       setStatus(web3Auth.status);
       setIsInitialized(true);
@@ -91,7 +89,7 @@ function Web3AuthInnerProvider(params) {
     const connectedListener = () => {
       setStatus(web3Auth.status);
       // we do this because of rehydration issues. status connected is fired first but web3auth sdk is not ready yet.
-      if (web3Auth.status === ADAPTER_STATUS.CONNECTED) {
+      if (web3Auth.status === CONNECTOR_STATUS.CONNECTED) {
         setIsInitialized(true);
         setIsConnected(true);
       }
@@ -104,26 +102,26 @@ function Web3AuthInnerProvider(params) {
       setStatus(web3Auth.status);
     };
     const errorListener = () => {
-      setStatus(ADAPTER_STATUS.ERRORED);
+      setStatus(CONNECTOR_STATUS.ERRORED);
     };
     if (web3Auth) {
       // web3Auth is initialized here.
       setStatus(web3Auth.status);
-      web3Auth.on(ADAPTER_EVENTS.NOT_READY, notReadyListener);
-      web3Auth.on(ADAPTER_EVENTS.READY, readyListener);
-      web3Auth.on(ADAPTER_EVENTS.CONNECTED, connectedListener);
-      web3Auth.on(ADAPTER_EVENTS.DISCONNECTED, disconnectedListener);
-      web3Auth.on(ADAPTER_EVENTS.CONNECTING, connectingListener);
-      web3Auth.on(ADAPTER_EVENTS.ERRORED, errorListener);
+      web3Auth.on(CONNECTOR_EVENTS.NOT_READY, notReadyListener);
+      web3Auth.on(CONNECTOR_EVENTS.READY, readyListener);
+      web3Auth.on(CONNECTOR_EVENTS.CONNECTED, connectedListener);
+      web3Auth.on(CONNECTOR_EVENTS.DISCONNECTED, disconnectedListener);
+      web3Auth.on(CONNECTOR_EVENTS.CONNECTING, connectingListener);
+      web3Auth.on(CONNECTOR_EVENTS.ERRORED, errorListener);
     }
     return () => {
       if (web3Auth) {
-        web3Auth.off(ADAPTER_EVENTS.NOT_READY, notReadyListener);
-        web3Auth.off(ADAPTER_EVENTS.READY, readyListener);
-        web3Auth.off(ADAPTER_EVENTS.CONNECTED, connectedListener);
-        web3Auth.off(ADAPTER_EVENTS.DISCONNECTED, disconnectedListener);
-        web3Auth.off(ADAPTER_EVENTS.CONNECTING, connectingListener);
-        web3Auth.off(ADAPTER_EVENTS.ERRORED, errorListener);
+        web3Auth.off(CONNECTOR_EVENTS.NOT_READY, notReadyListener);
+        web3Auth.off(CONNECTOR_EVENTS.READY, readyListener);
+        web3Auth.off(CONNECTOR_EVENTS.CONNECTED, connectedListener);
+        web3Auth.off(CONNECTOR_EVENTS.DISCONNECTED, disconnectedListener);
+        web3Auth.off(CONNECTOR_EVENTS.CONNECTING, connectingListener);
+        web3Auth.off(CONNECTOR_EVENTS.ERRORED, errorListener);
       }
     };
   }, [web3Auth]);
@@ -161,21 +159,10 @@ function Web3AuthInnerProvider(params) {
       setIsConnecting(false);
     }
   }, [web3Auth]);
-  const addAndSwitchChain = useCallback(async chainConfig => {
-    if (!web3Auth) throw WalletInitializationError.notReady();
-    await web3Auth.addChain(chainConfig);
-    await web3Auth.switchChain({
-      chainId: chainConfig.chainId
-    });
-  }, [web3Auth]);
   const authenticateUser = useCallback(async () => {
     if (!web3Auth) throw WalletInitializationError.notReady();
     return web3Auth.authenticateUser();
   }, [web3Auth]);
-  const addChain = useCallback(async chainConfig => {
-    if (!web3Auth) throw WalletInitializationError.notReady();
-    return web3Auth.addChain(chainConfig);
-  }, [web3Auth]);
   const switchChain = useCallback(chainParams => {
     if (!web3Auth) throw WalletInitializationError.notReady();
     return web3Auth.switchChain(chainParams);
@@ -194,9 +181,6 @@ function Web3AuthInnerProvider(params) {
       enableMFA,
       manageMFA,
       logout,
-      addAndSwitchChain,
-      addChain,
-      addPlugin,
       authenticateUser,
       switchChain,
       isInitializing,
@@ -204,7 +188,7 @@ function Web3AuthInnerProvider(params) {
       initError,
       connectError
     };
-  }, [web3Auth, isConnected, isInitialized, provider, userInfo, isMFAEnabled, status, connectTo, getPlugin, enableMFA, manageMFA, logout, addAndSwitchChain, addChain, addPlugin, authenticateUser, switchChain, isConnecting, isInitializing, initError, connectError]);
+  }, [web3Auth, isConnected, isInitialized, provider, userInfo, isMFAEnabled, status, connectTo, getPlugin, enableMFA, manageMFA, logout, authenticateUser, switchChain, isConnecting, isInitializing, initError, connectError]);
   return createElement(Web3AuthInnerContext.Provider, {
     value
   }, children);

package/dist/lib.esm/react/no-modal/hooks/useWeb3Auth.js

@@ -1,5 +1,16 @@
 import { useContext } from 'react';
 import { WalletInitializationError } from '../../../base/errors/index.js';
+import '@toruslabs/base-controllers';
+import '@babel/runtime/helpers/defineProperty';
+import '@web3auth/auth';
+import '../../../base/wallet/index.js';
+import '../../../base/connector/constants.js';
+import 'jwt-decode';
+import '../../../base/loglevel.js';
+import '../../../base/plugin/errors.js';
+import '../../../base/plugin/IPlugin.js';
+import '@toruslabs/constants';
+import '@toruslabs/http-helpers';
 import { Web3AuthInnerContext } from '../Web3AuthInnerContext.js';
 
 const useWeb3Auth = () => {

package/dist/lib.esm/react/wallet-services-plugin/WalletServicesContext.js

@@ -1,6 +1,16 @@
 import { createContext, useState, useContext, useEffect, useCallback, useMemo, createElement } from 'react';
-import { EVM_PLUGINS, PLUGIN_EVENTS } from '../../base/plugin/IPlugin.js';
+import '../../base/errors/index.js';
+import '@toruslabs/base-controllers';
+import '@babel/runtime/helpers/defineProperty';
+import '@web3auth/auth';
+import '../../base/wallet/index.js';
+import { CONNECTOR_STATUS } from '../../base/connector/constants.js';
+import 'jwt-decode';
+import '../../base/loglevel.js';
 import { WalletServicesPluginError } from '../../base/plugin/errors.js';
+import { EVM_PLUGINS, PLUGIN_EVENTS } from '../../base/plugin/IPlugin.js';
+import '@toruslabs/constants';
+import '@toruslabs/http-helpers';
 
 const WalletServicesContext = createContext(null);
 function WalletServicesContextProvider({
@@ -25,6 +35,8 @@ function WalletServicesContextProvider({
     if (isConnected) {
       const plugin = getPlugin(EVM_PLUGINS.WALLET_SERVICES);
       if (!walletServicesPlugin) setWalletServicesPlugin(plugin);
+      // when rehydrating, the connectedListener may be registered after the connected event is emitted, we need to check the status here
+      if ((walletServicesPlugin === null || walletServicesPlugin === void 0 ? void 0 : walletServicesPlugin.status) === CONNECTOR_STATUS.CONNECTED) setIsPluginConnected(true);
     }
   }, [isConnected, getPlugin, walletServicesPlugin]);
   useEffect(() => {

package/dist/lib.esm/react/wallet-services-plugin/hooks/useWalletServicesPlugin.js

@@ -1,5 +1,16 @@
 import { useContext } from 'react';
 import { WalletInitializationError } from '../../../base/errors/index.js';
+import '@toruslabs/base-controllers';
+import '@babel/runtime/helpers/defineProperty';
+import '@web3auth/auth';
+import '../../../base/wallet/index.js';
+import '../../../base/connector/constants.js';
+import 'jwt-decode';
+import '../../../base/loglevel.js';
+import '../../../base/plugin/errors.js';
+import '../../../base/plugin/IPlugin.js';
+import '@toruslabs/constants';
+import '@toruslabs/http-helpers';
 import { WalletServicesContext } from '../WalletServicesContext.js';
 
 const useWalletServicesPlugin = () => {

package/dist/lib.esm/vue/no-modal/Web3AuthProvider.js

@@ -1,8 +1,18 @@
 import { defineComponent, h, shallowRef, ref, watch, provide } from 'vue';
-import { Web3AuthContextKey } from '../../base/composables/index.js';
 import { WalletInitializationError, WalletLoginError } from '../../base/errors/index.js';
+import '@toruslabs/base-controllers';
+import { Web3AuthContextKey } from '../../base/composables/index.js';
+import '@babel/runtime/helpers/defineProperty';
+import '@web3auth/auth';
+import '../../base/wallet/index.js';
+import { CONNECTOR_EVENTS, CONNECTOR_STATUS } from '../../base/connector/constants.js';
+import 'jwt-decode';
+import '../../base/loglevel.js';
+import '../../base/plugin/errors.js';
+import '../../base/plugin/IPlugin.js';
+import '@toruslabs/constants';
+import '@toruslabs/http-helpers';
 import { Web3AuthNoModal } from '../../noModal.js';
-import { ADAPTER_EVENTS, ADAPTER_STATUS } from '../../base/adapter/constants.js';
 
 const Web3AuthProvider = defineComponent({
   name: "Web3AuthProvider",
@@ -24,10 +34,6 @@ const Web3AuthProvider = defineComponent({
     const isConnecting = ref(false);
     const connectError = ref(null);
     const isConnected = ref(false);
-    const addPlugin = plugin => {
-      if (!web3Auth.value) throw WalletInitializationError.notReady();
-      return web3Auth.value.addPlugin(plugin);
-    };
     const getPlugin = name => {
       if (!web3Auth.value) throw WalletInitializationError.notReady();
       return web3Auth.value.getPlugin(name);
@@ -65,21 +71,10 @@ const Web3AuthProvider = defineComponent({
         isConnecting.value = false;
       }
     };
-    const addAndSwitchChain = async chainConfig => {
-      if (!web3Auth.value) throw WalletInitializationError.notReady();
-      await web3Auth.value.addChain(chainConfig);
-      await web3Auth.value.switchChain({
-        chainId: chainConfig.chainId
-      });
-    };
     const authenticateUser = async () => {
       if (!web3Auth.value) throw WalletInitializationError.notReady();
       return web3Auth.value.authenticateUser();
     };
-    const addChain = async chainConfig => {
-      if (!web3Auth.value) throw WalletInitializationError.notReady();
-      return web3Auth.value.addChain(chainConfig);
-    };
     const switchChain = chainParams => {
       if (!web3Auth.value) throw WalletInitializationError.notReady();
       return web3Auth.value.switchChain(chainParams);
@@ -94,17 +89,9 @@ const Web3AuthProvider = defineComponent({
       };
       resetHookState();
       const {
-        web3AuthOptions,
-        adapters = [],
-        plugins = []
+        web3AuthOptions
       } = newConfig;
       const web3AuthInstance = new Web3AuthNoModal(web3AuthOptions);
-      if (adapters.length) adapters.map(adapter => web3AuthInstance.configureAdapter(adapter));
-      if (plugins.length) {
-        plugins.forEach(plugin => {
-          web3AuthInstance.addPlugin(plugin);
-        });
-      }
       web3Auth.value = web3AuthInstance;
     }, {
       immediate: true
@@ -149,7 +136,7 @@ const Web3AuthProvider = defineComponent({
       const connectedListener = () => {
         status.value = web3Auth.value.status;
         // we do this because of rehydration issues. status connected is fired first but web3auth sdk is not ready yet.
-        if (web3Auth.value.status === ADAPTER_STATUS.CONNECTED) {
+        if (web3Auth.value.status === CONNECTOR_STATUS.CONNECTED) {
           isInitialized.value = true;
           isConnected.value = true;
         }
@@ -162,27 +149,26 @@ const Web3AuthProvider = defineComponent({
         status.value = web3Auth.value.status;
       };
       const errorListener = () => {
-        status.value = ADAPTER_EVENTS.ERRORED;
+        status.value = CONNECTOR_EVENTS.ERRORED;
       };
-
       // unregister previous listeners
       if (prevWeb3Auth && newWeb3Auth !== prevWeb3Auth) {
-        prevWeb3Auth.off(ADAPTER_EVENTS.NOT_READY, notReadyListener);
-        prevWeb3Auth.off(ADAPTER_EVENTS.READY, readyListener);
-        prevWeb3Auth.off(ADAPTER_EVENTS.CONNECTED, connectedListener);
-        prevWeb3Auth.off(ADAPTER_EVENTS.DISCONNECTED, disconnectedListener);
-        prevWeb3Auth.off(ADAPTER_EVENTS.CONNECTING, connectingListener);
-        prevWeb3Auth.off(ADAPTER_EVENTS.ERRORED, errorListener);
+        prevWeb3Auth.off(CONNECTOR_EVENTS.NOT_READY, notReadyListener);
+        prevWeb3Auth.off(CONNECTOR_EVENTS.READY, readyListener);
+        prevWeb3Auth.off(CONNECTOR_EVENTS.CONNECTED, connectedListener);
+        prevWeb3Auth.off(CONNECTOR_EVENTS.DISCONNECTED, disconnectedListener);
+        prevWeb3Auth.off(CONNECTOR_EVENTS.CONNECTING, connectingListener);
+        prevWeb3Auth.off(CONNECTOR_EVENTS.ERRORED, errorListener);
       }
       if (newWeb3Auth && newWeb3Auth !== prevWeb3Auth) {
         status.value = newWeb3Auth.status;
         // web3Auth is initialized here.
-        newWeb3Auth.on(ADAPTER_EVENTS.NOT_READY, notReadyListener);
-        newWeb3Auth.on(ADAPTER_EVENTS.READY, readyListener);
-        newWeb3Auth.on(ADAPTER_EVENTS.CONNECTED, connectedListener);
-        newWeb3Auth.on(ADAPTER_EVENTS.DISCONNECTED, disconnectedListener);
-        newWeb3Auth.on(ADAPTER_EVENTS.CONNECTING, connectingListener);
-        newWeb3Auth.on(ADAPTER_EVENTS.ERRORED, errorListener);
+        newWeb3Auth.on(CONNECTOR_EVENTS.NOT_READY, notReadyListener);
+        newWeb3Auth.on(CONNECTOR_EVENTS.READY, readyListener);
+        newWeb3Auth.on(CONNECTOR_EVENTS.CONNECTED, connectedListener);
+        newWeb3Auth.on(CONNECTOR_EVENTS.DISCONNECTED, disconnectedListener);
+        newWeb3Auth.on(CONNECTOR_EVENTS.CONNECTING, connectingListener);
+        newWeb3Auth.on(CONNECTOR_EVENTS.ERRORED, errorListener);
       }
     }, {
       immediate: true
@@ -200,9 +186,6 @@ const Web3AuthProvider = defineComponent({
       enableMFA,
       manageMFA,
       logout,
-      addAndSwitchChain,
-      addChain,
-      addPlugin,
       authenticateUser,
       switchChain,
       isInitializing,

package/dist/lib.esm/vue/no-modal/composables/useWeb3Auth.js

@@ -1,6 +1,17 @@
 import { inject } from 'vue';
-import { Web3AuthContextKey } from '../../../base/composables/index.js';
 import { WalletInitializationError } from '../../../base/errors/index.js';
+import '@toruslabs/base-controllers';
+import { Web3AuthContextKey } from '../../../base/composables/index.js';
+import '@babel/runtime/helpers/defineProperty';
+import '@web3auth/auth';
+import '../../../base/wallet/index.js';
+import '../../../base/connector/constants.js';
+import 'jwt-decode';
+import '../../../base/loglevel.js';
+import '../../../base/plugin/errors.js';
+import '../../../base/plugin/IPlugin.js';
+import '@toruslabs/constants';
+import '@toruslabs/http-helpers';
 
 const useWeb3Auth = () => {
   const context = inject(Web3AuthContextKey);