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

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

@@ -0,0 +1,415 @@
+import _objectSpread from '@babel/runtime/helpers/objectSpread2';
+import _defineProperty from '@babel/runtime/helpers/defineProperty';
+import { signChallenge, verifySignedChallenge } from '@toruslabs/base-controllers';
+import Client from '@walletconnect/sign-client';
+import { isValidArray, getSdkError } from '@walletconnect/utils';
+import { EVM_METHOD_TYPES, SOLANA_METHOD_TYPES } from '@web3auth/ws-embed';
+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 { WALLET_CONNECTORS } from '../../base/wallet/index.js';
+import { getWalletConnectV2Settings } from './config.js';
+import { WalletConnectV2Provider } from './WalletConnectV2Provider.js';
+import { BaseConnector } from '../../base/connector/baseConnector.js';
+import { CONNECTOR_CATEGORY, CONNECTOR_STATUS, CONNECTOR_EVENTS } from '../../base/connector/constants.js';
+import { getSavedToken, checkIfTokenIsExpired, saveToken } from '../../base/connector/utils.js';
+
+class WalletConnectV2Connector extends BaseConnector {
+  constructor(options) {
+    var _this$connectorOption, _this$connectorOption2, _this$connectorOption3, _this$connectorOption4, _this$connectorOption5;
+    super(options);
+    _defineProperty(this, "name", WALLET_CONNECTORS.WALLET_CONNECT_V2);
+    _defineProperty(this, "connectorNamespace", CONNECTOR_NAMESPACES.MULTICHAIN);
+    _defineProperty(this, "currentChainNamespace", CHAIN_NAMESPACES.OTHER);
+    _defineProperty(this, "type", CONNECTOR_CATEGORY.EXTERNAL);
+    _defineProperty(this, "connectorOptions", void 0);
+    _defineProperty(this, "status", CONNECTOR_STATUS.NOT_READY);
+    _defineProperty(this, "connectorData", {
+      uri: ""
+    });
+    _defineProperty(this, "connector", null);
+    _defineProperty(this, "activeSession", null);
+    _defineProperty(this, "wcProvider", null);
+    this.connectorOptions = _objectSpread({}, options);
+    const {
+      qrcodeModal,
+      walletConnectInitOptions
+    } = (options === null || options === void 0 ? void 0 : options.connectorSettings) || {};
+    this.connectorOptions = _objectSpread(_objectSpread({}, this.connectorOptions), {}, {
+      connectorSettings: (_this$connectorOption = (_this$connectorOption2 = this.connectorOptions) === null || _this$connectorOption2 === void 0 ? void 0 : _this$connectorOption2.connectorSettings) !== null && _this$connectorOption !== void 0 ? _this$connectorOption : {},
+      loginSettings: (_this$connectorOption3 = (_this$connectorOption4 = this.connectorOptions) === null || _this$connectorOption4 === void 0 ? void 0 : _this$connectorOption4.loginSettings) !== null && _this$connectorOption3 !== void 0 ? _this$connectorOption3 : {}
+    });
+    if (qrcodeModal) this.connectorOptions.connectorSettings.qrcodeModal = qrcodeModal;
+    if (walletConnectInitOptions) this.connectorOptions.connectorSettings.walletConnectInitOptions = _objectSpread(_objectSpread({}, (_this$connectorOption5 = this.connectorOptions.connectorSettings.walletConnectInitOptions) !== null && _this$connectorOption5 !== void 0 ? _this$connectorOption5 : {}), walletConnectInitOptions);
+    const {
+      loginSettings
+    } = options;
+    if (loginSettings) this.connectorOptions.loginSettings = _objectSpread(_objectSpread({}, this.connectorOptions.loginSettings || {}), loginSettings);
+  }
+  get connected() {
+    return !!this.activeSession;
+  }
+  get provider() {
+    if (this.status !== CONNECTOR_STATUS.NOT_READY && this.wcProvider) {
+      return this.wcProvider;
+    }
+    return null;
+  }
+  set provider(_) {
+    throw new Error("Not implemented");
+  }
+  async init(options) {
+    var _this$connectorOption6;
+    const chainConfig = this.coreOptions.chains.find(x => x.chainId === options.chainId);
+    super.checkInitializationRequirements({
+      chainConfig
+    });
+    const projectId = (_this$connectorOption6 = this.connectorOptions.connectorSettings) === null || _this$connectorOption6 === void 0 || (_this$connectorOption6 = _this$connectorOption6.walletConnectInitOptions) === null || _this$connectorOption6 === void 0 ? void 0 : _this$connectorOption6.projectId;
+    if (!projectId) {
+      throw WalletInitializationError.invalidParams("Wallet connect project id is required in wallet connect v2 connector");
+    }
+    const wc2Settings = await getWalletConnectV2Settings(this.coreOptions.chains, projectId);
+    if (!this.connectorOptions.loginSettings || Object.keys(this.connectorOptions.loginSettings).length === 0) {
+      this.connectorOptions.loginSettings = wc2Settings.loginSettings;
+    }
+    this.connectorOptions.connectorSettings = deepmerge(wc2Settings.connectorSettings || {}, this.connectorOptions.connectorSettings || {});
+    const {
+      connectorSettings
+    } = this.connectorOptions;
+    this.connector = await Client.init(connectorSettings === null || connectorSettings === void 0 ? void 0 : connectorSettings.walletConnectInitOptions);
+    this.wcProvider = new WalletConnectV2Provider({
+      config: {
+        chain: chainConfig,
+        chains: this.coreOptions.chains
+      },
+      connector: this.connector
+    });
+    this.emit(CONNECTOR_EVENTS.READY, WALLET_CONNECTORS.WALLET_CONNECT_V2);
+    this.status = CONNECTOR_STATUS.READY;
+    log.debug("initializing wallet connect v2 connector");
+    if (options.autoConnect) {
+      await this.checkForPersistedSession();
+      if (this.connected) {
+        this.rehydrated = true;
+        try {
+          await this.onConnectHandler({
+            chain: chainConfig
+          });
+        } catch (error) {
+          log.error("wallet auto connect", error);
+          this.emit(CONNECTOR_EVENTS.ERRORED, error);
+        }
+      } else {
+        this.status = CONNECTOR_STATUS.NOT_READY;
+        this.emit(CONNECTOR_EVENTS.CACHE_CLEAR);
+      }
+    }
+  }
+  async connect({
+    chainId
+  }) {
+    super.checkConnectionRequirements();
+    const chainConfig = this.coreOptions.chains.find(x => x.chainId === chainId);
+    if (!chainConfig) throw WalletLoginError.connectionError("Chain config is not available");
+    if (!this.connector) throw WalletInitializationError.notReady("Wallet connector is not ready yet");
+    try {
+      // if already connected
+      if (this.connected) {
+        await this.onConnectHandler({
+          chain: chainConfig
+        });
+        return this.provider;
+      }
+      if (this.status !== CONNECTOR_STATUS.CONNECTING) {
+        await this.createNewSession({
+          chainConfig
+        });
+      }
+      return this.provider;
+    } catch (error) {
+      log.error("Wallet connect v2 connector error while connecting", error);
+      // ready again to be connected
+      this.status = CONNECTOR_STATUS.READY;
+      this.rehydrated = true;
+      this.emit(CONNECTOR_EVENTS.ERRORED, error);
+      const finalError = error instanceof Web3AuthError ? error : WalletLoginError.connectionError(`Failed to login with wallet connect: ${(error === null || error === void 0 ? void 0 : error.message) || ""}`, error);
+      throw finalError;
+    }
+  }
+  async switchChain(params, init = false) {
+    super.checkSwitchChainRequirements(params, init);
+    if (!this.wcProvider) throw WalletInitializationError.notReady("Wallet Connect provider is not ready yet");
+    try {
+      await this.wcProvider.switchChain({
+        chainId: params.chainId
+      });
+    } catch (error) {
+      log.error("error while switching chain", error);
+      throw error;
+    }
+  }
+  async getUserInfo() {
+    if (!this.connected) throw WalletLoginError.notConnectedError("Not connected with wallet, Please login/connect first");
+    return {};
+  }
+  async disconnect(options = {
+    cleanup: false,
+    sessionRemovedByWallet: false
+  }) {
+    var _this$activeSession, _this$activeSession2;
+    const {
+      cleanup
+    } = options;
+    if (!this.connector || !this.connected || !((_this$activeSession = this.activeSession) !== null && _this$activeSession !== void 0 && _this$activeSession.topic)) throw WalletLoginError.notConnectedError("Not connected with wallet");
+    if (!options.sessionRemovedByWallet) await this.connector.disconnect({
+      topic: (_this$activeSession2 = this.activeSession) === null || _this$activeSession2 === void 0 ? void 0 : _this$activeSession2.topic,
+      reason: getSdkError("USER_DISCONNECTED")
+    });
+    this.rehydrated = false;
+    if (cleanup) {
+      this.connector = null;
+      this.status = CONNECTOR_STATUS.NOT_READY;
+      this.wcProvider = null;
+    } else {
+      // ready to connect again
+      this.status = CONNECTOR_STATUS.READY;
+    }
+    this.activeSession = null;
+    this.emit(CONNECTOR_EVENTS.DISCONNECTED);
+  }
+  async authenticateUser() {
+    if (!this.provider || this.status !== CONNECTOR_STATUS.CONNECTED) throw WalletLoginError.notConnectedError();
+    const {
+      chainId
+    } = this.provider;
+    const currentChainConfig = this.coreOptions.chains.find(x => x.chainId === chainId);
+    if (!currentChainConfig) throw WalletLoginError.connectionError("Chain config is not available");
+    const {
+      chainNamespace
+    } = currentChainConfig;
+    const accounts = await this.provider.request({
+      method: chainNamespace === CHAIN_NAMESPACES.EIP155 ? EVM_METHOD_TYPES.GET_ACCOUNTS : SOLANA_METHOD_TYPES.GET_ACCOUNTS
+    });
+    if (accounts && accounts.length > 0) {
+      const existingToken = getSavedToken(accounts[0], this.name);
+      if (existingToken) {
+        const isExpired = checkIfTokenIsExpired(existingToken);
+        if (!isExpired) {
+          return {
+            idToken: existingToken
+          };
+        }
+      }
+      const payload = {
+        domain: window.location.origin,
+        uri: window.location.href,
+        address: accounts[0],
+        chainId: parseInt(chainId, 16),
+        version: "1",
+        nonce: Math.random().toString(36).slice(2),
+        issuedAt: new Date().toISOString()
+      };
+      const challenge = await signChallenge(payload, chainNamespace);
+      const signedMessage = await this._getSignedMessage(challenge, accounts, chainNamespace);
+      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
+      };
+    }
+    throw WalletLoginError.notConnectedError("Not connected with wallet, Please login/connect first");
+  }
+  async enableMFA() {
+    throw new Error("Method Not implemented");
+  }
+  async manageMFA() {
+    throw new Error("Method Not implemented");
+  }
+  cleanupPendingPairings() {
+    if (!this.connector) throw WalletInitializationError.notReady("Wallet connector is not ready yet");
+    const inactivePairings = this.connector.pairing.getAll({
+      active: false
+    });
+    if (!isValidArray(inactivePairings)) return;
+    inactivePairings.forEach(pairing => {
+      if (this.connector) {
+        this.connector.pairing.delete(pairing.topic, getSdkError("USER_DISCONNECTED"));
+      }
+    });
+  }
+  async checkForPersistedSession() {
+    if (!this.connector) throw WalletInitializationError.notReady("Wallet connector is not ready yet");
+    if (this.connector.session.length) {
+      const lastKeyIndex = this.connector.session.keys.length - 1;
+      this.activeSession = this.connector.session.get(this.connector.session.keys[lastKeyIndex]);
+    }
+    return this.activeSession;
+  }
+  async createNewSession({
+    forceNewSession = false,
+    chainConfig
+  }) {
+    try {
+      var _this$activeSession3, _this$connectorOption7;
+      if (!this.connector) throw WalletInitializationError.notReady("Wallet connector is not ready yet");
+      if (!this.connectorOptions.loginSettings || Object.keys(this.connectorOptions.loginSettings).length === 0) throw WalletInitializationError.notReady("login settings are not set yet");
+      this.status = CONNECTOR_STATUS.CONNECTING;
+      this.emit(CONNECTOR_EVENTS.CONNECTING, {
+        connector: WALLET_CONNECTORS.WALLET_CONNECT_V2
+      });
+      if (forceNewSession && (_this$activeSession3 = this.activeSession) !== null && _this$activeSession3 !== void 0 && _this$activeSession3.topic) {
+        var _this$activeSession4;
+        await this.connector.disconnect({
+          topic: (_this$activeSession4 = this.activeSession) === null || _this$activeSession4 === void 0 ? void 0 : _this$activeSession4.topic,
+          reason: getSdkError("USER_DISCONNECTED")
+        });
+      }
+      const {
+        uri,
+        approval
+      } = await this.connector.connect(this.connectorOptions.loginSettings);
+      const qrcodeModal = (_this$connectorOption7 = this.connectorOptions) === null || _this$connectorOption7 === void 0 || (_this$connectorOption7 = _this$connectorOption7.connectorSettings) === null || _this$connectorOption7 === void 0 ? void 0 : _this$connectorOption7.qrcodeModal;
+      // Open QRCode modal if a URI was returned (i.e. we're not connecting with an existing pairing).
+      if (uri) {
+        if (qrcodeModal) {
+          try {
+            await qrcodeModal.openModal({
+              uri
+            });
+            log.debug("EVENT", "QR Code Modal closed");
+            this.status = CONNECTOR_STATUS.READY;
+            this.emit(CONNECTOR_EVENTS.READY, WALLET_CONNECTORS.WALLET_CONNECT_V2);
+          } catch (error) {
+            log.error("unable to open qr code modal");
+          }
+        } else {
+          this.updateConnectorData({
+            uri
+          });
+        }
+      }
+      log.info("awaiting session approval from wallet");
+
+      // Await session approval from the wallet.
+      const session = await approval();
+      this.activeSession = session;
+      // Handle the returned session (e.g. update UI to "connected" state).
+      await this.onConnectHandler({
+        chain: chainConfig
+      });
+      if (qrcodeModal) {
+        qrcodeModal.closeModal();
+      }
+    } catch (error) {
+      var _message;
+      if ((_message = error.message) !== null && _message !== void 0 && _message.toLowerCase().includes("proposal expired")) {
+        // Retry if connector status is still connecting
+        log.info("current connector status: ", this.status);
+        if (this.status === CONNECTOR_STATUS.CONNECTING) {
+          log.info("retrying to create new wallet connect session since proposal expired");
+          return this.createNewSession({
+            forceNewSession: true,
+            chainConfig
+          });
+        }
+        if (this.status === CONNECTOR_STATUS.READY) {
+          log.info("ignoring proposal expired error since some other connector is connected");
+          return;
+        }
+      }
+      log.error("error while creating new wallet connect session", error);
+      this.emit(CONNECTOR_EVENTS.ERRORED, error);
+      throw error;
+    }
+  }
+  async onConnectHandler({
+    chain
+  }) {
+    var _this$connectorOption8;
+    if (!this.connector || !this.wcProvider) throw WalletInitializationError.notReady("Wallet connect connector is not ready yet");
+    this.subscribeEvents();
+    if ((_this$connectorOption8 = this.connectorOptions.connectorSettings) !== null && _this$connectorOption8 !== void 0 && _this$connectorOption8.qrcodeModal) {
+      this.wcProvider = new WalletConnectV2Provider({
+        config: {
+          chain,
+          chains: this.coreOptions.chains,
+          skipLookupNetwork: true
+        },
+        connector: this.connector
+      });
+    }
+    await this.wcProvider.setupProvider(this.connector);
+    this.cleanupPendingPairings();
+    this.status = CONNECTOR_STATUS.CONNECTED;
+    this.emit(CONNECTOR_EVENTS.CONNECTED, {
+      connector: WALLET_CONNECTORS.WALLET_CONNECT_V2,
+      reconnected: this.rehydrated,
+      provider: this.provider
+    });
+  }
+  subscribeEvents() {
+    if (!this.connector) throw WalletInitializationError.notReady("Wallet connector is not ready yet");
+    this.connector.events.on("session_update", ({
+      topic,
+      params
+    }) => {
+      if (!this.connector) return;
+      const {
+        namespaces
+      } = params;
+      const _session = this.connector.session.get(topic);
+      // Overwrite the `namespaces` of the existing session with the incoming one.
+      const updatedSession = _objectSpread(_objectSpread({}, _session), {}, {
+        namespaces
+      });
+      // Integrate the updated session state into your dapp state.
+      this.activeSession = updatedSession;
+    });
+    this.connector.events.on("session_delete", () => {
+      // Session was deleted -> reset the dapp state, clean up from user session, etc.
+      this.disconnect({
+        sessionRemovedByWallet: true
+      });
+    });
+  }
+  async _getSignedMessage(challenge, accounts, chainNamespace) {
+    const signedMessage = await this.provider.request({
+      method: chainNamespace === CHAIN_NAMESPACES.EIP155 ? EVM_METHOD_TYPES.PERSONAL_SIGN : SOLANA_METHOD_TYPES.SIGN_MESSAGE,
+      params: chainNamespace === CHAIN_NAMESPACES.EIP155 ? [challenge, accounts[0]] : {
+        data: challenge
+      }
+    });
+    return signedMessage;
+  }
+}
+const walletConnectV2Connector = params => {
+  return ({
+    projectConfig,
+    coreOptions
+  }) => {
+    let {
+      projectId
+    } = (params === null || params === void 0 ? void 0 : params.walletConnectInitOptions) || {};
+
+    // use project config if projectId is not set
+    if (projectConfig) {
+      const {
+        wallet_connect_enabled: walletConnectEnabled,
+        wallet_connect_project_id: walletConnectProjectId
+      } = projectConfig;
+      if (walletConnectEnabled && walletConnectProjectId && !projectId) projectId = walletConnectProjectId;
+    }
+    const connectorSettings = _objectSpread(_objectSpread({}, params), {}, {
+      walletConnectInitOptions: _objectSpread(_objectSpread({}, params === null || params === void 0 ? void 0 : params.walletConnectInitOptions), {}, {
+        projectId
+      })
+    });
+    return new WalletConnectV2Connector({
+      connectorSettings,
+      coreOptions
+    });
+  };
+};
+
+export { walletConnectV2Connector };

