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

package/dist/lib.cjs/adapters/coinbase-adapter/coinbaseAdapter.js

@@ -0,0 +1,156 @@
+'use strict';
+
+var _objectSpread = require('@babel/runtime/helpers/objectSpread2');
+var _defineProperty = require('@babel/runtime/helpers/defineProperty');
+var walletSdk = require('@coinbase/wallet-sdk');
+var IChainInterface = require('../../base/chain/IChainInterface.js');
+var index$1 = require('../../base/errors/index.js');
+var index = require('../../base/wallet/index.js');
+var baseEvmAdapter = require('../base-evm-adapter/baseEvmAdapter.js');
+var constants = require('../../base/adapter/constants.js');
+
+class CoinbaseAdapter extends baseEvmAdapter.BaseEvmAdapter {
+  constructor(adapterOptions = {}) {
+    super(adapterOptions);
+    _defineProperty(this, "adapterNamespace", IChainInterface.ADAPTER_NAMESPACES.EIP155);
+    _defineProperty(this, "currentChainNamespace", IChainInterface.CHAIN_NAMESPACES.EIP155);
+    _defineProperty(this, "type", constants.ADAPTER_CATEGORY.EXTERNAL);
+    _defineProperty(this, "name", index.WALLET_ADAPTERS.COINBASE);
+    _defineProperty(this, "status", constants.ADAPTER_STATUS.NOT_READY);
+    _defineProperty(this, "coinbaseProvider", null);
+    _defineProperty(this, "coinbaseOptions", {
+      appName: "Web3Auth"
+    });
+    this.setAdapterSettings(adapterOptions);
+  }
+  get provider() {
+    if (this.status !== constants.ADAPTER_STATUS.NOT_READY && this.coinbaseProvider) {
+      return this.coinbaseProvider;
+    }
+    return null;
+  }
+  set provider(_) {
+    throw new Error("Not implemented");
+  }
+  setAdapterSettings(options) {
+    super.setAdapterSettings(options);
+    this.coinbaseOptions = _objectSpread(_objectSpread({}, this.coinbaseOptions), options.adapterSettings);
+  }
+  async init(options = {}) {
+    await super.init(options);
+    super.checkInitializationRequirements();
+    const coinbaseInstance = new walletSdk.CoinbaseWalletSDK(_objectSpread(_objectSpread({}, this.coinbaseOptions), {}, {
+      appChainIds: [Number.parseInt(this.chainConfig.chainId, 16)]
+    }));
+    this.coinbaseProvider = coinbaseInstance.makeWeb3Provider({
+      options: this.coinbaseOptions.options || "smartWalletOnly"
+    });
+    this.status = constants.ADAPTER_STATUS.READY;
+    this.emit(constants.ADAPTER_EVENTS.READY, index.WALLET_ADAPTERS.COINBASE);
+    try {
+      if (options.autoConnect) {
+        this.rehydrated = true;
+        await this.connect();
+      }
+    } catch (error) {
+      this.emit(constants.ADAPTER_EVENTS.ERRORED, error);
+    }
+  }
+  async connect() {
+    super.checkConnectionRequirements();
+    if (!this.coinbaseProvider) throw index$1.WalletLoginError.notConnectedError("Adapter is not initialized");
+    this.status = constants.ADAPTER_STATUS.CONNECTING;
+    this.emit(constants.ADAPTER_EVENTS.CONNECTING, {
+      adapter: index.WALLET_ADAPTERS.COINBASE
+    });
+    try {
+      await this.coinbaseProvider.request({
+        method: "eth_requestAccounts"
+      });
+      const chainId = await this.coinbaseProvider.request({
+        method: "eth_chainId"
+      });
+      if (chainId !== this.chainConfig.chainId) {
+        await this.addChain(this.chainConfig);
+        await this.switchChain(this.chainConfig, true);
+      }
+      this.status = constants.ADAPTER_STATUS.CONNECTED;
+      if (!this.provider) throw index$1.WalletLoginError.notConnectedError("Failed to connect with provider");
+      this.provider.once("disconnect", () => {
+        // ready to be connected again
+        this.disconnect();
+      });
+      this.emit(constants.ADAPTER_EVENTS.CONNECTED, {
+        adapter: index.WALLET_ADAPTERS.COINBASE,
+        reconnected: this.rehydrated,
+        provider: this.provider
+      });
+      return this.provider;
+    } catch (error) {
+      // ready again to be connected
+      this.status = constants.ADAPTER_STATUS.READY;
+      this.rehydrated = false;
+      this.emit(constants.ADAPTER_EVENTS.ERRORED, error);
+      if (error instanceof index$1.Web3AuthError) throw error;
+      throw index$1.WalletLoginError.connectionError("Failed to login with coinbase wallet", error);
+    }
+  }
+  async disconnect(options = {
+    cleanup: false
+  }) {
+    var _this$provider;
+    await super.disconnectSession();
+    (_this$provider = this.provider) === null || _this$provider === void 0 || _this$provider.removeAllListeners();
+    if (options.cleanup) {
+      this.status = constants.ADAPTER_STATUS.NOT_READY;
+      this.coinbaseProvider = null;
+    } else {
+      // ready to be connected again
+      this.status = constants.ADAPTER_STATUS.READY;
+    }
+    await super.disconnect();
+  }
+  async getUserInfo() {
+    if (this.status !== constants.ADAPTER_STATUS.CONNECTED) throw index$1.WalletLoginError.notConnectedError("Not connected with wallet, Please login/connect first");
+    return {};
+  }
+  async addChain(chainConfig, init = false) {
+    super.checkAddChainRequirements(chainConfig, init);
+    await this.coinbaseProvider.request({
+      method: "wallet_addEthereumChain",
+      params: [{
+        chainId: chainConfig.chainId,
+        chainName: chainConfig.displayName,
+        rpcUrls: [chainConfig.rpcTarget],
+        blockExplorerUrls: [chainConfig.blockExplorerUrl],
+        nativeCurrency: {
+          name: chainConfig.tickerName,
+          symbol: chainConfig.ticker,
+          decimals: chainConfig.decimals || 18
+        },
+        iconUrls: [chainConfig.logo]
+      }]
+    });
+    super.addChainConfig(chainConfig);
+  }
+  async switchChain(params, init = false) {
+    super.checkSwitchChainRequirements(params, init);
+    await this.coinbaseProvider.request({
+      method: "wallet_switchEthereumChain",
+      params: [{
+        chainId: params.chainId
+      }]
+    });
+    this.setAdapterSettings({
+      chainConfig: this.getChainConfig(params.chainId)
+    });
+  }
+  async enableMFA() {
+    throw new Error("Method Not implemented");
+  }
+  async manageMFA() {
+    throw new Error("Method Not implemented");
+  }
+}
+
+exports.CoinbaseAdapter = CoinbaseAdapter;

