@web3auth/no-modal 11.1.0 → 11.3.0

package/dist/lib.cjs/base/connector/baseConnector.js

@@ -128,17 +128,28 @@ class BaseConnector extends auth.SafeEventEmitter {
     return cached;
   }
   async verifyAndAuthorize(params) {
-    const tokens = await baseControllers.verifySignedChallenge({
-      chainNamespace: params.chainNamespace,
-      signedMessage: params.signedMessage,
-      challenge: params.challenge,
-      connector: this.name,
-      authServer: params.authServer,
-      web3AuthClientId: this.coreOptions.clientId,
-      web3AuthNetwork: this.coreOptions.web3AuthNetwork,
-      sessionTimeout: this.coreOptions.sessionTime,
-      deviceInfo: baseControllers.getDeviceInfo()
-    });
+    let tokens;
+    try {
+      tokens = await baseControllers.verifySignedChallenge({
+        chainNamespace: params.chainNamespace,
+        signedMessage: params.signedMessage,
+        challenge: params.challenge,
+        connector: this.name,
+        authServer: params.authServer,
+        web3AuthClientId: this.coreOptions.clientId,
+        web3AuthNetwork: this.coreOptions.web3AuthNetwork,
+        sessionTimeout: this.coreOptions.sessionTime,
+        deviceInfo: baseControllers.getDeviceInfo()
+      });
+    } catch (error) {
+      if (error instanceof Response && error.status === 401) {
+        const body = await error.clone().json().catch(() => ({}));
+        if (body.message === "ACCESS_CONTROL_DENIED") {
+          throw index$1.WalletLoginError.userBlocked("User is blocked by the application", error);
+        }
+      }
+      throw error;
+    }
     await this.saveAuthTokenInfo(tokens);
     const tokenInfo = {
       idToken: tokens.idToken,
@@ -152,6 +163,26 @@ class BaseConnector extends auth.SafeEventEmitter {
     });
     return tokenInfo;
   }