package/dist/lib.esm/{adapters/wallet-connect-v2-adapter → connectors/wallet-connect-v2-connector}/walletConnectV2Utils.js

@@ -1,6 +1,7 @@
 import _objectSpread from '@babel/runtime/helpers/objectSpread2';
 import { getAccountsFromNamespaces, parseAccountId } from '@walletconnect/utils';
 import { providerErrors, rpcErrors } from '@web3auth/auth';
+import { EVM_METHOD_TYPES, SOLANA_METHOD_TYPES } from '@web3auth/ws-embed';
 import bs58 from 'bs58';
 import { WalletLoginError } from '../../base/errors/index.js';
 import { SOLANA_CAIP_CHAIN_MAP } from './config.js';
@@ -67,7 +68,7 @@ function getEthProviderHandlers({
       return getAccounts(connector);
     },
     processTransaction: async (txParams, _) => {
-      const methodRes = await sendJrpcRequest(connector, `eip155:${chainId}`, "eth_sendTransaction", [txParams]);
+      const methodRes = await sendJrpcRequest(connector, `eip155:${chainId}`, EVM_METHOD_TYPES.ETH_TRANSACTION, [txParams]);
       return methodRes;
     },
     processSignTransaction: async (txParams, _) => {
@@ -75,15 +76,15 @@ function getEthProviderHandlers({
       return methodRes;
     },
     processEthSignMessage: async (msgParams, _) => {
-      const methodRes = await sendJrpcRequest(connector, `eip155:${chainId}`, "eth_sign", [msgParams.from, msgParams.data]);
+      const methodRes = await sendJrpcRequest(connector, `eip155:${chainId}`, EVM_METHOD_TYPES.ETH_SIGN, [msgParams.from, msgParams.data]);
       return methodRes;
     },
     processPersonalMessage: async (msgParams, _) => {
-      const methodRes = await sendJrpcRequest(connector, `eip155:${chainId}`, "personal_sign", [msgParams.data, msgParams.from]);
+      const methodRes = await sendJrpcRequest(connector, `eip155:${chainId}`, EVM_METHOD_TYPES.PERSONAL_SIGN, [msgParams.data, msgParams.from]);
       return methodRes;
     },
     processTypedMessageV4: async msgParams => {
-      const methodRes = await sendJrpcRequest(connector, `eip155:${chainId}`, "eth_signTypedData_v4", [msgParams.from, msgParams.data]);
+      const methodRes = await sendJrpcRequest(connector, `eip155:${chainId}`, EVM_METHOD_TYPES.ETH_SIGN_TYPED_DATA_V4, [msgParams.from, msgParams.data]);
       return methodRes;
     }
   };
@@ -115,26 +116,20 @@ function getSolProviderHandlers({
       throw rpcErrors.methodNotSupported();
     },
     signMessage: async req => {
-      const methodRes = await sendJrpcRequest(connector, `solana:${SOLANA_CAIP_CHAIN_MAP[chainId]}`, "solana_signMessage", {
-        message: bs58.encode(req.params.message)
+      const methodRes = await sendJrpcRequest(connector, `solana:${SOLANA_CAIP_CHAIN_MAP[chainId]}`, SOLANA_METHOD_TYPES.SIGN_MESSAGE, {
+        message: bs58.encode(Buffer.from(req.params.data, "utf-8"))
       });
-      return bs58.decode(methodRes.signature);
+      return methodRes.signature;
     },
     signTransaction: async req => {
-      const [{
-        PublicKey
-      }, accounts] = await Promise.all([import('@solana/web3.js'), getAccounts(connector)]);
+      const accounts = await getAccounts(connector);
       if (accounts.length === 0) {
         throw providerErrors.disconnected();
       }
-      const methodRes = await sendJrpcRequest(connector, `solana:${SOLANA_CAIP_CHAIN_MAP[chainId]}`, "solana_signTransaction", {
-        transaction: req.params.message.serialize({
-          requireAllSignatures: false
-        }).toString("base64")
+      const methodRes = await sendJrpcRequest(connector, `solana:${SOLANA_CAIP_CHAIN_MAP[chainId]}`, SOLANA_METHOD_TYPES.SIGN_TRANSACTION, {
+        transaction: req.params.message
       });
-      const finalTransaction = req.params.message;
-      finalTransaction.addSignature(new PublicKey(accounts[0]), Buffer.from(bs58.decode(methodRes.signature)));
-      return finalTransaction;
+      return methodRes.signature;
     }
   };
 }
@@ -147,12 +142,5 @@ async function switchChain({
     chainId: newChainId
   }]);
 }
-async function addChain({
-  connector,
-  chainId,
-  chainConfig
-}) {
-  await sendJrpcRequest(connector, `eip155:${chainId}`, "wallet_addEthereumChain", [chainConfig]);
-}
 
-export { addChain, getAccounts, getEthProviderHandlers, getSolProviderHandlers, sendJrpcRequest, switchChain };
+export { getAccounts, getEthProviderHandlers, getSolProviderHandlers, sendJrpcRequest, switchChain };

package/dist/lib.esm/index.js

@@ -1,55 +1,50 @@
 export { getChainConfig, getEvmChainConfig, getSolanaChainConfig, getXrplChainConfig } from './base/chain/config.js';
-export { ADAPTER_NAMESPACES, CHAIN_NAMESPACES } from './base/chain/IChainInterface.js';
+export { CHAIN_NAMESPACES, CONNECTOR_NAMESPACES } from './base/chain/IChainInterface.js';
 export { Web3AuthContextKey } from './base/composables/index.js';
 export { WalletInitializationError, WalletLoginError, WalletOperationsError, WalletProviderError, Web3AuthError, serializeError } from './base/errors/index.js';
 export { log } from './base/loglevel.js';
 export { PROVIDER_EVENTS } from './base/provider/IProvider.js';
 export { fetchProjectConfig, fetchWalletRegistry, isHexStrict, normalizeWalletName, signerHost } from './base/utils.js';
-export { ADAPTER_NAMES, EVM_ADAPTERS, MULTI_CHAIN_ADAPTERS, SOLANA_ADAPTERS, WALLET_ADAPTERS } from './base/wallet/index.js';
+export { CONNECTOR_NAMES, EVM_CONNECTORS, MULTI_CHAIN_CONNECTORS, SOLANA_CONNECTORS, WALLET_CONNECTORS } from './base/wallet/index.js';
 export { Web3AuthNoModal } from './noModal.js';
-export { AuthAdapter } from './adapters/auth-adapter/authAdapter.js';
-export { getAuthDefaultOptions } from './adapters/auth-adapter/config.js';
+export { BaseConnector } from './base/connector/baseConnector.js';
+export { CONNECTOR_CATEGORY, CONNECTOR_EVENTS, CONNECTOR_STATUS } from './base/connector/constants.js';
 export { LOGIN_PROVIDER, UX_MODE, WEB3AUTH_NETWORK, getED25519Key } from '@web3auth/auth';
-export { BaseEvmAdapter } from './adapters/base-evm-adapter/baseEvmAdapter.js';
-export { BaseSolanaAdapter } from './adapters/base-solana-adapter/baseSolanaAdapter.js';
-export { CoinbaseAdapter } from './adapters/coinbase-adapter/coinbaseAdapter.js';
-export { getEvmDefaultExternalAdapters } from './adapters/default-evm-adapter/index.js';
-export { getEvmInjectedAdapters } from './adapters/default-evm-adapter/injectedAdapters.js';
-export { getSolanaDefaultExternalAdapters } from './adapters/default-solana-adapter/index.js';
-export { getSolanaInjectedAdapters } from './adapters/default-solana-adapter/injectedAdapters.js';
-export { DEFAULT_EIP155_METHODS, DEFAULT_EIP_155_EVENTS, DEFAULT_SOLANA_EVENTS, DEFAULT_SOLANA_METHODS, SOLANA_CAIP_CHAIN_MAP, getNamespacesFromChains, getRequiredNamespaces, getSupportedEventsByNamespace, getSupportedMethodsByNamespace, getWalletConnectV2Settings } from './adapters/wallet-connect-v2-adapter/config.js';
-export { WalletConnectV2Adapter } from './adapters/wallet-connect-v2-adapter/walletConnectV2adapter.js';
-export { WalletConnectV2Provider } from './adapters/wallet-connect-v2-adapter/WalletConnectV2Provider.js';
-export { BaseAdapter } from './base/adapter/baseAdapter.js';
-export { ADAPTER_CATEGORY, ADAPTER_EVENTS, ADAPTER_STATUS } from './base/adapter/constants.js';
-export { checkIfTokenIsExpired, clearToken, getSavedToken, saveToken, storageAvailable } from './base/adapter/utils.js';
+export { checkIfTokenIsExpired, clearToken, getSavedToken, saveToken, storageAvailable } from './base/connector/utils.js';
 export { NFTCheckoutPluginError, WalletServicesPluginError } from './base/plugin/errors.js';
 export { EVM_PLUGINS, PLUGIN_EVENTS, PLUGIN_NAMESPACES, PLUGIN_STATUS, SOLANA_PLUGINS, WALLET_PLUGINS } from './base/plugin/IPlugin.js';
 export { cloneDeep } from '@toruslabs/base-controllers';
+export { authConnector } from './connectors/auth-connector/authConnector.js';
+export { BaseEvmConnector } from './connectors/base-evm-connector/baseEvmConnector.js';
+export { BaseSolanaConnector } from './connectors/base-solana-connector/baseSolanaConnector.js';
+export { coinbaseConnector } from './connectors/coinbase-connector/coinbaseConnector.js';
+export { injectedEvmConnector } from './connectors/injected-evm-connector/injectedEvmConnector.js';
+export { createStore as createMipd } from 'mipd';
+export { getWallets as createSolanaMipd } from '@wallet-standard/app';
+export { hasSolanaWalletStandardFeatures } from './connectors/injected-solana-connector/index.js';
+export { walletStandardConnector } from './connectors/injected-solana-connector/walletStandardConnector.js';
+export { DEFAULT_EIP155_METHODS, DEFAULT_EIP_155_EVENTS, DEFAULT_SOLANA_EVENTS, DEFAULT_SOLANA_METHODS, SOLANA_CAIP_CHAIN_MAP, getNamespacesFromChains, getRequiredNamespaces, getSupportedEventsByNamespace, getSupportedMethodsByNamespace, getWalletConnectV2Settings } from './connectors/wallet-connect-v2-connector/config.js';
+export { walletConnectV2Connector } from './connectors/wallet-connect-v2-connector/walletConnectV2Connector.js';
+export { WalletConnectV2Provider } from './connectors/wallet-connect-v2-connector/WalletConnectV2Provider.js';
 export { NFTCheckoutEmbed } from './plugins/nft-checkout-plugin/embed.js';
-export { NFTCheckoutPlugin } from './plugins/nft-checkout-plugin/plugin.js';
+export { nftCheckoutPlugin } from './plugins/nft-checkout-plugin/plugin.js';
 export { BUTTON_POSITION, CONFIRMATION_STRATEGY } from '@web3auth/ws-embed';
-export { WalletServicesPlugin } from './plugins/wallet-services-plugin/plugin.js';
-export { AccountAbstractionProvider } from './providers/account-abstraction-provider/providers/AccountAbstractionProvider.js';
-export { BiconomySmartAccount } from './providers/account-abstraction-provider/providers/smartAccounts/BiconomySmartAccount.js';
-export { KernelSmartAccount } from './providers/account-abstraction-provider/providers/smartAccounts/KernelSmartAccount.js';
-export { NexusSmartAccount } from './providers/account-abstraction-provider/providers/smartAccounts/NexusSmartAccount.js';
-export { SafeSmartAccount } from './providers/account-abstraction-provider/providers/smartAccounts/SafeSmartAccount.js';
-export { TrustSmartAccount } from './providers/account-abstraction-provider/providers/smartAccounts/TrustSmartAccount.js';
+export { walletServicesPlugin } from './plugins/wallet-services-plugin/plugin.js';
+export { accountAbstractionProvider } from './providers/account-abstraction-provider/providers/AccountAbstractionProvider.js';
+export { BiconomySmartAccount, KernelSmartAccount, NexusSmartAccount, SMART_ACCOUNT, SafeSmartAccount, TrustSmartAccount } from '@toruslabs/ethereum-controllers';
 export { BaseProvider } from './providers/base-provider/baseProvider.js';
 export { CommonJRPCProvider } from './providers/base-provider/CommonJRPCProvider.js';
 export { CommonPrivateKeyProvider } from './providers/base-provider/commonPrivateKeyProvider.js';
 export { createRandomId } from './providers/base-provider/utils.js';
 export { EthereumSigningProvider } from './providers/ethereum-mpc-provider/providers/signingProviders/EthereumSigningProvider.js';
-export { EthereumPrivateKeyProvider } from './providers/ethereum-provider/providers/privateKeyProviders/EthereumPrivateKeyProvider.js';
 export { EIP1559APIEndpoint, GAS_ESTIMATE_TYPES, LegacyGasAPIEndpoint, TRANSACTION_ENVELOPE_TYPES, TRANSACTION_TYPES } from './providers/ethereum-provider/providers/privateKeyProviders/TransactionFormatter/constants.js';
 export { TransactionFormatter } from './providers/ethereum-provider/providers/privateKeyProviders/TransactionFormatter/formatter.js';
 export { SignTypedDataVersion } from './providers/ethereum-provider/providers/privateKeyProviders/TransactionFormatter/interfaces.js';
 export { fetchEip1159GasEstimates, fetchLegacyGasPriceEstimates, normalizeGWEIDecimalNumbers, validateAddress, validateTypedSignMessageDataV4 } from './providers/ethereum-provider/providers/privateKeyProviders/TransactionFormatter/utils.js';
-export { createEthAccountMiddleware, createEthChainSwitchMiddleware, createEthMiddleware } from './providers/ethereum-provider/rpc/ethRpcMiddlewares.js';
+export { createEthChainSwitchMiddleware, createEthMiddleware } from './providers/ethereum-provider/rpc/ethRpcMiddlewares.js';
 export { createEthChainIdMiddleware, createEthJsonRpcClient, createEthProviderConfigMiddleware } from './providers/ethereum-provider/rpc/jrpcClient.js';
 export { createWalletMiddleware } from './providers/ethereum-provider/rpc/walletMidddleware.js';
-export { TorusInjectedProvider } from './providers/solana-provider/providers/injectedProviders/torus/torusInjectedProvider.js';
+export { getSolanaChainByChainConfig } from './providers/solana-provider/providers/injectedProviders/utils.js';
 export { WalletStandardProvider } from './providers/solana-provider/providers/injectedProviders/walletStandardProvider.js';
 export { SolanaPrivateKeyProvider } from './providers/solana-provider/providers/privateKeyProvider/solanaPrivateKeyProvider.js';
 export { createConfigMiddleware, createSolanaChainIdMiddleware, createSolanaJsonRpcClient, createSolanaProviderConfigMiddleware } from './providers/solana-provider/rpc/JrpcClient.js';