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

package/dist/lib.cjs/connectors/coinbase-connector/coinbaseConnector.js

@@ -0,0 +1,151 @@
+'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 baseEvmConnector = require('../base-evm-connector/baseEvmConnector.js');
+var constants = require('../../base/connector/constants.js');
+
+class CoinbaseConnector extends baseEvmConnector.BaseEvmConnector {
+  constructor(connectorOptions) {
+    super(connectorOptions);
+    _defineProperty(this, "connectorNamespace", IChainInterface.CONNECTOR_NAMESPACES.EIP155);
+    _defineProperty(this, "currentChainNamespace", IChainInterface.CHAIN_NAMESPACES.EIP155);
+    _defineProperty(this, "type", constants.CONNECTOR_CATEGORY.EXTERNAL);
+    _defineProperty(this, "name", index.WALLET_CONNECTORS.COINBASE);
+    _defineProperty(this, "status", constants.CONNECTOR_STATUS.NOT_READY);
+    _defineProperty(this, "coinbaseProvider", null);
+    _defineProperty(this, "coinbaseOptions", {
+      appName: "Web3Auth"
+    });
+    this.coinbaseOptions = _objectSpread(_objectSpread({}, this.coinbaseOptions), connectorOptions.connectorSettings);
+  }
+  get provider() {
+    if (this.status !== constants.CONNECTOR_STATUS.NOT_READY && this.coinbaseProvider) {
+      return this.coinbaseProvider;
+    }
+    return null;
+  }
+  set provider(_) {
+    throw new Error("Not implemented");
+  }
+  async init(options) {
+    await super.init(options);
+    const chainConfig = this.coreOptions.chains.find(x => x.chainId === options.chainId);
+    super.checkInitializationRequirements({
+      chainConfig
+    });
+    const coinbaseInstance = walletSdk.createCoinbaseWalletSDK(_objectSpread(_objectSpread({}, this.coinbaseOptions), {}, {
+      preference: {
+        options: this.coinbaseOptions.options || "smartWalletOnly"
+      },
+      appChainIds: this.coreOptions.chains.map(x => Number.parseInt(x.chainId, 16)),
+      appName: this.coinbaseOptions.appName || "Web3Auth",
+      appLogoUrl: this.coinbaseOptions.appLogoUrl || ""
+    }));
+    this.coinbaseProvider = coinbaseInstance.getProvider();
+    this.status = constants.CONNECTOR_STATUS.READY;
+    this.emit(constants.CONNECTOR_EVENTS.READY, index.WALLET_CONNECTORS.COINBASE);
+    try {
+      if (options.autoConnect) {
+        this.rehydrated = true;
+        await this.connect({
+          chainId: options.chainId
+        });
+      }
+    } catch (error) {
+      this.emit(constants.CONNECTOR_EVENTS.ERRORED, error);
+    }
+  }
+  async connect({
+    chainId
+  }) {
+    super.checkConnectionRequirements();
+    if (!this.coinbaseProvider) throw index$1.WalletLoginError.notConnectedError("Connector is not initialized");
+    this.status = constants.CONNECTOR_STATUS.CONNECTING;
+    this.emit(constants.CONNECTOR_EVENTS.CONNECTING, {
+      connector: index.WALLET_CONNECTORS.COINBASE
+    });
+    try {
+      const chainConfig = this.coreOptions.chains.find(x => x.chainId === chainId);
+      if (!chainConfig) throw index$1.WalletLoginError.connectionError("Chain config is not available");
+      await this.coinbaseProvider.request({
+        method: "eth_requestAccounts"
+      });
+      const currentChainId = await this.coinbaseProvider.request({
+        method: "eth_chainId"
+      });
+      if (currentChainId !== chainConfig.chainId) {
+        await this.switchChain(chainConfig, true);
+      }
+      this.status = constants.CONNECTOR_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.CONNECTOR_EVENTS.CONNECTED, {
+        connector: index.WALLET_CONNECTORS.COINBASE,
+        reconnected: this.rehydrated,
+        provider: this.provider
+      });
+      return this.provider;
+    } catch (error) {
+      // ready again to be connected
+      this.status = constants.CONNECTOR_STATUS.READY;
+      this.rehydrated = false;
+      this.emit(constants.CONNECTOR_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.CONNECTOR_STATUS.NOT_READY;
+      this.coinbaseProvider = null;
+    } else {
+      // ready to be connected again
+      this.status = constants.CONNECTOR_STATUS.READY;
+    }
+    await super.disconnect();
+  }
+  async getUserInfo() {
+    if (this.status !== constants.CONNECTOR_STATUS.CONNECTED) throw index$1.WalletLoginError.notConnectedError("Not connected with wallet, Please login/connect first");
+    return {};
+  }
+  async switchChain(params, init = false) {
+    super.checkSwitchChainRequirements(params, init);
+    await this.coinbaseProvider.request({
+      method: "wallet_switchEthereumChain",
+      params: [{
+        chainId: params.chainId
+      }]
+    });
+  }
+  async enableMFA() {
+    throw new Error("Method Not implemented");
+  }
+  async manageMFA() {
+    throw new Error("Method Not implemented");
+  }
+}
+const coinbaseConnector = params => {
+  return ({
+    coreOptions
+  }) => {
+    return new CoinbaseConnector({
+      connectorSettings: params,
+      coreOptions
+    });
+  };
+};
+
+exports.coinbaseConnector = coinbaseConnector;