+  async authorizeOrDisconnect(getAuthTokenInfo, chainId) {
+    if (!getAuthTokenInfo) return;
+    try {
+      await this.getAuthTokenInfo(chainId);
+    } catch (error) {
+      loglevel.log.error("Authorization failed after connect; disconnecting wallet to keep state consistent", error);
+      const wasRehydrated = this.rehydrated;
+      try {
+        // getAuthTokenInfo moved status to AUTHORIZING; restore CONNECTED so disconnect requirements pass.
+        if (!this.connected) this.status = constants.CONNECTOR_STATUS.CONNECTED;
+        await this.disconnect();
+      } catch (disconnectError) {
+        loglevel.log.error("Failed to disconnect wallet after authorization error", disconnectError);
+      } finally {
+        // disconnect() resets rehydrated=false; restore so caller catch emits the right event.
+        this.rehydrated = wasRehydrated;
+      }
+      throw error;
+    }
+  }
   async clearWalletSession() {
     if (!this.authSessionManager) return;
     try {

package/dist/lib.cjs/base/errors/index.js

@@ -159,6 +159,9 @@ class WalletLoginError extends Web3AuthError {
   static userNotLoggedIn(extraMessage = "", cause) {
     return WalletLoginError.fromCode(5119, extraMessage, cause);
   }
+  static userBlocked(extraMessage = "", cause) {
+    return WalletLoginError.fromCode(5120, extraMessage, cause);
+  }
 }
 _defineProperty(WalletLoginError, "messages", {
   5000: "Custom",
@@ -170,7 +173,8 @@ _defineProperty(WalletLoginError, "messages", {
   5116: "Chain config has not been added. Please add the chain config before calling switchChain",
   5117: "Unsupported operation",
   5118: "useSFAKey flag is enabled but SFA key is not available",
-  5119: "User not logged in."
+  5119: "User not logged in.",
+  5120: "User is blocked by the application"
 });
 class WalletOperationsError extends Web3AuthError {
   constructor(code, message, cause) {

package/dist/lib.cjs/base/utils.js

@@ -145,7 +145,7 @@ const getWalletServicesAnalyticsProperties = walletServicesConfig => {
     ws_default_portfolio: walletServicesConfig === null || walletServicesConfig === void 0 || (_walletServicesConfig10 = walletServicesConfig.whiteLabel) === null || _walletServicesConfig10 === void 0 ? void 0 : _walletServicesConfig10.defaultPortfolio
   };
 };
-const sdkVersion = "11.1.0";
+const sdkVersion = "11.3.0";
 const getErrorAnalyticsProperties = error => {
   try {
     const code = error instanceof index.Web3AuthError ? error.code : error === null || error === void 0 ? void 0 : error.code;

package/dist/lib.cjs/base/wallet/index.js

@@ -10,13 +10,15 @@ const MULTI_CHAIN_CONNECTORS = {
 };
 const SOLANA_CONNECTORS = _objectSpread({}, MULTI_CHAIN_CONNECTORS);
 const EVM_CONNECTORS = _objectSpread({
-  COINBASE: "coinbase"
+  COINBASE: "coinbase",
+  BASE_ACCOUNT: "base-account"
 }, MULTI_CHAIN_CONNECTORS);
 const WALLET_CONNECTORS = _objectSpread(_objectSpread({}, EVM_CONNECTORS), SOLANA_CONNECTORS);
 const CONNECTOR_NAMES = {
   [MULTI_CHAIN_CONNECTORS.AUTH]: "Auth",
   [MULTI_CHAIN_CONNECTORS.WALLET_CONNECT_V2]: "Wallet Connect v2",
   [EVM_CONNECTORS.COINBASE]: "Coinbase Smart Wallet",
+  [EVM_CONNECTORS.BASE_ACCOUNT]: "Base Account",
   [EVM_CONNECTORS.METAMASK]: "MetaMask"
 };
 const WEB3AUTH_ICON = `data:image/svg+xml;base64,PHN2ZyB3aWR0aD0iOTYiIGhlaWdodD0iOTciIHZpZXdCb3g9IjAgMCA5NiA5NyIgZmlsbD0ibm9uZSIgeG1sbnM9Imh0dHA6Ly93d3cudzMub3JnLzIwMDAvc3ZnIj4KPHBhdGggZmlsbC1ydWxlPSJldmVub2RkIiBjbGlwLXJ1bGU9ImV2ZW5vZGQiIGQ9Ik00NC4wMzQ2IDczLjI2MjRDNDMuODU5NSA3My45MTU5IDQ0LjM1MTkgNzQuNTU3NiA0NS4wMjg1IDc0LjU1NzZINTAuOTUzOUM1MS42MzA0IDc0LjU1NzYgNTIuMTIyOSA3My45MTU5IDUxLjk0NzggNzMuMjYyNEw0OC45ODUgNjIuMjA1M0M0OC43MTI2IDYxLjE4ODUgNDcuMjY5OCA2MS4xODg1IDQ2Ljk5NzMgNjIuMjA1M0w0NC4wMzQ2IDczLjI2MjRaIiBmaWxsPSIjMDM2NEZGIi8+CjxwYXRoIGZpbGwtcnVsZT0iZXZlbm9kZCIgY2xpcC1ydWxlPSJldmVub2RkIiBkPSJNMzguMTM0NSA4MC4zMzk2QzM3LjY4MDcgODIuMDMzIDM2LjE0NjEgODMuMjEwNiAzNC4zOTI5IDgzLjIxMDZIMjYuMzcyNkMyMy44MjU2IDgzLjIxMDYgMjEuOTcxOSA4MC43OTQ3IDIyLjYzMTEgNzguMzM0NUwzOS4wODQ0IDE2LjkyOTlDMzkuNTgwNyAxNS4wNzc3IDQxLjI1OTEgMTMuNzg5NyA0My4xNzY3IDEzLjc4OTdINTIuNzIxOUM1NC42Mzk0IDEzLjc4OTcgNTYuMzE3OSAxNS4wNzc3IDU2LjgxNDIgMTYuOTI5OUw3My4yNjc1IDc4LjMzNDVDNzMuOTI2NyA4MC43OTQ3IDcyLjA3MjkgODMuMjEwNiA2OS41MjYgODMuMjEwNkg2MS41MDU2QzU5Ljc1MjQgODMuMjEwNiA1OC4yMTc4IDgyLjAzMyA1Ny43NjQxIDgwLjMzOTZMNDkuNzYxNiA1MC40NzM4QzQ5LjI2NDggNDguNjE5NyA0Ni42MzM4IDQ4LjYxOTcgNDYuMTM3IDUwLjQ3MzhMMzguMTM0NSA4MC4zMzk2WiIgZmlsbD0iIzAzNjRGRiIvPgo8cGF0aCBmaWxsLXJ1bGU9ImV2ZW5vZGQiIGNsaXAtcnVsZT0iZXZlbm9kZCIgZD0iTTc4LjQ3NzQgNjguNzY4NUM3Ny45NjQ2IDcwLjY4MjQgNzUuMjQ4NyA3MC42ODI0IDc0LjczNTkgNjguNzY4NUw2OC43NjI2IDQ2LjQ3NTlDNjguNjQ3MSA0Ni4wNDQ5IDY4LjY0NzEgNDUuNTkxIDY4Ljc2MjYgNDUuMTZMNzYuMzc1MSAxNi43NUM3Ni44NDMgMTUuMDAzNiA3OC40MjU2IDEzLjc4OTMgODAuMjMzNSAxMy43ODkzSDg4LjAwMzJDOTAuNjI5OCAxMy43ODkzIDkyLjU0MTUgMTYuMjgwNyA5MS44NjE3IDE4LjgxNzhMNzguNDc3NCA2OC43Njg1Wk0yNy4yMjc0IDQ2LjQzODdDMjcuMzQyOSA0Ni4wMDc3IDI3LjM0MjkgNDUuNTUzOSAyNy4yMjc0IDQ1LjEyMjhMMTkuNjI0OSAxNi43NUMxOS4xNTcgMTUuMDAzNiAxNy41NzQ0IDEzLjc4OTMgMTUuNzY2NSAxMy43ODkzSDcuOTk2NzdDNS4zNzAyMyAxMy43ODkzIDMuNDU4NTEgMTYuMjgwNyA0LjEzODMxIDE4LjgxNzhMMTcuNTEyNiA2OC43MzEzQzE4LjAyNTQgNzAuNjQ1MiAyMC43NDEzIDcwLjY0NTIgMjEuMjU0MSA2OC43MzEzTDI3LjIyNzQgNDYuNDM4N1oiIGZpbGw9IiMwMzY0RkYiLz4KPC9zdmc+Cg==`;

package/dist/lib.cjs/connectors/auth-connector/authConnector.js

@@ -209,7 +209,8 @@ class AuthConnector extends baseConnector.BaseConnector {
       return {
         ethereumProvider: this.provider,
         solanaWallet: this._solanaWallet,
-        connectorName: this.name
+        connectorName: this.name,
+        connectorNamespace: this.connectorNamespace
       };
     } catch (error) {
       var _error$message;
@@ -816,6 +817,7 @@ class AuthConnector extends baseConnector.BaseConnector {
       }
       throw index.WalletLoginError.sfaKeyNotFound("This typically occurs when the authentication method used does not provide SFA keys (e.g., default auth connection).");
     }
+    const connectorNamespace = this.connectorNamespace;
     // setup WS embed if chainNamespace is EIP155 or SOLANA
     if (chainNamespace === baseControllers.CHAIN_NAMESPACES.EIP155 || chainNamespace === baseControllers.CHAIN_NAMESPACES.SOLANA) {
       // wait for ws embed instance to be ready.
@@ -841,7 +843,8 @@ class AuthConnector extends baseConnector.BaseConnector {
             connectorName: index$1.WALLET_CONNECTORS.AUTH,
             reconnected: this.rehydrated,
             ethereumProvider: this.provider,
-            solanaWallet: this._solanaWallet
+            solanaWallet: this._solanaWallet,
+            connectorNamespace
           });
           if (params.getAuthTokenInfo) {
             await this.getAuthTokenInfo();
@@ -858,7 +861,8 @@ class AuthConnector extends baseConnector.BaseConnector {
           connectorName: index$1.WALLET_CONNECTORS.AUTH,
           ethereumProvider: this.provider,
           solanaWallet: this._solanaWallet,
-          reconnected: this.rehydrated
+          reconnected: this.rehydrated,
+          connectorNamespace
         });
       }
     }
@@ -959,7 +963,12 @@ class AuthConnector extends baseConnector.BaseConnector {
         if (error instanceof index.Web3AuthError) {
           throw error;
         }
-        reject(index.WalletLoginError.connectionError(error instanceof Error ? error.message : error || "Failed to login with social"));
+        const errorMessage = error instanceof Error ? error.message : error;
+        if (errorMessage === "Access control denied") {
+          reject(index.WalletLoginError.userBlocked(errorMessage, error));
+          return;
+        }
+        reject(index.WalletLoginError.connectionError(errorMessage || "Failed to login with social"));
       });
     });
   }

package/dist/lib.cjs/connectors/base-account-connector/baseAccountConnector.js

@@ -0,0 +1,211 @@
+'use strict';
+
+var _objectSpread = require('@babel/runtime/helpers/objectSpread2');
+var _defineProperty = require('@babel/runtime/helpers/defineProperty');
+require('@segment/analytics-next');
+require('../../base/loglevel.js');
+var IChainInterface = require('../../base/chain/IChainInterface.js');
+var baseControllers = require('@toruslabs/base-controllers');
+require('@toruslabs/session-manager');
+require('@web3auth/auth');
+var index$1 = require('../../base/errors/index.js');
+require('@toruslabs/constants');
+require('@toruslabs/http-helpers');
+require('../../base/constants.js');
+var index = require('../../base/wallet/index.js');
+require('../../base/connector/connectorStatus.js');
+var constants = require('../../base/connector/constants.js');
+require('jwt-decode');
+require('../../base/plugin/errors.js');
+require('../../base/plugin/IPlugin.js');
+var baseEvmConnector = require('../base-evm-connector/baseEvmConnector.js');
+var utils = require('../utils.js');
+
+class BaseAccountConnector 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.BASE_ACCOUNT);
+    _defineProperty(this, "status", constants.CONNECTOR_STATUS.NOT_READY);
+    _defineProperty(this, "baseAccountProvider", null);
+    _defineProperty(this, "baseAccountOptions", {
+      appName: "Web3Auth"
+    });
+    this.baseAccountOptions = _objectSpread(_objectSpread({}, this.baseAccountOptions), connectorOptions.connectorSettings);
+  }
+  get provider() {
+    if (this.status !== constants.CONNECTOR_STATUS.NOT_READY && this.baseAccountProvider) {
+      return this.baseAccountProvider;
+    }
+    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 {
+      createBaseAccountSDK
+    } = await import('@base-org/account');
+    let appName = this.baseAccountOptions.appName || "Web3Auth";
+    let appLogoUrl = this.baseAccountOptions.appLogoUrl || "";
+    if (typeof window !== "undefined") {
+      if (!this.baseAccountOptions.appName) {
+        appName = utils.getSiteName(window) || "Web3Auth";
+      }
+      if (!this.baseAccountOptions.appLogoUrl) {
+        appLogoUrl = (await utils.getSiteIcon(window)) || "";
+      }
+    }
+    const appChainIds = this.coreOptions.chains.filter(x => x.chainNamespace === baseControllers.CHAIN_NAMESPACES.EIP155).map(x => Number.parseInt(x.chainId, 16));
+    const sdk = createBaseAccountSDK(_objectSpread(_objectSpread({}, this.baseAccountOptions), {}, {
+      appName,
+      appLogoUrl: appLogoUrl || null,
+      appChainIds: this.baseAccountOptions.appChainIds || appChainIds
+    }));
+    this.baseAccountProvider = sdk.getProvider();
+    this.status = constants.CONNECTOR_STATUS.READY;
+    this.emit(constants.CONNECTOR_EVENTS.READY, index.WALLET_CONNECTORS.BASE_ACCOUNT);
+    try {
+      if (options.autoConnect) {
+        this.rehydrated = true;
+        const connection = await this.connect({
+          chainId: options.chainId,
+          getAuthTokenInfo: options.getAuthTokenInfo
+        });
+        if (!connection) {
+          this.rehydrated = false;
+          throw index$1.WalletLoginError.connectionError("Failed to rehydrate.");
+        }
+      }
+    } catch (error) {
+      this.emit(constants.CONNECTOR_EVENTS.REHYDRATION_ERROR, error);
+    }
+  }
+  async connect({
+    chainId,
+    getAuthTokenInfo
+  }) {
+    super.checkConnectionRequirements();
+    if (!this.baseAccountProvider) 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.BASE_ACCOUNT
+    });
+    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.baseAccountProvider.request({
+        method: "eth_requestAccounts"
+      });
+      const currentChainId = await this.baseAccountProvider.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", () => {
+        this.disconnect();
+      });
+      this.emit(constants.CONNECTOR_EVENTS.CONNECTED, {
+        connectorName: index.WALLET_CONNECTORS.BASE_ACCOUNT,
+        reconnected: this.rehydrated,
+        ethereumProvider: this.provider,
+        solanaWallet: null,
+        connectorNamespace: this.connectorNamespace
+      });
+      await this.authorizeOrDisconnect(getAuthTokenInfo);
+      return {
+        ethereumProvider: this.provider,
+        solanaWallet: null,
+        connectorName: this.name,
+        connectorNamespace: this.connectorNamespace
+      };
+    } catch (error) {
+      this.status = constants.CONNECTOR_STATUS.READY;
+      if (!this.rehydrated) this.emit(constants.CONNECTOR_EVENTS.ERRORED, error);
+      this.rehydrated = false;
+      if (error instanceof index$1.Web3AuthError) throw error;
+      throw index$1.WalletLoginError.connectionError("Failed to login with Base Account", 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.baseAccountProvider = null;
+    } else {
+      this.status = constants.CONNECTOR_STATUS.READY;
+    }
+    await super.disconnect();
+  }
+  async getUserInfo() {
+    if (!this.canAuthorize) throw index$1.WalletLoginError.notConnectedError("Not connected with wallet, Please login/connect first");
+    return {};
+  }
+  async switchChain(params, init = false) {
+    super.checkSwitchChainRequirements(params, init);
+    try {
+      var _this$baseAccountProv;
+      await ((_this$baseAccountProv = this.baseAccountProvider) === null || _this$baseAccountProv === void 0 ? void 0 : _this$baseAccountProv.request({
+        method: "wallet_switchEthereumChain",
+        params: [{
+          chainId: params.chainId
+        }]
+      }));
+    } catch (switchError) {
+      if (switchError.code === 4902) {
+        var _this$baseAccountProv2;
+        const chainConfig = this.coreOptions.chains.find(x => x.chainId === params.chainId);
+        if (!chainConfig) throw index$1.WalletLoginError.connectionError("Chain config is not available");
+        await ((_this$baseAccountProv2 = this.baseAccountProvider) === null || _this$baseAccountProv2 === void 0 ? void 0 : _this$baseAccountProv2.request({
+          method: "wallet_addEthereumChain",
+          params: [{
+            chainId: chainConfig.chainId,
+            rpcUrls: [chainConfig.rpcTarget],
+            chainName: chainConfig.displayName,
+            nativeCurrency: {
+              name: chainConfig.tickerName,
+              symbol: chainConfig.ticker,
+              decimals: chainConfig.decimals || 18
+            },
+            blockExplorerUrls: [chainConfig.blockExplorerUrl],
+            iconUrls: [chainConfig.logo]
+          }]
+        }));
+        return;
+      }
+      throw switchError;
+    }
+  }
+  async enableMFA() {
+    throw new Error("Method Not implemented");
+  }
+  async manageMFA() {
+    throw new Error("Method Not implemented");
+  }
+}
+const baseAccountConnector = params => {
+  return ({
+    coreOptions
+  }) => {
+    return new BaseAccountConnector({
+      connectorSettings: params,
+      coreOptions
+    });
+  };
+};
+
+exports.baseAccountConnector = baseAccountConnector;

