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

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

@@ -0,0 +1,149 @@
+import _objectSpread from '@babel/runtime/helpers/objectSpread2';
+import _defineProperty from '@babel/runtime/helpers/defineProperty';
+import { createCoinbaseWalletSDK } from '@coinbase/wallet-sdk';
+import { CONNECTOR_NAMESPACES, CHAIN_NAMESPACES } from '../../base/chain/IChainInterface.js';
+import { WalletLoginError, Web3AuthError } from '../../base/errors/index.js';
+import { WALLET_CONNECTORS } from '../../base/wallet/index.js';
+import { BaseEvmConnector } from '../base-evm-connector/baseEvmConnector.js';
+import { CONNECTOR_CATEGORY, CONNECTOR_STATUS, CONNECTOR_EVENTS } from '../../base/connector/constants.js';
+
+class CoinbaseConnector extends BaseEvmConnector {
+  constructor(connectorOptions) {
+    super(connectorOptions);
+    _defineProperty(this, "connectorNamespace", CONNECTOR_NAMESPACES.EIP155);
+    _defineProperty(this, "currentChainNamespace", CHAIN_NAMESPACES.EIP155);
+    _defineProperty(this, "type", CONNECTOR_CATEGORY.EXTERNAL);
+    _defineProperty(this, "name", WALLET_CONNECTORS.COINBASE);
+    _defineProperty(this, "status", 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 !== 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 = 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 = CONNECTOR_STATUS.READY;
+    this.emit(CONNECTOR_EVENTS.READY, WALLET_CONNECTORS.COINBASE);
+    try {
+      if (options.autoConnect) {
+        this.rehydrated = true;
+        await this.connect({
+          chainId: options.chainId
+        });
+      }
+    } catch (error) {
+      this.emit(CONNECTOR_EVENTS.ERRORED, error);
+    }
+  }
+  async connect({
+    chainId
+  }) {
+    super.checkConnectionRequirements();
+    if (!this.coinbaseProvider) throw WalletLoginError.notConnectedError("Connector is not initialized");
+    this.status = CONNECTOR_STATUS.CONNECTING;
+    this.emit(CONNECTOR_EVENTS.CONNECTING, {
+      connector: WALLET_CONNECTORS.COINBASE
+    });
+    try {
+      const chainConfig = this.coreOptions.chains.find(x => x.chainId === chainId);
+      if (!chainConfig) throw 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 = CONNECTOR_STATUS.CONNECTED;
+      if (!this.provider) throw WalletLoginError.notConnectedError("Failed to connect with provider");
+      this.provider.once("disconnect", () => {
+        // ready to be connected again
+        this.disconnect();
+      });
+      this.emit(CONNECTOR_EVENTS.CONNECTED, {
+        connector: WALLET_CONNECTORS.COINBASE,
+        reconnected: this.rehydrated,
+        provider: this.provider
+      });
+      return this.provider;
+    } catch (error) {
+      // ready again to be connected
+      this.status = CONNECTOR_STATUS.READY;
+      this.rehydrated = false;
+      this.emit(CONNECTOR_EVENTS.ERRORED, error);
+      if (error instanceof Web3AuthError) throw error;
+      throw 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 = CONNECTOR_STATUS.NOT_READY;
+      this.coinbaseProvider = null;
+    } else {
+      // ready to be connected again
+      this.status = CONNECTOR_STATUS.READY;
+    }
+    await super.disconnect();
+  }
+  async getUserInfo() {
+    if (this.status !== CONNECTOR_STATUS.CONNECTED) throw 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
+    });
+  };
+};
+
+export { coinbaseConnector };

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

@@ -0,0 +1,2 @@
+export { injectedEvmConnector } from './injectedEvmConnector.js';
+export { createStore as createMipd } from 'mipd';

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

@@ -1,25 +1,26 @@
 import _defineProperty from '@babel/runtime/helpers/defineProperty';
