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

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

@@ -1,6 +1,8 @@
 'use strict';
 
 var _defineProperty = require('@babel/runtime/helpers/defineProperty');
+var web3_js = require('@solana/web3.js');
+var wsEmbed = require('@web3auth/ws-embed');
 
 class SolanaWallet {
   constructor(provider) {
@@ -9,46 +11,59 @@ class SolanaWallet {
   }
   async requestAccounts() {
     const accounts = await this.provider.request({
-      method: "requestAccounts"
+      method: wsEmbed.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: wsEmbed.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: wsEmbed.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: wsEmbed.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: wsEmbed.SOLANA_METHOD_TYPES.SIGN_MESSAGE,
       params: {
-        message: data
+        data: message,
+        from: pubKey
       }
     });
     return response;
@@ -57,6 +72,14 @@ class SolanaWallet {
     const result = await this.provider.request(args);
     return result;
   }
+  serializeTransaction(transaction) {
+    if (transaction instanceof web3_js.VersionedTransaction) {
+      return Buffer.from(transaction.serialize()).toString("base64");
+    }
+    return Buffer.from(transaction.serialize({
+      requireAllSignatures: false
+    })).toString("base64");
+  }
 }
 
 exports.SolanaWallet = SolanaWallet;

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

@@ -2,12 +2,23 @@
 
 var _defineProperty = require('@babel/runtime/helpers/defineProperty');
 var auth = require('@web3auth/auth');
-var IChainInterface = require('../../../../base/chain/IChainInterface.js');
 var index = require('../../../../base/errors/index.js');
+var baseControllers = require('@toruslabs/base-controllers');
+require('../../../../base/wallet/index.js');
+require('../../../../base/connector/constants.js');
+require('jwt-decode');
+require('../../../../base/loglevel.js');
+require('../../../../base/plugin/errors.js');
+require('../../../../base/plugin/IPlugin.js');
+require('@toruslabs/constants');
+require('@toruslabs/http-helpers');
+var baseProvider = require('../../../base-provider/baseProvider.js');
+require('../../../base-provider/CommonJRPCProvider.js');
+require('../../../base-provider/commonPrivateKeyProvider.js');
+require('../../../base-provider/utils.js');
 var JrpcClient = require('../../rpc/JrpcClient.js');
 var xrplRpcMiddlewares = require('../../rpc/xrplRpcMiddlewares.js');
 var xrplWalletUtils = require('./xrplWalletUtils.js');
-var baseProvider = require('../../../base-provider/baseProvider.js');
 
 var _XrplPrivateKeyProvider;
 class XrplPrivateKeyProvider extends baseProvider.BaseProvider {
@@ -19,121 +30,85 @@ class XrplPrivateKeyProvider extends baseProvider.BaseProvider {
       config,
       state
     });
-    _defineProperty(this, "PROVIDER_CHAIN_NAMESPACE", IChainInterface.CHAIN_NAMESPACES.XRPL);
+    _defineProperty(this, "PROVIDER_CHAIN_NAMESPACE", baseControllers.CHAIN_NAMESPACES.XRPL);
   }
   async enable() {
     if (!this.state.privateKey) throw auth.providerErrors.custom({
       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: xrplRpcMiddlewares.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 index.WalletInitializationError.incompatibleChainNameSpace("Invalid chain namespace");
     if (!wsTarget) {
       throw index.WalletInitializationError.invalidParams(`wsTarget is required in chainConfig for xrplProvider`);
     }
     const providerHandlers = await xrplWalletUtils.getProviderHandlers({
       privKey,
-      chainConfig: this.config.chainConfig,
+      chainConfig: chain,
       keyExportEnabled: this.config.keyExportEnabled
     });
     const xrplWalletMiddleware = xrplRpcMiddlewares.createXRPLMiddleware(providerHandlers);
     const engine = new auth.JRPCEngine();
     const {
       networkMiddleware
-    } = JrpcClient.createXrplJsonRpcClient(this.config.chainConfig);
+    } = JrpcClient.createXrplJsonRpcClient(chain);
     engine.push(this.getChainSwitchMiddleware());
     engine.push(xrplWalletMiddleware);
     engine.push(networkMiddleware);
     const provider = auth.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 auth.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: xrplRpcMiddlewares.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 auth.providerErrors.custom({
       message: "Provider is not initialized",
       code: 4902
     });
-    const {
-      chainId
-    } = this.config.chainConfig;
     if (!chainId) throw auth.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 index.WalletInitializationError.rpcConnectionError(`Failed to ping network for following rpc target: ${chainConfig.rpcTarget}`);
+      const chain = this.getChain(chainId);
+      throw index.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 auth.rpcErrors.invalidParams("Missing request params");
-        const {
-          chainId,
-          ticker,
-          tickerName,
-          displayName,
-          rpcTarget,
-          wsTarget,
-          blockExplorerUrl,
-          logo
-        } = req.params;
-        if (!chainId) throw auth.rpcErrors.invalidParams("Missing chainId in chainParams");
-        if (!rpcTarget) throw auth.rpcErrors.invalidParams("Missing rpcTarget in chainParams");
-        if (!wsTarget) throw auth.rpcErrors.invalidParams("Missing wsTarget in chainParams");
-        this.addChain({
-          chainNamespace: IChainInterface.CHAIN_NAMESPACES.XRPL,
-          chainId,
-          ticker: ticker || "XRP",
-          tickerName: tickerName || "XRPL",
-          displayName: displayName || "XRPL",
-          rpcTarget,
-          wsTarget,
-          blockExplorerUrl,
-          logo
-        });
-      },
       switchChain: async req => {
         if (!req.params) throw auth.rpcErrors.invalidParams("Missing request params");
         if (!req.params.chainId) throw auth.rpcErrors.invalidParams("Missing chainId");
@@ -148,10 +123,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.cjs/providers/xrpl-provider/rpc/xrplRpcMiddlewares.js

@@ -10,7 +10,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"
@@ -22,7 +21,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 = baseControllers.randomId();
@@ -60,10 +58,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 auth.mergeMiddleware([createGenericJRPCMiddleware(RPC_METHODS.ADD_CHAIN, addChainConfig), createGenericJRPCMiddleware(RPC_METHODS.SWITCH_CHAIN, switchChain)]);
+  return auth.mergeMiddleware([createGenericJRPCMiddleware(RPC_METHODS.SWITCH_CHAIN, switchChain)]);
 }
 
 exports.RPC_METHODS = RPC_METHODS;

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

@@ -2,8 +2,18 @@
 
 var react = require('react');
 var index = require('../../base/errors/index.js');
+require('@toruslabs/base-controllers');
+require('@babel/runtime/helpers/defineProperty');
+require('@web3auth/auth');
+require('../../base/wallet/index.js');
+var constants = require('../../base/connector/constants.js');
+require('jwt-decode');
+require('../../base/loglevel.js');
+require('../../base/plugin/errors.js');
+require('../../base/plugin/IPlugin.js');
+require('@toruslabs/constants');
+require('@toruslabs/http-helpers');
 var noModal = require('../../noModal.js');
-var constants = require('../../base/adapter/constants.js');
 
 const Web3AuthInnerContext = react.createContext(null);
 function Web3AuthInnerProvider(params) {
@@ -22,10 +32,6 @@ function Web3AuthInnerProvider(params) {
   const [isMFAEnabled, setIsMFAEnabled] = react.useState(false);
   const [isInitialized, setIsInitialized] = react.useState(false);
   const [status, setStatus] = react.useState(null);
-  const addPlugin = react.useCallback(plugin => {
-    if (!web3Auth) throw index.WalletInitializationError.notReady();
-    return web3Auth.addPlugin(plugin);
-  }, [web3Auth]);
   const getPlugin = react.useCallback(name => {
     if (!web3Auth) throw index.WalletInitializationError.notReady();
     return web3Auth.getPlugin(name);
@@ -40,15 +46,9 @@ function Web3AuthInnerProvider(params) {
     };
     resetHookState();
     const {
-      web3AuthOptions,
-      adapters = [],
-      plugins = []
+      web3AuthOptions
     } = config;
     const web3Instance = new noModal.Web3AuthNoModal(web3AuthOptions);
-    if (adapters.length) adapters.map(adapter => web3Instance.configureAdapter(adapter));
-    if (plugins.length) plugins.forEach(plugin => {
-      web3Instance.addPlugin(plugin);
-    });
     setWeb3Auth(web3Instance);
   }, [config]);
   react.useEffect(() => {
@@ -81,11 +81,9 @@ function Web3AuthInnerProvider(params) {
       if (isConnected) addState();else resetState();
     }
   }, [web3Auth, isConnected]);
-
   // TODO: don't throw error in init, connect in v9
-
   react.useEffect(() => {
-    const notReadyListener = () => setStatus(constants.ADAPTER_STATUS.NOT_READY);
+    const notReadyListener = () => setStatus(constants.CONNECTOR_STATUS.NOT_READY);
     const readyListener = () => {
       setStatus(web3Auth.status);
       setIsInitialized(true);
@@ -93,7 +91,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 === constants.ADAPTER_STATUS.CONNECTED) {
+      if (web3Auth.status === constants.CONNECTOR_STATUS.CONNECTED) {
         setIsInitialized(true);
         setIsConnected(true);
       }
@@ -106,26 +104,26 @@ function Web3AuthInnerProvider(params) {
       setStatus(web3Auth.status);
     };
     const errorListener = () => {
-      setStatus(constants.ADAPTER_STATUS.ERRORED);
+      setStatus(constants.CONNECTOR_STATUS.ERRORED);
     };
     if (web3Auth) {
       // web3Auth is initialized here.
       setStatus(web3Auth.status);
-      web3Auth.on(constants.ADAPTER_EVENTS.NOT_READY, notReadyListener);
-      web3Auth.on(constants.ADAPTER_EVENTS.READY, readyListener);
-      web3Auth.on(constants.ADAPTER_EVENTS.CONNECTED, connectedListener);
-      web3Auth.on(constants.ADAPTER_EVENTS.DISCONNECTED, disconnectedListener);
-      web3Auth.on(constants.ADAPTER_EVENTS.CONNECTING, connectingListener);
-      web3Auth.on(constants.ADAPTER_EVENTS.ERRORED, errorListener);
+      web3Auth.on(constants.CONNECTOR_EVENTS.NOT_READY, notReadyListener);
+      web3Auth.on(constants.CONNECTOR_EVENTS.READY, readyListener);
+      web3Auth.on(constants.CONNECTOR_EVENTS.CONNECTED, connectedListener);
+      web3Auth.on(constants.CONNECTOR_EVENTS.DISCONNECTED, disconnectedListener);
+      web3Auth.on(constants.CONNECTOR_EVENTS.CONNECTING, connectingListener);
+      web3Auth.on(constants.CONNECTOR_EVENTS.ERRORED, errorListener);
     }
     return () => {
       if (web3Auth) {
-        web3Auth.off(constants.ADAPTER_EVENTS.NOT_READY, notReadyListener);
-        web3Auth.off(constants.ADAPTER_EVENTS.READY, readyListener);
-        web3Auth.off(constants.ADAPTER_EVENTS.CONNECTED, connectedListener);
-        web3Auth.off(constants.ADAPTER_EVENTS.DISCONNECTED, disconnectedListener);
-        web3Auth.off(constants.ADAPTER_EVENTS.CONNECTING, connectingListener);
-        web3Auth.off(constants.ADAPTER_EVENTS.ERRORED, errorListener);
+        web3Auth.off(constants.CONNECTOR_EVENTS.NOT_READY, notReadyListener);
+        web3Auth.off(constants.CONNECTOR_EVENTS.READY, readyListener);
+        web3Auth.off(constants.CONNECTOR_EVENTS.CONNECTED, connectedListener);
+        web3Auth.off(constants.CONNECTOR_EVENTS.DISCONNECTED, disconnectedListener);
+        web3Auth.off(constants.CONNECTOR_EVENTS.CONNECTING, connectingListener);
+        web3Auth.off(constants.CONNECTOR_EVENTS.ERRORED, errorListener);
       }
     };
   }, [web3Auth]);
@@ -163,21 +161,10 @@ function Web3AuthInnerProvider(params) {
       setIsConnecting(false);
     }
   }, [web3Auth]);
-  const addAndSwitchChain = react.useCallback(async chainConfig => {
-    if (!web3Auth) throw index.WalletInitializationError.notReady();
-    await web3Auth.addChain(chainConfig);
-    await web3Auth.switchChain({
-      chainId: chainConfig.chainId
-    });
-  }, [web3Auth]);
   const authenticateUser = react.useCallback(async () => {
     if (!web3Auth) throw index.WalletInitializationError.notReady();
     return web3Auth.authenticateUser();
   }, [web3Auth]);
-  const addChain = react.useCallback(async chainConfig => {
-    if (!web3Auth) throw index.WalletInitializationError.notReady();
-    return web3Auth.addChain(chainConfig);
-  }, [web3Auth]);
   const switchChain = react.useCallback(chainParams => {
     if (!web3Auth) throw index.WalletInitializationError.notReady();
     return web3Auth.switchChain(chainParams);
@@ -196,9 +183,6 @@ function Web3AuthInnerProvider(params) {
       enableMFA,
       manageMFA,
       logout,
-      addAndSwitchChain,
-      addChain,
-      addPlugin,
       authenticateUser,
       switchChain,
       isInitializing,
@@ -206,7 +190,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 react.createElement(Web3AuthInnerContext.Provider, {
     value
   }, children);

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

@@ -2,6 +2,17 @@
 
 var react = require('react');
 var index = require('../../../base/errors/index.js');
+require('@toruslabs/base-controllers');
+require('@babel/runtime/helpers/defineProperty');
+require('@web3auth/auth');
+require('../../../base/wallet/index.js');
+require('../../../base/connector/constants.js');
+require('jwt-decode');
+require('../../../base/loglevel.js');
+require('../../../base/plugin/errors.js');
+require('../../../base/plugin/IPlugin.js');
+require('@toruslabs/constants');
+require('@toruslabs/http-helpers');
 var Web3AuthInnerContext = require('../Web3AuthInnerContext.js');
 
 const useWeb3Auth = () => {

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

@@ -1,8 +1,18 @@
 'use strict';
 
 var react = require('react');
-var IPlugin = require('../../base/plugin/IPlugin.js');
+require('../../base/errors/index.js');
+require('@toruslabs/base-controllers');
+require('@babel/runtime/helpers/defineProperty');
+require('@web3auth/auth');
+require('../../base/wallet/index.js');
+var constants = require('../../base/connector/constants.js');
+require('jwt-decode');
+require('../../base/loglevel.js');
 var errors = require('../../base/plugin/errors.js');
+var IPlugin = require('../../base/plugin/IPlugin.js');
+require('@toruslabs/constants');
+require('@toruslabs/http-helpers');
 
 const WalletServicesContext = react.createContext(null);
 function WalletServicesContextProvider({
@@ -27,6 +37,8 @@ function WalletServicesContextProvider({
     if (isConnected) {
       const plugin = getPlugin(IPlugin.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) === constants.CONNECTOR_STATUS.CONNECTED) setIsPluginConnected(true);
     }
   }, [isConnected, getPlugin, walletServicesPlugin]);
   react.useEffect(() => {

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

@@ -2,6 +2,17 @@
 
 var react = require('react');
 var index = require('../../../base/errors/index.js');
+require('@toruslabs/base-controllers');
+require('@babel/runtime/helpers/defineProperty');
+require('@web3auth/auth');
+require('../../../base/wallet/index.js');
+require('../../../base/connector/constants.js');
+require('jwt-decode');
+require('../../../base/loglevel.js');
+require('../../../base/plugin/errors.js');
+require('../../../base/plugin/IPlugin.js');
+require('@toruslabs/constants');
+require('@toruslabs/http-helpers');
 var WalletServicesContext = require('../WalletServicesContext.js');
 
 const useWalletServicesPlugin = () => {

package/dist/{types → lib.cjs/types}/base/chain/IChainInterface.d.ts

@@ -1,19 +1,13 @@
-export declare const CHAIN_NAMESPACES: {
-    readonly EIP155: "eip155";
-    readonly SOLANA: "solana";
-    readonly CASPER: "casper";
-    readonly XRPL: "xrpl";
-    readonly OTHER: "other";
-};
-export type ChainNamespaceType = (typeof CHAIN_NAMESPACES)[keyof typeof CHAIN_NAMESPACES];
-export declare const ADAPTER_NAMESPACES: {
+import { CHAIN_NAMESPACES, type ChainNamespaceType } from "@toruslabs/base-controllers";
+export { CHAIN_NAMESPACES, type ChainNamespaceType };
+export declare const CONNECTOR_NAMESPACES: {
     readonly EIP155: "eip155";
     readonly SOLANA: "solana";
     readonly CASPER: "casper";
     readonly XRPL: "xrpl";
     readonly MULTICHAIN: "multichain";
 };
-export type AdapterNamespaceType = (typeof ADAPTER_NAMESPACES)[keyof typeof ADAPTER_NAMESPACES];
+export type ConnectorNamespaceType = (typeof CONNECTOR_NAMESPACES)[keyof typeof CONNECTOR_NAMESPACES];
 export type CustomChainConfig = {
     chainNamespace: ChainNamespaceType;
     /**

package/dist/{types → lib.cjs/types}/base/chain/config.d.ts

@@ -1,5 +1,5 @@
 import { ChainNamespaceType, CustomChainConfig } from "./IChainInterface";
-export declare const getEvmChainConfig: (chainId: number) => CustomChainConfig | null;
+export declare const getEvmChainConfig: (chainId: number, web3AuthClientId?: string) => CustomChainConfig | null;
 export declare const getSolanaChainConfig: (chainId: number) => CustomChainConfig | null;
 export declare const getXrplChainConfig: (chainId: number) => CustomChainConfig | null;
-export declare const getChainConfig: (chainNamespace: ChainNamespaceType, chainId?: number | string) => CustomChainConfig | null;
+export declare const getChainConfig: (chainNamespace: ChainNamespaceType, chainId?: number | string, web3AuthClientId?: string) => CustomChainConfig | null;

package/dist/lib.cjs/types/base/connector/baseConnector.d.ts

@@ -0,0 +1,37 @@
+import { SafeEventEmitter } from "@web3auth/auth";
+import { ConnectorNamespaceType, CustomChainConfig } from "../chain/IChainInterface";
+import type { BaseConnectorSettings, CONNECTOR_CATEGORY_TYPE, CONNECTOR_STATUS_TYPE, ConnectorEvents, ConnectorInitOptions, IConnector, IProvider, UserAuthInfo, UserInfo } from "./interfaces";
+export declare abstract class BaseConnector<T> extends SafeEventEmitter<ConnectorEvents> implements IConnector<T> {
+    connectorData?: unknown;
+    isInjected?: boolean;
+    coreOptions: BaseConnectorSettings["coreOptions"];
+    protected rehydrated: boolean;
+    abstract connectorNamespace: ConnectorNamespaceType;
+    abstract type: CONNECTOR_CATEGORY_TYPE;
+    abstract name: string;
+    abstract status: CONNECTOR_STATUS_TYPE;
+    constructor(options: BaseConnectorSettings);
+    get connnected(): boolean;
+    abstract get provider(): IProvider | null;
+    checkConnectionRequirements(): void;
+    checkInitializationRequirements({ chainConfig }: {
+        chainConfig?: CustomChainConfig;
+    }): void;
+    checkDisconnectionRequirements(): void;
+    checkSwitchChainRequirements(params: {
+        chainId: string;
+    }, init?: boolean): void;
+    updateConnectorData(data: unknown): void;
+    abstract init(options?: ConnectorInitOptions): Promise<void>;
+    abstract connect(params: T & {
+        chainId: string;
+    }): Promise<IProvider | null>;
+    abstract disconnect(): Promise<void>;
+    abstract getUserInfo(): Promise<Partial<UserInfo>>;
+    abstract enableMFA(params?: T): Promise<void>;
+    abstract manageMFA(params?: T): Promise<void>;
+    abstract authenticateUser(): Promise<UserAuthInfo>;
+    abstract switchChain(params: {
+        chainId: string;
+    }): Promise<void>;
+}

package/dist/{types/base/adapter → lib.cjs/types/base/connector}/constants.d.ts

@@ -1,22 +1,25 @@
-export declare const ADAPTER_STATUS: {
+export declare const CONNECTOR_STATUS: {
     readonly NOT_READY: "not_ready";
     readonly READY: "ready";
     readonly CONNECTING: "connecting";
     readonly CONNECTED: "connected";
+    readonly DISCONNECTING: "disconnecting";
     readonly DISCONNECTED: "disconnected";
     readonly ERRORED: "errored";
 };
-export declare const ADAPTER_EVENTS: {
-    readonly ADAPTER_DATA_UPDATED: "adapter_data_updated";
+export declare const CONNECTOR_EVENTS: {
+    readonly CONNECTOR_DATA_UPDATED: "connector_data_updated";
     readonly CACHE_CLEAR: "cache_clear";
+    readonly CONNECTORS_UPDATED: "connectors_updated";
     readonly NOT_READY: "not_ready";
     readonly READY: "ready";
     readonly CONNECTING: "connecting";
     readonly CONNECTED: "connected";
+    readonly DISCONNECTING: "disconnecting";
     readonly DISCONNECTED: "disconnected";
     readonly ERRORED: "errored";
 };
-export declare const ADAPTER_CATEGORY: {
+export declare const CONNECTOR_CATEGORY: {
     readonly EXTERNAL: "external";
     readonly IN_APP: "in_app";
 };

package/dist/{types/base/adapter → lib.cjs/types/base/connector}/index.d.ts

@@ -1,4 +1,4 @@
-export * from "./baseAdapter";
+export * from "./baseConnector";
 export * from "./constants";
 export * from "./interfaces";
 export * from "./utils";