package/dist/lib.cjs/connectors/base-account-connector/index.js

@@ -0,0 +1,7 @@
+'use strict';
+
+var baseAccountConnector = require('./baseAccountConnector.js');
+
+
+
+exports.baseAccountConnector = baseAccountConnector.baseAccountConnector;

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

@@ -112,15 +112,15 @@ class CoinbaseConnector extends baseEvmConnector.BaseEvmConnector {
         connectorName: index.WALLET_CONNECTORS.COINBASE,
         reconnected: this.rehydrated,
         ethereumProvider: this.provider,
-        solanaWallet: null
+        solanaWallet: null,
+        connectorNamespace: this.connectorNamespace
       });
-      if (getAuthTokenInfo) {
-        await this.getAuthTokenInfo();
-      }
+      await this.authorizeOrDisconnect(getAuthTokenInfo);
       return {
         ethereumProvider: this.provider,
         solanaWallet: null,
-        connectorName: this.name
+        connectorName: this.name,
+        connectorNamespace: this.connectorNamespace
       };
     } catch (error) {
       // ready again to be connected

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

@@ -101,19 +101,20 @@ class InjectedEvmConnector extends baseEvmConnector.BaseEvmConnector {
         }
       };
       this.injectedProvider.on("accountsChanged", accountDisconnectHandler);