package/dist/lib.cjs/adapters/default-evm-adapter/index.js

@@ -0,0 +1,40 @@
+'use strict';
+
+var _objectSpread = require('@babel/runtime/helpers/objectSpread2');
+var config = require('../../base/chain/config.js');
+var IChainInterface = require('../../base/chain/IChainInterface.js');
+var index = require('../../base/errors/index.js');
+var injectedAdapters = require('./injectedAdapters.js');
+var walletConnectV2adapter = require('../wallet-connect-v2-adapter/walletConnectV2adapter.js');
+
+const getEvmDefaultExternalAdapters = params => {
+  const {
+    options
+  } = params;
+  const {
+    clientId,
+    chainConfig,
+    sessionTime,
+    web3AuthNetwork,
+    useCoreKitKey
+  } = options;
+  if (!Object.values(IChainInterface.CHAIN_NAMESPACES).includes(chainConfig.chainNamespace)) throw index.WalletInitializationError.invalidParams(`Invalid chainNamespace: ${chainConfig.chainNamespace}`);
+  const finalChainConfig = _objectSpread(_objectSpread({}, config.getChainConfig(chainConfig.chainNamespace, chainConfig === null || chainConfig === void 0 ? void 0 : chainConfig.chainId)), chainConfig || {});
+  const wcv2Adapter = new walletConnectV2adapter.WalletConnectV2Adapter({
+    chainConfig: finalChainConfig,
+    clientId,
+    sessionTime,
+    web3AuthNetwork,
+    useCoreKitKey,
+    adapterSettings: {
+      walletConnectInitOptions: {}
+    }
+  });
+  const injectedProviders = injectedAdapters.getEvmInjectedAdapters({
+    options
+  });
+  return [...injectedProviders, wcv2Adapter];
+};
+
+exports.getEvmInjectedAdapters = injectedAdapters.getEvmInjectedAdapters;
+exports.getEvmDefaultExternalAdapters = getEvmDefaultExternalAdapters;