package/dist/lib.cjs/connectors/injected-evm-connector/index.js

@@ -0,0 +1,12 @@
+'use strict';
+
+var injectedEvmConnector = require('./injectedEvmConnector.js');
+var mipd = require('mipd');
+
+
+
+exports.injectedEvmConnector = injectedEvmConnector.injectedEvmConnector;
+Object.defineProperty(exports, "createMipd", {
+	enumerable: true,
+	get: function () { return mipd.createStore; }
+});

package/dist/lib.cjs/{adapters/default-evm-adapter/injectedEvmAdapter.js → connectors/injected-evm-connector/injectedEvmConnector.js}

@@ -4,24 +4,25 @@ 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');
+var utils = require('../../base/utils.js');
+var baseEvmConnector = require('../base-evm-connector/baseEvmConnector.js');
+var constants = require('../../base/connector/constants.js');
 
-class InjectedEvmAdapter extends baseEvmAdapter.BaseEvmAdapter {
+class InjectedEvmConnector extends baseEvmConnector.BaseEvmConnector {
   constructor(options) {
     super(options);
-    _defineProperty(this, "adapterNamespace", IChainInterface.ADAPTER_NAMESPACES.EIP155);
+    _defineProperty(this, "connectorNamespace", IChainInterface.CONNECTOR_NAMESPACES.EIP155);
     _defineProperty(this, "currentChainNamespace", IChainInterface.CHAIN_NAMESPACES.EIP155);
-    _defineProperty(this, "type", constants.ADAPTER_CATEGORY.EXTERNAL);
+    _defineProperty(this, "type", constants.CONNECTOR_CATEGORY.EXTERNAL);
     _defineProperty(this, "name", void 0);
     _defineProperty(this, "isInjected", true);
-    _defineProperty(this, "status", constants.ADAPTER_STATUS.NOT_READY);
+    _defineProperty(this, "status", constants.CONNECTOR_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) {
+    if (this.status !== constants.CONNECTOR_STATUS.NOT_READY && this.injectedProvider) {
       return this.injectedProvider;
     }
     return null;
@@ -29,43 +30,51 @@ class InjectedEvmAdapter extends baseEvmAdapter.BaseEvmAdapter {
   set provider(_) {
     throw new Error("Not implemented");
   }
-  async init(options = {}) {
+  async init(options) {
     await super.init(options);
-    super.checkInitializationRequirements();
-    this.status = constants.ADAPTER_STATUS.READY;
-    this.emit(constants.ADAPTER_EVENTS.READY, this.name);
+    const chainConfig = this.coreOptions.chains.find(x => x.chainId === options.chainId);
+    super.checkInitializationRequirements({
+      chainConfig
+    });
+    this.status = constants.CONNECTOR_STATUS.READY;
+    this.emit(constants.CONNECTOR_EVENTS.READY, this.name);
     try {
-      loglevel.log.debug(`initializing ${this.name} injected adapter`);
+      loglevel.log.debug(`initializing ${this.name} injected connector`);
       if (options.autoConnect) {
         this.rehydrated = true;
-        await this.connect();
+        await this.connect({
+          chainId: options.chainId
+        });
       }
     } catch (error) {
-      this.emit(constants.ADAPTER_EVENTS.ERRORED, error);
+      this.emit(constants.CONNECTOR_EVENTS.ERRORED, error);
     }
   }
-  async connect() {
+  async connect({
+    chainId
+  }) {
     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
+    const chainConfig = this.coreOptions.chains.find(x => x.chainId === chainId);
+    if (!chainConfig) throw index.WalletLoginError.connectionError("Chain config is not available");
+    this.status = constants.CONNECTOR_STATUS.CONNECTING;
+    this.emit(constants.CONNECTOR_EVENTS.CONNECTING, {
+      connector: 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) {
+      if (this.injectedProvider.chainId !== chainConfig.chainId) {
         try {
-          await this.switchChain(this.chainConfig, true);
+          await this.switchChain(chainConfig, true);
         } catch (error) {
-          await this.addChain(this.chainConfig, true);
-          await this.switchChain(this.chainConfig, true);
+          await this.addChain(chainConfig, true);
+          await this.switchChain(chainConfig, true);
         }
       }
-      this.status = constants.ADAPTER_STATUS.CONNECTED;
+      this.status = constants.CONNECTOR_STATUS.CONNECTED;
       const accountDisconnectHandler = accounts => {
         if (accounts.length === 0) {
           var _this$injectedProvide;
@@ -74,17 +83,17 @@ class InjectedEvmAdapter extends baseEvmAdapter.BaseEvmAdapter {
         }
       };
       this.injectedProvider.on("accountsChanged", accountDisconnectHandler);
-      this.emit(constants.ADAPTER_EVENTS.CONNECTED, {
-        adapter: this.name,
+      this.emit(constants.CONNECTOR_EVENTS.CONNECTED, {
+        connector: 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.status = constants.CONNECTOR_STATUS.READY;
       this.rehydrated = false;
-      this.emit(constants.ADAPTER_EVENTS.ERRORED, error);
+      this.emit(constants.CONNECTOR_EVENTS.ERRORED, error);
       if (error instanceof index.Web3AuthError) throw error;
       throw index.WalletLoginError.connectionError(`Failed to login with ${this.name} injected wallet`);
     }
@@ -104,21 +113,20 @@ class InjectedEvmAdapter extends baseEvmAdapter.BaseEvmAdapter {
       });
     } catch (error) {}
     if (options.cleanup) {
-      this.status = constants.ADAPTER_STATUS.NOT_READY;
+      this.status = constants.CONNECTOR_STATUS.NOT_READY;
       this.injectedProvider = null;
     } else {
       // ready to be connected again
-      this.status = constants.ADAPTER_STATUS.READY;
+      this.status = constants.CONNECTOR_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");
+    if (this.status !== constants.CONNECTOR_STATUS.CONNECTED) throw index.WalletLoginError.notConnectedError("Not connected with wallet, Please login/connect first");
     return {};
   }
-  async addChain(chainConfig, init = false) {
+  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: [{
@@ -134,7 +142,6 @@ class InjectedEvmAdapter extends baseEvmAdapter.BaseEvmAdapter {
         iconUrls: [chainConfig.logo]
       }]
     });
-    this.addChainConfig(chainConfig);
   }
   async switchChain(params, init = false) {
     if (!this.injectedProvider) throw index.WalletLoginError.connectionError("Injected provider is not available");
@@ -145,9 +152,6 @@ class InjectedEvmAdapter extends baseEvmAdapter.BaseEvmAdapter {
         chainId: params.chainId
       }]
     });
-    this.setAdapterSettings({
-      chainConfig: this.getChainConfig(params.chainId)
-    });
   }
   async enableMFA() {
     throw new Error("Method Not implemented");
@@ -156,5 +160,17 @@ class InjectedEvmAdapter extends baseEvmAdapter.BaseEvmAdapter {
     throw new Error("Method Not implemented");
   }
 }
+const injectedEvmConnector = providerDetail => {
+  return ({
+    coreOptions
+  }) => {
+    return new InjectedEvmConnector({
+      name: utils.normalizeWalletName(providerDetail.info.name),
+      provider: providerDetail.provider,
+      coreOptions
+    });
+  };
+};
 
-exports.InjectedEvmAdapter = InjectedEvmAdapter;
+exports.InjectedEvmConnector = InjectedEvmConnector;
+exports.injectedEvmConnector = injectedEvmConnector;

package/dist/lib.cjs/connectors/injected-solana-connector/index.js

@@ -0,0 +1,25 @@
+'use strict';
+
+var walletStandardFeatures = require('@solana/wallet-standard-features');
+var app = require('@wallet-standard/app');
+var features = require('@wallet-standard/features');
+var walletStandardConnector = require('./walletStandardConnector.js');
+
+const hasSolanaWalletStandardFeatures = wallet => {
+  const {
+    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 false;
+  return true;
+};
+
+Object.defineProperty(exports, "createSolanaMipd", {
+  enumerable: true,
+  get: function () { return app.getWallets; }
+});
+exports.walletStandardConnector = walletStandardConnector.walletStandardConnector;
+exports.hasSolanaWalletStandardFeatures = hasSolanaWalletStandardFeatures;

package/dist/lib.cjs/{adapters/default-solana-adapter/walletStandardAdapter.js → connectors/injected-solana-connector/walletStandardConnector.js}

@@ -5,21 +5,21 @@ 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 utils = require('../../base/utils.js');
+var baseSolanaConnector = require('../base-solana-connector/baseSolanaConnector.js');
 var walletStandardProvider = require('../../providers/solana-provider/providers/injectedProviders/walletStandardProvider.js');
-var constants = require('../../base/adapter/constants.js');
+var utils$1 = require('../../providers/solana-provider/providers/injectedProviders/utils.js');
+var constants = require('../../base/connector/constants.js');
 
-class WalletStandardAdapter extends baseSolanaAdapter.BaseSolanaAdapter {
+class WalletStandardConnector extends baseSolanaConnector.BaseSolanaConnector {
   constructor(options) {
     super(options);
     _defineProperty(this, "name", void 0);
-    _defineProperty(this, "adapterNamespace", IChainInterface.ADAPTER_NAMESPACES.SOLANA);
+    _defineProperty(this, "connectorNamespace", IChainInterface.CONNECTOR_NAMESPACES.SOLANA);
     _defineProperty(this, "currentChainNamespace", IChainInterface.CHAIN_NAMESPACES.SOLANA);
-    _defineProperty(this, "type", constants.ADAPTER_CATEGORY.EXTERNAL);
+    _defineProperty(this, "type", constants.CONNECTOR_CATEGORY.EXTERNAL);
     _defineProperty(this, "isInjected", true);
-    _defineProperty(this, "status", constants.ADAPTER_STATUS.NOT_READY);
+    _defineProperty(this, "status", constants.CONNECTOR_STATUS.NOT_READY);
     _defineProperty(this, "wallet", null);
     _defineProperty(this, "injectedProvider", null);
     this.name = options.name;
@@ -29,65 +29,71 @@ class WalletStandardAdapter extends baseSolanaAdapter.BaseSolanaAdapter {
     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) {
+    if (this.status !== constants.CONNECTOR_STATUS.NOT_READY && this.injectedProvider) {
       return this.injectedProvider;
     }
     return null;
   }
   get isWalletConnected() {
-    return !!(this.status === constants.ADAPTER_STATUS.CONNECTED && this.wallet.accounts.length > 0);
+    return !!(this.status === constants.CONNECTOR_STATUS.CONNECTED && this.wallet.accounts.length > 0);
   }
-  async init(options = {}) {
+  async init(options) {
     await super.init(options);
-    super.checkInitializationRequirements();
+    const chainConfig = this.coreOptions.chains.find(x => x.chainId === options.chainId);
+    super.checkInitializationRequirements({
+      chainConfig
+    });
     this.injectedProvider = new walletStandardProvider.WalletStandardProvider({
       config: {
-        chainConfig: this.chainConfig
+        chain: chainConfig,
+        chains: this.coreOptions.chains
       }
     });
-    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);
+    await this.injectedProvider.setupProvider(this.wallet, options.chainId);
+    this.status = constants.CONNECTOR_STATUS.READY;
+    this.emit(constants.CONNECTOR_EVENTS.READY, this.name);
     try {
-      loglevel.log.debug("initializing solana injected adapter");
+      loglevel.log.debug("initializing solana injected connector");
       if (options.autoConnect) {
         this.rehydrated = true;
-        await this.connect();
+        await this.connect({
+          chainId: options.chainId
+        });
       }
     } catch (error) {
       loglevel.log.error("Failed to connect with cached solana injected provider", error);
-      this.emit(constants.ADAPTER_EVENTS.ERRORED, error);
+      this.emit(constants.CONNECTOR_EVENTS.ERRORED, error);
     }
   }
-  async connect() {
+  async connect({
+    chainId
+  }) {
     try {
       super.checkConnectionRequirements();
-      this.status = constants.ADAPTER_STATUS.CONNECTING;
-      this.emit(constants.ADAPTER_EVENTS.CONNECTING, {
-        adapter: this.name
+      const chainConfig = this.coreOptions.chains.find(x => x.chainId === chainId);
+      if (!chainConfig) throw index.WalletLoginError.connectionError("Chain config is not available");
+      this.status = constants.CONNECTOR_STATUS.CONNECTING;
+      this.emit(constants.CONNECTOR_EVENTS.CONNECTING, {
+        connector: this.name
       });
-      const chainName = utils.getSolanaChainByChainConfig(this.chainConfig);
+      const chainName = utils$1.getSolanaChainByChainConfig(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,
+      this.status = constants.CONNECTOR_STATUS.CONNECTED;
+      this.emit(constants.CONNECTOR_EVENTS.CONNECTED, {
+        connector: 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.status = constants.CONNECTOR_STATUS.READY;
       this.rehydrated = false;
-      this.emit(constants.ADAPTER_EVENTS.ERRORED, error);
+      this.emit(constants.CONNECTOR_EVENTS.ERRORED, error);
       throw error;
     }
   }
@@ -99,33 +105,24 @@ class WalletStandardAdapter extends baseSolanaAdapter.BaseSolanaAdapter {
       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.status = constants.CONNECTOR_STATUS.NOT_READY;
         this.injectedProvider = null;
       } else {
-        this.status = constants.ADAPTER_STATUS.READY;
+        this.status = constants.CONNECTOR_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));
+      this.emit(constants.CONNECTOR_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;
+    var _this$injectedProvide;
     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)
-    });
+    await ((_this$injectedProvide = this.injectedProvider) === null || _this$injectedProvide === void 0 ? void 0 : _this$injectedProvide.switchChain(params));
   }
   async enableMFA() {
     throw new Error("Method not implemented.");
@@ -134,5 +131,17 @@ class WalletStandardAdapter extends baseSolanaAdapter.BaseSolanaAdapter {
     throw new Error("Method Not implemented");
   }
 }
+const walletStandardConnector = wallet => {
+  return ({
+    coreOptions
+  }) => {
+    return new WalletStandardConnector({
+      name: utils.normalizeWalletName(wallet.name),
+      wallet,
+      coreOptions
+    });
+  };
+};
 
-exports.WalletStandardAdapter = WalletStandardAdapter;
+exports.WalletStandardConnector = WalletStandardConnector;
+exports.walletStandardConnector = walletStandardConnector;