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

package/dist/lib.cjs/{adapters/base-evm-adapter/baseEvmAdapter.js → connectors/base-evm-connector/baseEvmConnector.js}

@@ -1,25 +1,26 @@
 'use strict';
 
 var baseControllers = require('@toruslabs/base-controllers');
-var config = require('../../base/chain/config.js');
-var IChainInterface = require('../../base/chain/IChainInterface.js');
+var wsEmbed = require('@web3auth/ws-embed');
 var index = require('../../base/errors/index.js');
-var utils = require('../../base/adapter/utils.js');
-var baseAdapter = require('../../base/adapter/baseAdapter.js');
-var constants = require('../../base/adapter/constants.js');
+var baseConnector = require('../../base/connector/baseConnector.js');
+var constants = require('../../base/connector/constants.js');
+require('@web3auth/auth');
+var utils = require('../../base/connector/utils.js');
+require('../../base/loglevel.js');
+require('../../base/plugin/errors.js');
+require('../../base/plugin/IPlugin.js');
+require('@toruslabs/constants');
+require('@toruslabs/http-helpers');
+require('../../base/wallet/index.js');
 
-class BaseEvmAdapter extends baseAdapter.BaseAdapter {
-  async init(_) {
-    if (!this.chainConfig) this.chainConfig = config.getChainConfig(IChainInterface.CHAIN_NAMESPACES.EIP155, 1);
-  }
+class BaseEvmConnector extends baseConnector.BaseConnector {
+  async init(_) {}
   async authenticateUser() {
-    if (!this.provider || this.status !== constants.ADAPTER_STATUS.CONNECTED) throw index.WalletLoginError.notConnectedError();
-    const {
-      chainNamespace,
-      chainId
-    } = this.chainConfig;
+    if (!this.provider || this.status !== constants.CONNECTOR_STATUS.CONNECTED) throw index.WalletLoginError.notConnectedError();
+    if (!this.coreOptions) throw index.WalletInitializationError.invalidParams("Please initialize Web3Auth with valid options");
     const accounts = await this.provider.request({
-      method: "eth_accounts"
+      method: wsEmbed.EVM_METHOD_TYPES.GET_ACCOUNTS
     });
     if (accounts && accounts.length > 0) {
       const existingToken = utils.getSavedToken(accounts[0], this.name);
@@ -31,6 +32,14 @@ class BaseEvmAdapter extends baseAdapter.BaseAdapter {
           };
         }
       }
+      const chainId = await this.provider.request({
+        method: "eth_chainId"
+      });
+      const currentChainConfig = this.coreOptions.chains.find(x => x.chainId === chainId);
+      if (!currentChainConfig) throw index.WalletInitializationError.invalidParams("chainConfig is required before authentication");
+      const {
+        chainNamespace
+      } = currentChainConfig;
       const payload = {
         domain: window.location.origin,
         uri: window.location.href,
@@ -43,10 +52,10 @@ class BaseEvmAdapter extends baseAdapter.BaseAdapter {
       const challenge = await baseControllers.signChallenge(payload, chainNamespace);
       const hexChallenge = `0x${Buffer.from(challenge, "utf8").toString("hex")}`;
       const signedMessage = await this.provider.request({
-        method: "personal_sign",
+        method: wsEmbed.EVM_METHOD_TYPES.PERSONAL_SIGN,
         params: [hexChallenge, accounts[0]]
       });
-      const idToken = await baseControllers.verifySignedChallenge(chainNamespace, signedMessage, challenge, this.name, this.sessionTime, this.clientId, this.web3AuthNetwork);
+      const idToken = await baseControllers.verifySignedChallenge(chainNamespace, signedMessage, challenge, this.name, this.coreOptions.sessionTime, this.coreOptions.clientId, this.coreOptions.web3AuthNetwork);
       utils.saveToken(accounts[0], this.name, idToken);
       return {
         idToken
@@ -65,8 +74,8 @@ class BaseEvmAdapter extends baseAdapter.BaseAdapter {
   }
   async disconnect() {
     this.rehydrated = false;
-    this.emit(constants.ADAPTER_EVENTS.DISCONNECTED);
+    this.emit(constants.CONNECTOR_EVENTS.DISCONNECTED);
   }
 }
 
-exports.BaseEvmAdapter = BaseEvmAdapter;
+exports.BaseEvmConnector = BaseEvmConnector;

package/dist/lib.cjs/connectors/base-solana-connector/baseSolanaConnector.js

@@ -0,0 +1,83 @@
+'use strict';
+
+var baseControllers = require('@toruslabs/base-controllers');
+var wsEmbed = require('@web3auth/ws-embed');
+var index = require('../../base/errors/index.js');
+var baseConnector = require('../../base/connector/baseConnector.js');
+var constants = require('../../base/connector/constants.js');
+require('@web3auth/auth');
+var utils = require('../../base/connector/utils.js');
+require('../../base/loglevel.js');
+require('../../base/plugin/errors.js');
+require('../../base/plugin/IPlugin.js');
+require('@toruslabs/constants');
+require('@toruslabs/http-helpers');
+require('../../base/wallet/index.js');
+
+class BaseSolanaConnector extends baseConnector.BaseConnector {
+  async init(_) {}
+  async authenticateUser() {
+    if (!this.provider || this.status !== constants.CONNECTOR_STATUS.CONNECTED) throw index.WalletLoginError.notConnectedError();
+    if (!this.coreOptions) throw index.WalletInitializationError.invalidParams("Please initialize Web3Auth with a valid options");
+    const accounts = await this.provider.request({
+      method: wsEmbed.SOLANA_METHOD_TYPES.GET_ACCOUNTS
+    });
+    if (accounts && accounts.length > 0) {
+      const existingToken = utils.getSavedToken(accounts[0], this.name);
+      if (existingToken) {
+        const isExpired = utils.checkIfTokenIsExpired(existingToken);
+        if (!isExpired) {
+          return {
+            idToken: existingToken
+          };
+        }
+      }
+      const chainId = await this.provider.request({
+        method: "solana_chainId"
+      });
+      const currentChainConfig = this.coreOptions.chains.find(x => x.chainId === chainId);
+      if (!currentChainConfig) throw index.WalletInitializationError.invalidParams("chainConfig is required before authentication");
+      const {
+        chainNamespace
+      } = currentChainConfig;
+      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 baseControllers.signChallenge(payload, chainNamespace);
+      const signedMessage = await this.provider.request({
+        method: wsEmbed.SOLANA_METHOD_TYPES.SIGN_MESSAGE,
+        params: {
+          data: challenge,
+          display: "utf8"
+        }
+      });
+      const idToken = await baseControllers.verifySignedChallenge(chainNamespace, signedMessage, challenge, this.name, this.coreOptions.sessionTime, this.coreOptions.clientId, this.coreOptions.web3AuthNetwork);
+      utils.saveToken(accounts[0], this.name, idToken);
+      return {
+        idToken
+      };
+    }
+    throw index.WalletLoginError.notConnectedError("Not connected with wallet, Please login/connect first");
+  }
+  async disconnectSession() {
+    super.checkDisconnectionRequirements();
+    const accounts = await this.provider.request({
+      method: wsEmbed.SOLANA_METHOD_TYPES.GET_ACCOUNTS
+    });
+    if (accounts && accounts.length > 0) {
+      utils.clearToken(accounts[0], this.name);
+    }
+  }
+  async disconnect() {
+    this.rehydrated = false;
+    this.emit(constants.CONNECTOR_EVENTS.DISCONNECTED);
+  }
+}
+
+exports.BaseSolanaConnector = BaseSolanaConnector;

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

@@ -0,0 +1,159 @@
+'use strict';
+
+var _objectSpread = require('@babel/runtime/helpers/objectSpread2');
+var _defineProperty = require('@babel/runtime/helpers/defineProperty');
+var walletSdk = require('@coinbase/wallet-sdk');
+var index$1 = require('../../base/errors/index.js');
+var IChainInterface = require('../../base/chain/IChainInterface.js');
+require('@web3auth/auth');
+var index = require('../../base/wallet/index.js');
+var constants = require('../../base/connector/constants.js');
+require('jwt-decode');
+require('../../base/loglevel.js');
+require('../../base/plugin/errors.js');
+require('../../base/plugin/IPlugin.js');
+var baseControllers = require('@toruslabs/base-controllers');
+require('@toruslabs/constants');
+require('@toruslabs/http-helpers');
+var baseEvmConnector = require('../base-evm-connector/baseEvmConnector.js');
+
+class CoinbaseConnector extends baseEvmConnector.BaseEvmConnector {
+  constructor(connectorOptions) {
+    super(connectorOptions);
+    _defineProperty(this, "connectorNamespace", IChainInterface.CONNECTOR_NAMESPACES.EIP155);
+    _defineProperty(this, "currentChainNamespace", baseControllers.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}

@@ -1,27 +1,34 @@
 'use strict';
 
 var _defineProperty = require('@babel/runtime/helpers/defineProperty');
-var IChainInterface = require('../../base/chain/IChainInterface.js');
 var index = require('../../base/errors/index.js');
+var IChainInterface = require('../../base/chain/IChainInterface.js');
+require('@web3auth/auth');
+require('../../base/wallet/index.js');
+var constants = require('../../base/connector/constants.js');
+require('jwt-decode');
 var loglevel = require('../../base/loglevel.js');
-var baseEvmAdapter = require('../base-evm-adapter/baseEvmAdapter.js');
-var constants = require('../../base/adapter/constants.js');
+require('../../base/plugin/errors.js');
+require('../../base/plugin/IPlugin.js');
+var utils = require('../../base/utils.js');
+var baseEvmConnector = require('../base-evm-connector/baseEvmConnector.js');
+var baseControllers = require('@toruslabs/base-controllers');
 
-class InjectedEvmAdapter extends baseEvmAdapter.BaseEvmAdapter {
+class InjectedEvmConnector extends baseEvmConnector.BaseEvmConnector {
   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, "connectorNamespace", IChainInterface.CONNECTOR_NAMESPACES.EIP155);
+    _defineProperty(this, "currentChainNamespace", baseControllers.CHAIN_NAMESPACES.EIP155);
+    _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 +36,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);
-        } catch (error) {
-          await this.addChain(this.chainConfig, true);
-          await this.switchChain(this.chainConfig, true);
+          await this.switchChain(chainConfig, true);
+        } catch {
+          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 +89,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`);
     }
@@ -102,23 +117,24 @@ class InjectedEvmAdapter extends baseEvmAdapter.BaseEvmAdapter {
           eth_accounts: {}
         }]
       });
-    } catch (error) {}
+    } catch {
+      // ignore 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 +150,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 +160,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 +168,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;