package/dist/lib.cjs/adapters/default-evm-adapter/injectedAdapters.js

@@ -0,0 +1,42 @@
+'use strict';
+
+var _objectSpread = require('@babel/runtime/helpers/objectSpread2');
+var mipd = require('mipd');
+var config = require('../../base/chain/config.js');
+var IChainInterface = require('../../base/chain/IChainInterface.js');
+var index = require('../../base/errors/index.js');
+var utils = require('../../base/utils.js');
+var injectedEvmAdapter = require('./injectedEvmAdapter.js');
+
+const getEvmInjectedAdapters = params => {
+  const {
+    options
+  } = params;
+  const {
+    clientId,
+    chainConfig,
+    sessionTime,
+    web3AuthNetwork,
+    useCoreKitKey
+  } = options;
+  if (!Object.values(IChainInterface.CHAIN_NAMESPACES).includes(chainConfig.chainNamespace)) throw index.WalletInitializationError.invalidParams(`Invalid chainNamespace: ${chainConfig.chainNamespace}`);
+  const finalChainConfig = _objectSpread(_objectSpread({}, config.getChainConfig(chainConfig.chainNamespace, chainConfig === null || chainConfig === void 0 ? void 0 : chainConfig.chainId)), chainConfig || {});
+  // EIP-6963: multiple injected provider discovery
+  const mipd$1 = mipd.createStore();
+  // We assume that all extensions have emitted by here.
+  // TODO: Ideally, we must use reactive listening. We will do that with v9
+  const injectedProviders = mipd$1.getProviders().map(providerDetail => {
+    return new injectedEvmAdapter.InjectedEvmAdapter({
+      name: utils.normalizeWalletName(providerDetail.info.name),
+      provider: providerDetail.provider,
+      chainConfig: finalChainConfig,
+      clientId,
+      sessionTime,
+      web3AuthNetwork,
+      useCoreKitKey
+    });
+  });
+  return injectedProviders;
+};
+
+exports.getEvmInjectedAdapters = getEvmInjectedAdapters;

package/dist/lib.cjs/adapters/default-evm-adapter/injectedEvmAdapter.js