-import { ADAPTER_NAMESPACES, CHAIN_NAMESPACES } from '../../base/chain/IChainInterface.js';
+import { CONNECTOR_NAMESPACES, CHAIN_NAMESPACES } from '../../base/chain/IChainInterface.js';
 import { WalletLoginError, Web3AuthError } from '../../base/errors/index.js';
 import { log } from '../../base/loglevel.js';
-import { BaseEvmAdapter } from '../base-evm-adapter/baseEvmAdapter.js';
-import { ADAPTER_CATEGORY, ADAPTER_STATUS, ADAPTER_EVENTS } from '../../base/adapter/constants.js';
+import { normalizeWalletName } from '../../base/utils.js';
+import { BaseEvmConnector } from '../base-evm-connector/baseEvmConnector.js';
+import { CONNECTOR_CATEGORY, CONNECTOR_STATUS, CONNECTOR_EVENTS } from '../../base/connector/constants.js';
 
-class InjectedEvmAdapter extends BaseEvmAdapter {
+class InjectedEvmConnector extends BaseEvmConnector {
   constructor(options) {
     super(options);
-    _defineProperty(this, "adapterNamespace", ADAPTER_NAMESPACES.EIP155);
+    _defineProperty(this, "connectorNamespace", CONNECTOR_NAMESPACES.EIP155);
     _defineProperty(this, "currentChainNamespace", CHAIN_NAMESPACES.EIP155);
-    _defineProperty(this, "type", ADAPTER_CATEGORY.EXTERNAL);
+    _defineProperty(this, "type", CONNECTOR_CATEGORY.EXTERNAL);
     _defineProperty(this, "name", void 0);
     _defineProperty(this, "isInjected", true);
-    _defineProperty(this, "status", ADAPTER_STATUS.NOT_READY);
+    _defineProperty(this, "status", CONNECTOR_STATUS.NOT_READY);
     _defineProperty(this, "injectedProvider", null);
     this.name = options.name;
     this.injectedProvider = options.provider;
   }
   get provider() {
-    if (this.status !== ADAPTER_STATUS.NOT_READY && this.injectedProvider) {
+    if (this.status !== CONNECTOR_STATUS.NOT_READY && this.injectedProvider) {
       return this.injectedProvider;
     }
     return null;
@@ -27,43 +28,51 @@ class InjectedEvmAdapter extends BaseEvmAdapter {
   set provider(_) {
     throw new Error("Not implemented");
   }
-  async init(options = {}) {
+  async init(options) {
     await super.init(options);
-    super.checkInitializationRequirements();
-    this.status = ADAPTER_STATUS.READY;
-    this.emit(ADAPTER_EVENTS.READY, this.name);
+    const chainConfig = this.coreOptions.chains.find(x => x.chainId === options.chainId);
+    super.checkInitializationRequirements({
+      chainConfig
+    });
+    this.status = CONNECTOR_STATUS.READY;
+    this.emit(CONNECTOR_EVENTS.READY, this.name);
     try {
-      log.debug(`initializing ${this.name} injected adapter`);
+      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(ADAPTER_EVENTS.ERRORED, error);
+      this.emit(CONNECTOR_EVENTS.ERRORED, error);
     }
   }
-  async connect() {
+  async connect({
+    chainId
+  }) {
     super.checkConnectionRequirements();
     if (!this.injectedProvider) throw WalletLoginError.connectionError("Injected provider is not available");
-    if (!this.chainConfig) throw WalletLoginError.connectionError("Chain config is not available");
-    this.status = ADAPTER_STATUS.CONNECTING;
-    this.emit(ADAPTER_EVENTS.CONNECTING, {
-      adapter: this.name
+    const chainConfig = this.coreOptions.chains.find(x => x.chainId === chainId);
+    if (!chainConfig) throw WalletLoginError.connectionError("Chain config is not available");
+    this.status = CONNECTOR_STATUS.CONNECTING;
+    this.emit(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 = ADAPTER_STATUS.CONNECTED;
+      this.status = CONNECTOR_STATUS.CONNECTED;
       const accountDisconnectHandler = accounts => {
         if (accounts.length === 0) {
           var _this$injectedProvide;
@@ -72,17 +81,17 @@ class InjectedEvmAdapter extends BaseEvmAdapter {
         }
       };
       this.injectedProvider.on("accountsChanged", accountDisconnectHandler);
-      this.emit(ADAPTER_EVENTS.CONNECTED, {
-        adapter: this.name,
+      this.emit(CONNECTOR_EVENTS.CONNECTED, {
+        connector: this.name,
         reconnected: this.rehydrated,
         provider: this.injectedProvider
       });
       return this.injectedProvider;
     } catch (error) {
       // ready again to be connected
-      this.status = ADAPTER_STATUS.READY;
+      this.status = CONNECTOR_STATUS.READY;
       this.rehydrated = false;
-      this.emit(ADAPTER_EVENTS.ERRORED, error);
+      this.emit(CONNECTOR_EVENTS.ERRORED, error);
       if (error instanceof Web3AuthError) throw error;
       throw WalletLoginError.connectionError(`Failed to login with ${this.name} injected wallet`);
     }
@@ -102,21 +111,20 @@ class InjectedEvmAdapter extends BaseEvmAdapter {
       });
     } catch (error) {}
     if (options.cleanup) {
-      this.status = ADAPTER_STATUS.NOT_READY;
+      this.status = CONNECTOR_STATUS.NOT_READY;
       this.injectedProvider = null;
     } else {
       // ready to be connected again
-      this.status = ADAPTER_STATUS.READY;
+      this.status = CONNECTOR_STATUS.READY;
     }
     await super.disconnect();
   }
   async getUserInfo() {
-    if (this.status !== ADAPTER_STATUS.CONNECTED) throw WalletLoginError.notConnectedError("Not connected with wallet, Please login/connect first");
+    if (this.status !== CONNECTOR_STATUS.CONNECTED) throw 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 WalletLoginError.connectionError("Injected provider is not available");
-    super.checkAddChainRequirements(chainConfig, init);
     await this.injectedProvider.request({
       method: "wallet_addEthereumChain",
       params: [{
@@ -132,7 +140,6 @@ class InjectedEvmAdapter extends BaseEvmAdapter {
         iconUrls: [chainConfig.logo]
       }]
     });
-    this.addChainConfig(chainConfig);
   }
   async switchChain(params, init = false) {
     if (!this.injectedProvider) throw WalletLoginError.connectionError("Injected provider is not available");
@@ -143,9 +150,6 @@ class InjectedEvmAdapter extends BaseEvmAdapter {
         chainId: params.chainId
       }]
     });
-    this.setAdapterSettings({
-      chainConfig: this.getChainConfig(params.chainId)
-    });
   }
   async enableMFA() {
     throw new Error("Method Not implemented");
@@ -154,5 +158,16 @@ class InjectedEvmAdapter extends BaseEvmAdapter {
     throw new Error("Method Not implemented");
   }
 }
+const injectedEvmConnector = providerDetail => {
+  return ({
+    coreOptions
+  }) => {
+    return new InjectedEvmConnector({
+      name: normalizeWalletName(providerDetail.info.name),
+      provider: providerDetail.provider,
+      coreOptions
+    });
+  };
+};
 
-export { InjectedEvmAdapter };
+export { InjectedEvmConnector, injectedEvmConnector };

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

@@ -0,0 +1,18 @@
+import { SolanaSignMessage, SolanaSignTransaction, SolanaSignAndSendTransaction } from '@solana/wallet-standard-features';
+export { getWallets as createSolanaMipd } from '@wallet-standard/app';
+import { StandardConnect } from '@wallet-standard/features';
+export { walletStandardConnector } from './walletStandardConnector.js';
+
+const hasSolanaWalletStandardFeatures = wallet => {
+  const {
+    chains,
+    features
+  } = wallet;
+  const isSolana = chains.some(chain => chain.startsWith("solana"));
+  if (!isSolana) return;
+  const hasRequiredFeatures = [StandardConnect, SolanaSignMessage, SolanaSignTransaction, SolanaSignAndSendTransaction].every(feature => Object.keys(features).includes(feature));
+  if (!hasRequiredFeatures) return false;
+  return true;
+};
+
+export { hasSolanaWalletStandardFeatures };

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

@@ -1,23 +1,23 @@
 import _defineProperty from '@babel/runtime/helpers/defineProperty';
 import { StandardConnect, StandardDisconnect } from '@wallet-standard/features';
-import { ADAPTER_NAMESPACES, CHAIN_NAMESPACES } from '../../base/chain/IChainInterface.js';
+import { CONNECTOR_NAMESPACES, CHAIN_NAMESPACES } from '../../base/chain/IChainInterface.js';
 import { WalletLoginError } from '../../base/errors/index.js';
 import { log } from '../../base/loglevel.js';
-import { getSolanaChainByChainConfig } from './utils.js';
-import { WalletStandardProviderHandler } from './walletStandardHandler.js';
-import { BaseSolanaAdapter } from '../base-solana-adapter/baseSolanaAdapter.js';
+import { normalizeWalletName } from '../../base/utils.js';
+import { BaseSolanaConnector } from '../base-solana-connector/baseSolanaConnector.js';
 import { WalletStandardProvider } from '../../providers/solana-provider/providers/injectedProviders/walletStandardProvider.js';
-import { ADAPTER_CATEGORY, ADAPTER_STATUS, ADAPTER_EVENTS } from '../../base/adapter/constants.js';
+import { getSolanaChainByChainConfig } from '../../providers/solana-provider/providers/injectedProviders/utils.js';
+import { CONNECTOR_CATEGORY, CONNECTOR_STATUS, CONNECTOR_EVENTS } from '../../base/connector/constants.js';
 
-class WalletStandardAdapter extends BaseSolanaAdapter {
+class WalletStandardConnector extends BaseSolanaConnector {
   constructor(options) {
     super(options);
     _defineProperty(this, "name", void 0);
-    _defineProperty(this, "adapterNamespace", ADAPTER_NAMESPACES.SOLANA);
+    _defineProperty(this, "connectorNamespace", CONNECTOR_NAMESPACES.SOLANA);
     _defineProperty(this, "currentChainNamespace", CHAIN_NAMESPACES.SOLANA);
-    _defineProperty(this, "type", ADAPTER_CATEGORY.EXTERNAL);
+    _defineProperty(this, "type", CONNECTOR_CATEGORY.EXTERNAL);
     _defineProperty(this, "isInjected", true);
-    _defineProperty(this, "status", ADAPTER_STATUS.NOT_READY);
+    _defineProperty(this, "status", CONNECTOR_STATUS.NOT_READY);
     _defineProperty(this, "wallet", null);
     _defineProperty(this, "injectedProvider", null);
     this.name = options.name;
@@ -27,65 +27,71 @@ class WalletStandardAdapter extends BaseSolanaAdapter {
     this.wallet = ["gate", "solflare"].includes(this.name) ? Object.freeze(options.wallet) : options.wallet;
   }
   get provider() {
-    if (this.status !== ADAPTER_STATUS.NOT_READY && this.injectedProvider) {
+    if (this.status !== CONNECTOR_STATUS.NOT_READY && this.injectedProvider) {
       return this.injectedProvider;
     }
     return null;
   }
   get isWalletConnected() {
-    return !!(this.status === ADAPTER_STATUS.CONNECTED && this.wallet.accounts.length > 0);
+    return !!(this.status === 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({
       config: {
-        chainConfig: this.chainConfig
+        chain: chainConfig,
+        chains: this.coreOptions.chains
       }
     });
-    const providerHandler = new WalletStandardProviderHandler({
-      wallet: this.wallet,
-      getCurrentChain: () => getSolanaChainByChainConfig(this.chainConfig)
-    });
-    this.injectedProvider.setupProvider(providerHandler);
-    this.status = ADAPTER_STATUS.READY;
-    this.emit(ADAPTER_EVENTS.READY, this.name);
+    await this.injectedProvider.setupProvider(this.wallet, options.chainId);
+    this.status = CONNECTOR_STATUS.READY;
+    this.emit(CONNECTOR_EVENTS.READY, this.name);
     try {
-      log.debug("initializing solana injected adapter");
+      log.debug("initializing solana injected connector");
       if (options.autoConnect) {
         this.rehydrated = true;
-        await this.connect();
+        await this.connect({
+          chainId: options.chainId
+        });
       }
     } catch (error) {
       log.error("Failed to connect with cached solana injected provider", error);
-      this.emit(ADAPTER_EVENTS.ERRORED, error);
+      this.emit(CONNECTOR_EVENTS.ERRORED, error);
     }
   }
-  async connect() {
+  async connect({
+    chainId
+  }) {
     try {
       super.checkConnectionRequirements();
-      this.status = ADAPTER_STATUS.CONNECTING;
-      this.emit(ADAPTER_EVENTS.CONNECTING, {
-        adapter: this.name
+      const chainConfig = this.coreOptions.chains.find(x => x.chainId === chainId);
+      if (!chainConfig) throw WalletLoginError.connectionError("Chain config is not available");
+      this.status = CONNECTOR_STATUS.CONNECTING;
+      this.emit(CONNECTOR_EVENTS.CONNECTING, {
+        connector: this.name
       });
-      const chainName = getSolanaChainByChainConfig(this.chainConfig);
+      const chainName = getSolanaChainByChainConfig(chainConfig);
       if (!this.wallet.chains.find(chain => chain === chainName)) throw WalletLoginError.connectionError(`Chain ${chainName} not supported. Supported chains are ${this.wallet.chains.join(", ")}`);
       if (!this.isWalletConnected) {
         await this.wallet.features[StandardConnect].connect();
       }
       if (this.wallet.accounts.length === 0) throw WalletLoginError.connectionError();
-      this.status = ADAPTER_STATUS.CONNECTED;
-      this.emit(ADAPTER_EVENTS.CONNECTED, {
-        adapter: this.name,
+      this.status = CONNECTOR_STATUS.CONNECTED;
+      this.emit(CONNECTOR_EVENTS.CONNECTED, {
+        connector: this.name,
         reconnected: this.rehydrated,
         provider: this.provider
       });
       return this.provider;
     } catch (error) {
       // ready again to be connected
-      this.status = ADAPTER_STATUS.READY;
+      this.status = CONNECTOR_STATUS.READY;
       this.rehydrated = false;
-      this.emit(ADAPTER_EVENTS.ERRORED, error);
+      this.emit(CONNECTOR_EVENTS.ERRORED, error);
       throw error;
     }
   }
@@ -97,33 +103,24 @@ class WalletStandardAdapter extends BaseSolanaAdapter {
       var _this$wallet$features;
       await ((_this$wallet$features = this.wallet.features[StandardDisconnect]) === null || _this$wallet$features === void 0 ? void 0 : _this$wallet$features.disconnect());
       if (options.cleanup) {
-        this.status = ADAPTER_STATUS.NOT_READY;
+        this.status = CONNECTOR_STATUS.NOT_READY;
         this.injectedProvider = null;
       } else {
-        this.status = ADAPTER_STATUS.READY;
+        this.status = CONNECTOR_STATUS.READY;
       }
       await super.disconnect();
     } catch (error) {
-      this.emit(ADAPTER_EVENTS.ERRORED, WalletLoginError.disconnectionError(error === null || error === void 0 ? void 0 : error.message));
+      this.emit(CONNECTOR_EVENTS.ERRORED, WalletLoginError.disconnectionError(error === null || error === void 0 ? void 0 : error.message));
     }
   }
   async getUserInfo() {
     if (!this.isWalletConnected) throw 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.");
@@ -132,5 +129,16 @@ class WalletStandardAdapter extends BaseSolanaAdapter {
     throw new Error("Method Not implemented");
   }
 }
+const walletStandardConnector = wallet => {
+  return ({
+    coreOptions
+  }) => {
+    return new WalletStandardConnector({
+      name: normalizeWalletName(wallet.name),
+      wallet,
+      coreOptions
+    });
+  };
+};
 
-export { WalletStandardAdapter };
+export { WalletStandardConnector, walletStandardConnector };