+      const connectorNamespace = this.connectorNamespace;
       this.emit(constants.CONNECTOR_EVENTS.CONNECTED, {
         connectorName: this.name,
         reconnected: this.rehydrated,
         ethereumProvider: this.injectedProvider,
-        solanaWallet: null
+        solanaWallet: null,
+        connectorNamespace
       });
-      if (getAuthTokenInfo) {
-        await this.getAuthTokenInfo();
-      }
+      await this.authorizeOrDisconnect(getAuthTokenInfo);
       return {
         ethereumProvider: this.injectedProvider,
         solanaWallet: null,
-        connectorName: this.name
+        connectorName: this.name,
+        connectorNamespace
       };
     } catch (error) {
       // ready again to be connected

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

@@ -88,19 +88,20 @@ class WalletStandardConnector extends baseSolanaConnector.BaseSolanaConnector {
       }
       if (this.wallet.accounts.length === 0) throw index.WalletLoginError.connectionError();
       this.status = constants.CONNECTOR_STATUS.CONNECTED;
+      const connectorNamespace = this.connectorNamespace;
       this.emit(constants.CONNECTOR_EVENTS.CONNECTED, {
         connectorName: this.name,
         reconnected: this.rehydrated,
         ethereumProvider: null,
-        solanaWallet: this.solanaWallet
+        solanaWallet: this.solanaWallet,
+        connectorNamespace
       });
-      if (getAuthTokenInfo) {
-        await this.getAuthTokenInfo();
-      }
+      await this.authorizeOrDisconnect(getAuthTokenInfo);
       return {
         ethereumProvider: null,
         solanaWallet: this.solanaWallet,
-        connectorName: this.name
+        connectorName: this.name,
+        connectorNamespace
       };
     } catch (error) {
       // ready again to be connected