@@ -0,0 +1,160 @@
+'use strict';
+
+var _defineProperty = require('@babel/runtime/helpers/defineProperty');
+var IChainInterface = require('../../base/chain/IChainInterface.js');
+var index = require('../../base/errors/index.js');
+var loglevel = require('../../base/loglevel.js');
+var baseEvmAdapter = require('../base-evm-adapter/baseEvmAdapter.js');
+var constants = require('../../base/adapter/constants.js');
+
+class InjectedEvmAdapter extends baseEvmAdapter.BaseEvmAdapter {
+  constructor(options) {
+    super(options);
+    _defineProperty(this, "adapterNamespace", IChainInterface.ADAPTER_NAMESPACES.EIP155);
+    _defineProperty(this, "currentChainNamespace", IChainInterface.CHAIN_NAMESPACES.EIP155);
+    _defineProperty(this, "type", constants.ADAPTER_CATEGORY.EXTERNAL);
+    _defineProperty(this, "name", void 0);
+    _defineProperty(this, "isInjected", true);
+    _defineProperty(this, "status", constants.ADAPTER_STATUS.NOT_READY);
+    _defineProperty(this, "injectedProvider", null);
+    this.name = options.name;
+    this.injectedProvider = options.provider;
+  }
+  get provider() {
+    if (this.status !== constants.ADAPTER_STATUS.NOT_READY && this.injectedProvider) {
+      return this.injectedProvider;
+    }
+    return null;
+  }
+  set provider(_) {
+    throw new Error("Not implemented");
+  }
+  async init(options = {}) {
+    await super.init(options);
+    super.checkInitializationRequirements();
+    this.status = constants.ADAPTER_STATUS.READY;
+    this.emit(constants.ADAPTER_EVENTS.READY, this.name);
+    try {
+      loglevel.log.debug(`initializing ${this.name} injected adapter`);
+      if (options.autoConnect) {
+        this.rehydrated = true;
+        await this.connect();
+      }
+    } catch (error) {
+      this.emit(constants.ADAPTER_EVENTS.ERRORED, error);
+    }
+  }
+  async connect() {
+    super.checkConnectionRequirements();
+    if (!this.injectedProvider) throw index.WalletLoginError.connectionError("Injected provider is not available");
+    if (!this.chainConfig) throw index.WalletLoginError.connectionError("Chain config is not available");
+    this.status = constants.ADAPTER_STATUS.CONNECTING;
+    this.emit(constants.ADAPTER_EVENTS.CONNECTING, {
+      adapter: this.name
+    });
+    try {
+      await this.injectedProvider.request({
+        method: "eth_requestAccounts"
+      });
+      // switch chain if not connected to the right chain
+      if (this.injectedProvider.chainId !== this.chainConfig.chainId) {
+        try {
+          await this.switchChain(this.chainConfig, true);
+        } catch (error) {
+          await this.addChain(this.chainConfig, true);
+          await this.switchChain(this.chainConfig, true);
+        }
+      }
+      this.status = constants.ADAPTER_STATUS.CONNECTED;
+      const accountDisconnectHandler = accounts => {
+        if (accounts.length === 0) {
+          var _this$injectedProvide;
+          this.disconnect();
+          if ((_this$injectedProvide = this.injectedProvider) !== null && _this$injectedProvide !== void 0 && _this$injectedProvide.removeListener) this.injectedProvider.removeListener("accountsChanged", accountDisconnectHandler);
+        }
+      };
+      this.injectedProvider.on("accountsChanged", accountDisconnectHandler);
+      this.emit(constants.ADAPTER_EVENTS.CONNECTED, {
+        adapter: this.name,
+        reconnected: this.rehydrated,
+        provider: this.injectedProvider
+      });
+      return this.injectedProvider;
+    } catch (error) {
+      // ready again to be connected
+      this.status = constants.ADAPTER_STATUS.READY;
+      this.rehydrated = false;
+      this.emit(constants.ADAPTER_EVENTS.ERRORED, error);
+      if (error instanceof index.Web3AuthError) throw error;
+      throw index.WalletLoginError.connectionError(`Failed to login with ${this.name} injected wallet`);
+    }
+  }
+  async disconnect(options = {
+    cleanup: false
+  }) {
+    if (!this.injectedProvider) throw index.WalletLoginError.connectionError("Injected provider is not available");
+    await super.disconnectSession();
+    if (typeof this.injectedProvider.removeAllListeners !== "undefined") this.injectedProvider.removeAllListeners();
+    try {
+      await this.injectedProvider.request({
+        method: "wallet_revokePermissions",
+        params: [{
+          eth_accounts: {}
+        }]
+      });
+    } catch (error) {}
+    if (options.cleanup) {
+      this.status = constants.ADAPTER_STATUS.NOT_READY;
+      this.injectedProvider = null;
+    } else {
+      // ready to be connected again
+      this.status = constants.ADAPTER_STATUS.READY;
+    }
+    await super.disconnect();
+  }
+  async getUserInfo() {
+    if (this.status !== constants.ADAPTER_STATUS.CONNECTED) throw index.WalletLoginError.notConnectedError("Not connected with wallet, Please login/connect first");
+    return {};
+  }
+  async addChain(chainConfig, init = false) {
+    if (!this.injectedProvider) throw index.WalletLoginError.connectionError("Injected provider is not available");
+    super.checkAddChainRequirements(chainConfig, init);
+    await this.injectedProvider.request({
+      method: "wallet_addEthereumChain",
+      params: [{
+        chainId: chainConfig.chainId,
+        chainName: chainConfig.displayName,
+        rpcUrls: [chainConfig.rpcTarget],
+        blockExplorerUrls: [chainConfig.blockExplorerUrl],
+        nativeCurrency: {
+          name: chainConfig.tickerName,
+          symbol: chainConfig.ticker,
+          decimals: chainConfig.decimals || 18
+        },
+        iconUrls: [chainConfig.logo]
+      }]
+    });
+    this.addChainConfig(chainConfig);
+  }
+  async switchChain(params, init = false) {
+    if (!this.injectedProvider) throw index.WalletLoginError.connectionError("Injected provider is not available");
+    super.checkSwitchChainRequirements(params, init);
+    await this.injectedProvider.request({
+      method: "wallet_switchEthereumChain",
+      params: [{
+        chainId: params.chainId
+      }]
+    });
+    this.setAdapterSettings({
+      chainConfig: this.getChainConfig(params.chainId)
+    });
+  }
+  async enableMFA() {
+    throw new Error("Method Not implemented");
+  }
+  async manageMFA() {
+    throw new Error("Method Not implemented");
+  }
+}
+
+exports.InjectedEvmAdapter = InjectedEvmAdapter;

package/dist/lib.cjs/adapters/default-solana-adapter/index.js

@@ -0,0 +1,40 @@
+'use strict';
+
+var _objectSpread = require('@babel/runtime/helpers/objectSpread2');
+var config = require('../../base/chain/config.js');
+var IChainInterface = require('../../base/chain/IChainInterface.js');
+var index = require('../../base/errors/index.js');
+var injectedAdapters = require('./injectedAdapters.js');
+var walletConnectV2adapter = require('../wallet-connect-v2-adapter/walletConnectV2adapter.js');
+
+const getSolanaDefaultExternalAdapters = params => {
+  const {
+    options
+  } = params;
+  const {
+    clientId,
+    chainConfig,
+    sessionTime,
+    web3AuthNetwork,
+    useCoreKitKey
+  } = options;
+  if (!Object.values(IChainInterface.CHAIN_NAMESPACES).includes(chainConfig.chainNamespace)) throw index.WalletInitializationError.invalidParams(`Invalid chainNamespace: ${chainConfig.chainNamespace}`);
+  const finalChainConfig = _objectSpread(_objectSpread({}, config.getChainConfig(chainConfig.chainNamespace, chainConfig === null || chainConfig === void 0 ? void 0 : chainConfig.chainId)), chainConfig || {});
+  const wcv2Adapter = new walletConnectV2adapter.WalletConnectV2Adapter({
+    chainConfig: finalChainConfig,
+    clientId,
+    sessionTime,
+    web3AuthNetwork,
+    useCoreKitKey,
+    adapterSettings: {
+      walletConnectInitOptions: {}
+    }
+  });
+  const injectedProviders = injectedAdapters.getSolanaInjectedAdapters({
+    options
+  });
+  return [...injectedProviders, wcv2Adapter];
+};
+
+exports.getSolanaInjectedAdapters = injectedAdapters.getSolanaInjectedAdapters;
+exports.getSolanaDefaultExternalAdapters = getSolanaDefaultExternalAdapters;

package/dist/lib.cjs/adapters/default-solana-adapter/injectedAdapters.js

@@ -0,0 +1,53 @@
+'use strict';
+
+var _objectSpread = require('@babel/runtime/helpers/objectSpread2');
+var walletStandardFeatures = require('@solana/wallet-standard-features');
+var app = require('@wallet-standard/app');
+var features = require('@wallet-standard/features');
+var config = require('../../base/chain/config.js');
+var IChainInterface = require('../../base/chain/IChainInterface.js');
+var index = require('../../base/errors/index.js');
+var utils = require('../../base/utils.js');
+var walletStandardAdapter = require('./walletStandardAdapter.js');
+
+const getSolanaInjectedAdapters = params => {
+  const {
+    options
+  } = params;
+  const {
+    clientId,
+    chainConfig,
+    sessionTime,
+    web3AuthNetwork,
+    useCoreKitKey
+  } = options;
+  if (!Object.values(IChainInterface.CHAIN_NAMESPACES).includes(chainConfig.chainNamespace)) throw index.WalletInitializationError.invalidParams(`Invalid chainNamespace: ${chainConfig.chainNamespace}`);
+  const finalChainConfig = _objectSpread(_objectSpread({}, config.getChainConfig(chainConfig.chainNamespace, chainConfig === null || chainConfig === void 0 ? void 0 : chainConfig.chainId)), chainConfig || {});
+
+  // get installed wallets that support standard wallet
+  const standardWalletAdapters = [];
+  const wallets = app.getWallets().get();
+  wallets.forEach(wallet => {
+    const {
+      name,
+      chains,
+      features: features$1
+    } = wallet;
+    const isSolana = chains.some(chain => chain.startsWith("solana"));
+    if (!isSolana) return;
+    const hasRequiredFeatures = [features.StandardConnect, walletStandardFeatures.SolanaSignMessage, walletStandardFeatures.SolanaSignTransaction, walletStandardFeatures.SolanaSignAndSendTransaction].every(feature => Object.keys(features$1).includes(feature));
+    if (!hasRequiredFeatures) return;
+    standardWalletAdapters.push(new walletStandardAdapter.WalletStandardAdapter({
+      name: utils.normalizeWalletName(name),
+      wallet,
+      chainConfig: finalChainConfig,
+      clientId,
+      sessionTime,
+      web3AuthNetwork,
+      useCoreKitKey
+    }));
+  });
+  return standardWalletAdapters;
+};
+
+exports.getSolanaInjectedAdapters = getSolanaInjectedAdapters;

package/dist/lib.cjs/adapters/default-solana-adapter/utils.js

@@ -0,0 +1,16 @@
+'use strict';
+
+const getSolanaChainByChainConfig = chainConfig => {
+  switch (chainConfig.chainId) {
+    case "0x65":
+      return "solana:mainnet";
+    case "0x66":
+      return "solana:testnet";
+    case "0x67":
+      return "solana:devnet";
+    default:
+      return null;
+  }
+};
+
+exports.getSolanaChainByChainConfig = getSolanaChainByChainConfig;

package/dist/lib.cjs/adapters/default-solana-adapter/walletStandardAdapter.js

@@ -0,0 +1,138 @@
+'use strict';
+
+var _defineProperty = require('@babel/runtime/helpers/defineProperty');
+var features = require('@wallet-standard/features');
+var IChainInterface = require('../../base/chain/IChainInterface.js');
+var index = require('../../base/errors/index.js');
+var loglevel = require('../../base/loglevel.js');
+var utils = require('./utils.js');
+var walletStandardHandler = require('./walletStandardHandler.js');
+var baseSolanaAdapter = require('../base-solana-adapter/baseSolanaAdapter.js');
+var walletStandardProvider = require('../../providers/solana-provider/providers/injectedProviders/walletStandardProvider.js');
+var constants = require('../../base/adapter/constants.js');
+
+class WalletStandardAdapter extends baseSolanaAdapter.BaseSolanaAdapter {
+  constructor(options) {
+    super(options);
+    _defineProperty(this, "name", void 0);
+    _defineProperty(this, "adapterNamespace", IChainInterface.ADAPTER_NAMESPACES.SOLANA);
+    _defineProperty(this, "currentChainNamespace", IChainInterface.CHAIN_NAMESPACES.SOLANA);
+    _defineProperty(this, "type", constants.ADAPTER_CATEGORY.EXTERNAL);
+    _defineProperty(this, "isInjected", true);
+    _defineProperty(this, "status", constants.ADAPTER_STATUS.NOT_READY);
+    _defineProperty(this, "wallet", null);
+    _defineProperty(this, "injectedProvider", null);
+    this.name = options.name;
+    // in VueJS, for some wallets e.g. Gate, Solflare, when connecting it throws error "attempted to get private field on non-instance"
+    // it seems that Vue create a Proxy object for the wallet object which causes the issue
+    // ref: https://stackoverflow.com/questions/64917686/vue-array-converted-to-proxy-object
+    this.wallet = ["gate", "solflare"].includes(this.name) ? Object.freeze(options.wallet) : options.wallet;
+  }
+  get provider() {
+    if (this.status !== constants.ADAPTER_STATUS.NOT_READY && this.injectedProvider) {
+      return this.injectedProvider;
+    }
+    return null;
+  }
+  get isWalletConnected() {
+    return !!(this.status === constants.ADAPTER_STATUS.CONNECTED && this.wallet.accounts.length > 0);
+  }
+  async init(options = {}) {
+    await super.init(options);
+    super.checkInitializationRequirements();
+    this.injectedProvider = new walletStandardProvider.WalletStandardProvider({
+      config: {
+        chainConfig: this.chainConfig
+      }
+    });
+    const providerHandler = new walletStandardHandler.WalletStandardProviderHandler({
+      wallet: this.wallet,
+      getCurrentChain: () => utils.getSolanaChainByChainConfig(this.chainConfig)
+    });
+    this.injectedProvider.setupProvider(providerHandler);
+    this.status = constants.ADAPTER_STATUS.READY;
+    this.emit(constants.ADAPTER_EVENTS.READY, this.name);
+    try {
+      loglevel.log.debug("initializing solana injected adapter");
+      if (options.autoConnect) {
+        this.rehydrated = true;
+        await this.connect();
+      }
+    } catch (error) {
+      loglevel.log.error("Failed to connect with cached solana injected provider", error);
+      this.emit(constants.ADAPTER_EVENTS.ERRORED, error);
+    }
+  }
+  async connect() {
+    try {
+      super.checkConnectionRequirements();
+      this.status = constants.ADAPTER_STATUS.CONNECTING;
+      this.emit(constants.ADAPTER_EVENTS.CONNECTING, {
+        adapter: this.name
+      });
+      const chainName = utils.getSolanaChainByChainConfig(this.chainConfig);
+      if (!this.wallet.chains.find(chain => chain === chainName)) throw index.WalletLoginError.connectionError(`Chain ${chainName} not supported. Supported chains are ${this.wallet.chains.join(", ")}`);
+      if (!this.isWalletConnected) {
+        await this.wallet.features[features.StandardConnect].connect();
+      }
+      if (this.wallet.accounts.length === 0) throw index.WalletLoginError.connectionError();
+      this.status = constants.ADAPTER_STATUS.CONNECTED;
+      this.emit(constants.ADAPTER_EVENTS.CONNECTED, {
+        adapter: this.name,
+        reconnected: this.rehydrated,
+        provider: this.provider
+      });
+      return this.provider;
+    } catch (error) {
+      // ready again to be connected
+      this.status = constants.ADAPTER_STATUS.READY;
+      this.rehydrated = false;
+      this.emit(constants.ADAPTER_EVENTS.ERRORED, error);
+      throw error;
+    }
+  }
+  async disconnect(options = {
+    cleanup: false
+  }) {
+    await super.disconnectSession();
+    try {
+      var _this$wallet$features;
+      await ((_this$wallet$features = this.wallet.features[features.StandardDisconnect]) === null || _this$wallet$features === void 0 ? void 0 : _this$wallet$features.disconnect());
+      if (options.cleanup) {
+        this.status = constants.ADAPTER_STATUS.NOT_READY;
+        this.injectedProvider = null;
+      } else {
+        this.status = constants.ADAPTER_STATUS.READY;
+      }
+      await super.disconnect();
+    } catch (error) {
+      this.emit(constants.ADAPTER_EVENTS.ERRORED, index.WalletLoginError.disconnectionError(error === null || error === void 0 ? void 0 : error.message));
+    }
+  }
+  async getUserInfo() {
+    if (!this.isWalletConnected) throw index.WalletLoginError.notConnectedError("Not connected with wallet, Please login/connect first");
+    return {};
+  }
+  async addChain(chainConfig, init = false) {
+    var _this$injectedProvide;
+    super.checkAddChainRequirements(chainConfig, init);
+    (_this$injectedProvide = this.injectedProvider) === null || _this$injectedProvide === void 0 || _this$injectedProvide.addChain(chainConfig);
+    this.addChainConfig(chainConfig);
+  }
+  async switchChain(params, init = false) {
+    var _this$injectedProvide2;
+    super.checkSwitchChainRequirements(params, init);
+    await ((_this$injectedProvide2 = this.injectedProvider) === null || _this$injectedProvide2 === void 0 ? void 0 : _this$injectedProvide2.switchChain(params));
+    this.setAdapterSettings({
+      chainConfig: this.getChainConfig(params.chainId)
+    });
+  }
+  async enableMFA() {
+    throw new Error("Method not implemented.");
+  }
+  async manageMFA() {
+    throw new Error("Method Not implemented");
+  }
+}
+
+exports.WalletStandardAdapter = WalletStandardAdapter;