@web3auth/no-modal 11.0.0-beta.0 → 11.0.0-beta.1

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

@@ -1,21 +1,23 @@
 import _objectSpread from '@babel/runtime/helpers/objectSpread2';
 import _defineProperty from '@babel/runtime/helpers/defineProperty';
 import { CITADEL_SERVER_MAP } from '@toruslabs/constants';
-import { put } from '@toruslabs/http-helpers';
+import { get, put } from '@toruslabs/http-helpers';
 import { SecurePubSub } from '@toruslabs/secure-pub-sub';
 import { BUILD_ENV, UX_MODE, Auth, SDK_MODE, SUPPORTED_KEY_CURVES, generateRecordId, version, createHandler, PopupHandler, getUserId } from '@web3auth/auth';
 import { WS_EMBED_LOGIN_MODE } from '@web3auth/ws-embed';
 import deepmerge from 'deepmerge';
 import { generateNonce, parseToken } from '../utils.js';
 import { AuthSolanaWallet } from './authSolanaWallet.js';
-import { BaseConnector } from '../../base/connector/baseConnector.js';
+import { WalletLoginError, WalletInitializationError, Web3AuthError, AccountLinkingError } from '../../base/errors/index.js';
 import { WALLET_CONNECTORS } from '../../base/wallet/index.js';
+import { BaseConnector } from '../../base/connector/baseConnector.js';
 import { CONNECTOR_NAMESPACES } from '../../base/chain/IChainInterface.js';
 import { CONNECTOR_CATEGORY, CONNECTOR_STATUS, CONNECTOR_EVENTS } from '../../base/connector/constants.js';
-import { WalletInitializationError, WalletLoginError, Web3AuthError } from '../../base/errors/index.js';
+import { Analytics, ANALYTICS_EVENTS } from '../../base/analytics.js';
 import { log } from '../../base/loglevel.js';
-import { getCaipChainId } from '../../base/utils.js';
+import { citadelServerUrl, getCaipChainId, getErrorAnalyticsProperties, parseChainNamespaceFromCitadelResponse } from '../../base/utils.js';
 import { CONNECTED_STATUSES } from '../../base/connector/connectorStatus.js';
+import { makeAccountLinkingRequest, makeAccountUnlinkingRequest } from '../../account-linking/rest.js';
 import { CHAIN_NAMESPACES, cloneDeep } from '@toruslabs/base-controllers';
 
 class AuthConnector extends BaseConnector {
@@ -36,6 +38,7 @@ class AuthConnector extends BaseConnector {
     _defineProperty(this, "authConnectionConfig", []);
     _defineProperty(this, "wsEmbedInstancePromise", null);
     _defineProperty(this, "_solanaWallet", null);
+    _defineProperty(this, "analytics", void 0);
     this.authOptions = params.connectorSettings;
     this.loginSettings = params.loginSettings || {
       authConnection: ""
@@ -44,6 +47,7 @@ class AuthConnector extends BaseConnector {
       loginMode: WS_EMBED_LOGIN_MODE.PLUGIN
     };
     this.authConnectionConfig = params.authConnectionConfig || [];
+    this.analytics = params.analytics || new Analytics();
   }
   get provider() {
     if (this.status !== CONNECTOR_STATUS.NOT_READY) {
@@ -245,7 +249,9 @@ class AuthConnector extends BaseConnector {
     }
     this.rehydrated = false;
     this._solanaWallet = null;
-    this.emit(CONNECTOR_EVENTS.DISCONNECTED);
+    this.emit(CONNECTOR_EVENTS.DISCONNECTED, {
+      connector: WALLET_CONNECTORS.AUTH
+    });
   }
   async getAuthTokenInfo() {
     if (!this.canAuthorize) throw WalletLoginError.notConnectedError("Not connected with wallet, Please login/connect first");
@@ -273,8 +279,24 @@ class AuthConnector extends BaseConnector {
   async getUserInfo() {
     if (!this.canAuthorize) throw WalletLoginError.notConnectedError("Not connected with wallet");
     if (!this.authInstance) throw WalletInitializationError.notReady("authInstance is not ready");
-    const userInfo = this.authInstance.getUserInfo();
-    return userInfo;
+    const [userInfo, linkedAccounts] = await Promise.all([this.authInstance.getUserInfo(), this.getLinkedAccounts()]);
+    return _objectSpread(_objectSpread({}, userInfo), {}, {
+      linkedAccounts
+    });
+  }
+  async getLinkedAccounts() {
+    const accessToken = await this.authInstance.authSessionManager.getAccessToken();
+    if (!accessToken) throw WalletLoginError.connectionError("Could not obtain an access token from the current AUTH session.");
+    const citadelUserInfo = await get(`${citadelServerUrl(this.coreOptions.authBuildEnv)}/v1/user`, {
+      headers: {
+        Authorization: `Bearer ${accessToken}`
+      }
+    });
+    const linkedAccounts = (citadelUserInfo === null || citadelUserInfo === void 0 ? void 0 : citadelUserInfo.accounts) || [];
+    return linkedAccounts.map(account => _objectSpread(_objectSpread({}, account), {}, {
+      // by default, the primary account is the active account
+      active: account.isPrimary
+    }));
   }
   async switchChain(params, init = false) {
     super.checkSwitchChainRequirements(params, init);
@@ -327,6 +349,347 @@ class AuthConnector extends BaseConnector {
     });
     return providerConfig;
   }
+  async generateChallengeAndSign() {
+    // we do not support this for auth connector, as of now. since auth login returns a valid idToken
+    throw new Error("Not implemented");
+  }
+  async switchAccount(account, context) {
+    if (!CONNECTED_STATUSES.includes(this.status)) {
+      throw WalletLoginError.notConnectedError("No wallet is connected. Connect with AUTH before switching accounts.");
+    }
+    try {
+      var _userInfo$linkedAccou;
+      const userInfo = await this.getUserInfo();
+      const linkedAccounts = (_userInfo$linkedAccou = userInfo.linkedAccounts) !== null && _userInfo$linkedAccou !== void 0 ? _userInfo$linkedAccou : [];
+      const targetAccount = linkedAccounts.find(candidate => candidate.id === account.id);
+      if (!targetAccount) {
+        throw AccountLinkingError.requestFailed(`No connected wallet matches account id "${account.id}". Refresh user info and try again.`);
+      }
+      const currentActiveAccount = context.activeAccount;
+      const isTargetAlreadyActive = currentActiveAccount ? currentActiveAccount.id === targetAccount.id : targetAccount.isPrimary;
+      if (isTargetAlreadyActive) {
+        return;
+      }
+      this.analytics.track(ANALYTICS_EVENTS.ACCOUNT_SWITCH_STARTED, this.getSwitchAccountTrackData(targetAccount));
+      if (targetAccount.connector === WALLET_CONNECTORS.AUTH && targetAccount.isPrimary) {
+        var _this$provider$chainI, _this$provider;
+        const activeChainId = this.getChainIdForLinkedAccount(targetAccount, (_this$provider$chainI = (_this$provider = this.provider) === null || _this$provider === void 0 ? void 0 : _this$provider.chainId) !== null && _this$provider$chainI !== void 0 ? _this$provider$chainI : context.currentChainId);
+        const ethereumProvider = this.provider;
+        const solanaWallet = this.solanaWallet;
+        if (!ethereumProvider && !solanaWallet) {
+          throw AccountLinkingError.requestFailed("Failed to restore the primary AUTH session for account switch.");
+        }
+        return {
+          kind: "primary",
+          targetAccount,
+          activeAccount: null,
+          activeChainId,
+          connectorName: this.name,
+          connectorNamespace: this.connectorNamespace,
+          ethereumProvider,
+          solanaWallet
+        };
+      }
+      return {
+        kind: "external",
+        targetAccount,
+        activeAccount: targetAccount,
+        activeChainId: this.getChainIdForLinkedAccount(targetAccount, context.currentChainId)
+      };
+    } catch (error) {
+      await this.trackSwitchAccountFailed(account, error);
+      throw error;
+    }
+  }
+  async trackSwitchAccountCompleted(account) {
+    await this.analytics.track(ANALYTICS_EVENTS.ACCOUNT_SWITCH_COMPLETED, _objectSpread(_objectSpread({}, this.getSwitchAccountTrackData(account)), {}, {
+      connector: account.connector
+    }));
+  }
+  async trackSwitchAccountFailed(account, error) {
+    await this.analytics.track(ANALYTICS_EVENTS.ACCOUNT_SWITCH_FAILED, _objectSpread(_objectSpread({}, this.getSwitchAccountTrackData(account)), getErrorAnalyticsProperties(error)));
+  }
+  async linkAccount(params) {
+    if (!CONNECTED_STATUSES.includes(this.status)) {
+      throw WalletLoginError.notConnectedError("No wallet is connected. Connect with AUTH before linking an account.");
+    }
+    const {
+      connectorName,
+      chainId,
+      walletConnector
+    } = params;
+    try {
+      if (!walletConnector.connected) {
+        const connection = await walletConnector.connect({
+          chainId,
+          isAccountLinking: true
+        });
+        if (!connection) {
+          throw AccountLinkingError.walletProofFailed(`Failed to connect to "${params.connectorName}" for account linking.`);
+        }
+      }
+    } catch (error) {
+      if (error instanceof AccountLinkingError) {
+        throw error;
+      }
+      throw AccountLinkingError.walletProofFailed(error instanceof Error ? error.message : String(error), error);
+    }
+    const trackData = {
+      connector: this.name,
+      linking_connector: connectorName,
+      chain_id: params.chainId
+    };
+    try {
+      await this.analytics.track(ANALYTICS_EVENTS.ACCOUNT_LINKING_STARTED, trackData);
+      const {
+        accessToken,
+        idToken
+      } = await this.getPrimaryAuthSession(params.authSessionTokens);
+      const walletProof = await this.createWalletLinkingProof(params.walletConnector);
+      const authServerUrl = citadelServerUrl(this.coreOptions.authBuildEnv);
+      const result = await makeAccountLinkingRequest(authServerUrl, accessToken, {
+        idToken,
+        network: walletProof.network,
+        connector: params.connectorName,
+        message: walletProof.challenge,
+        signature: {
+          s: walletProof.signature,
+          t: walletProof.signatureType
+        }
+      });
+      this.analytics.track(ANALYTICS_EVENTS.ACCOUNT_LINKING_COMPLETED, _objectSpread(_objectSpread({}, trackData), {}, {
+        linked_address: walletProof.address
+      }));
+      return result;
+    } catch (error) {
+      this.analytics.track(ANALYTICS_EVENTS.ACCOUNT_LINKING_FAILED, _objectSpread(_objectSpread({}, trackData), getErrorAnalyticsProperties(error)));
+
+      // disconnect the wallet connector to avoid any leftover state
+      try {
+        await walletConnector.disconnect({
+          cleanup: true
+        });
+      } catch (disconnectError) {
+        log.debug("Failed to disconnect wallet connector after linking failure", disconnectError);
+      }
+      throw error;
+    }
+  }
+  async unlinkAccount(params) {
+    if (!CONNECTED_STATUSES.includes(this.status)) {
+      throw WalletLoginError.notConnectedError("No wallet is connected. Connect with AUTH before unlinking an account.");
+    }
+    const {
+      address,
+      authSessionTokens
+    } = params;
+    const trackData = {
+      connector: this.name,
+      address
+    };
+    await this.analytics.track(ANALYTICS_EVENTS.ACCOUNT_UNLINKING_STARTED, trackData);
+    try {
+      const {
+        accessToken,
+        idToken,
+        linkedAccounts
+      } = await this.getPrimaryAuthSession(authSessionTokens, {
+        includeLinkedAccounts: true
+      });
+      const network = this.getNetworkForUnlinkAddress(linkedAccounts, address);
+      const authServerUrl = citadelServerUrl(this.coreOptions.authBuildEnv);
+      const result = await makeAccountUnlinkingRequest(authServerUrl, accessToken, {
+        idToken,
+        address,
+        network
+      });
+      await this.analytics.track(ANALYTICS_EVENTS.ACCOUNT_UNLINKING_COMPLETED, _objectSpread(_objectSpread({}, trackData), {}, {
+        linked_address: address
+      }));
+      return result;
+    } catch (error) {
+      await this.analytics.track(ANALYTICS_EVENTS.ACCOUNT_UNLINKING_FAILED, _objectSpread(_objectSpread({}, trackData), getErrorAnalyticsProperties(error)));
+      throw error;
+    }
+  }
+  getChainIdForLinkedAccount(account, preferredChainId) {
+    const accountChainNamespace = account.chainNamespace ? parseChainNamespaceFromCitadelResponse(account.chainNamespace) : null;
+    if (preferredChainId) {
+      const preferredChain = this.coreOptions.chains.find(chain => chain.chainId === preferredChainId);
+      if (preferredChain && (!accountChainNamespace || preferredChain.chainNamespace === accountChainNamespace)) {
+        return preferredChainId;
+      }
+    }
+    if (accountChainNamespace) {
+      const namespaceChain = this.coreOptions.chains.find(chain => chain.chainNamespace === accountChainNamespace);
+      if (namespaceChain) {
+        return namespaceChain.chainId;
+      }
+    }
+    throw WalletInitializationError.invalidParams(`No compatible chainId found for connector "${account.connector}".`);
+  }
+  async assertSwitchAccountConnectorMatchesTarget(connector, account) {
+    if (!account.chainNamespace) {
+      throw AccountLinkingError.requestFailed(`Could not determine the chain namespace for linked account "${account.eoaAddress}".`);
+    }
+    const chainNamespace = parseChainNamespaceFromCitadelResponse(account.chainNamespace);
+    let connectedAddress = null;
+    if (chainNamespace === CHAIN_NAMESPACES.EIP155) {
+      var _accounts$;
+      const accounts = connector.provider ? await connector.provider.request({
+        method: "eth_accounts"
+      }) : [];
+      connectedAddress = (_accounts$ = accounts === null || accounts === void 0 ? void 0 : accounts[0]) !== null && _accounts$ !== void 0 ? _accounts$ : null;
+    } else if (chainNamespace === CHAIN_NAMESPACES.SOLANA) {
+      var _connector$solanaWall, _connector$solanaWall2;
+      connectedAddress = (_connector$solanaWall = (_connector$solanaWall2 = connector.solanaWallet) === null || _connector$solanaWall2 === void 0 || (_connector$solanaWall2 = _connector$solanaWall2.accounts) === null || _connector$solanaWall2 === void 0 || (_connector$solanaWall2 = _connector$solanaWall2[0]) === null || _connector$solanaWall2 === void 0 ? void 0 : _connector$solanaWall2.address) !== null && _connector$solanaWall !== void 0 ? _connector$solanaWall : null;
+    } else {
+      throw AccountLinkingError.requestFailed(`Unsupported chain namespace "${account.chainNamespace}" for linked account "${account.eoaAddress}".`);
+    }
+    if (!connectedAddress) {
+      throw AccountLinkingError.requestFailed(`Connector "${account.connector}" is not connected to linked account "${account.eoaAddress}". Connect the intended wallet account and try again.`);
+    }
+    const isExpectedAddress = chainNamespace === CHAIN_NAMESPACES.EIP155 ? connectedAddress.toLowerCase() === account.eoaAddress.toLowerCase() : connectedAddress === account.eoaAddress;
+    if (!isExpectedAddress) {
+      throw AccountLinkingError.requestFailed(`Connector "${account.connector}" is connected to "${connectedAddress}" instead of linked account "${account.eoaAddress}". Connect the intended wallet account and try again.`);
+    }
+  }
+  toSwitchAccountConnectorError(account, error) {
+    if (error instanceof AccountLinkingError && error.code === 5401) {
+      return error;
+    }
+    const message = error instanceof Error ? error.message : String(error);
+    const isUnavailableConnectorError = error instanceof AccountLinkingError && error.code === 5405 || /not available|not initialized|not ready/i.test(message);
+    if (isUnavailableConnectorError) {
+      return AccountLinkingError.requestFailed(`Connector "${account.connector}" is not available for linked account "${account.eoaAddress}". Make sure the wallet is installed, unlocked, and accessible, then try again.`, error);
+    }
+    return AccountLinkingError.requestFailed(`Failed to connect connector "${account.connector}" for linked account "${account.eoaAddress}". ${message}`, error);
+  }
+  getSwitchAccountTrackData(account) {
+    var _account$eoaAddress;
+    return {
+      connector: this.name,
+      account_id: account.id,
+      account_type: account.accountType,
+      switched_to_address: (_account$eoaAddress = account.eoaAddress) !== null && _account$eoaAddress !== void 0 ? _account$eoaAddress : null
+    };
+  }
+  async getPrimaryAuthSession(authSessionTokens, options = {}) {
+    const {
+      accessToken: cachedAccessToken,
+      idToken: cachedIdToken
+    } = authSessionTokens;
+    const {
+      includeLinkedAccounts = false
+    } = options;
+    let accessToken = cachedAccessToken;
+    let idToken = cachedIdToken;
+    let linkedAccounts = [];
+    if (includeLinkedAccounts) {
+      const userInfoPromise = this.getUserInfo();
+      if (!accessToken || !idToken) {
+        var _userInfo$linkedAccou2;
+        const [tokenInfo, userInfo] = await Promise.all([this.getAuthTokenInfo(), userInfoPromise]);
+        accessToken = tokenInfo.accessToken;
+        idToken = tokenInfo.idToken;
+        linkedAccounts = (_userInfo$linkedAccou2 = userInfo.linkedAccounts) !== null && _userInfo$linkedAccou2 !== void 0 ? _userInfo$linkedAccou2 : [];
+      } else {
+        var _userInfo$linkedAccou3;
+        const userInfo = await userInfoPromise;
+        linkedAccounts = (_userInfo$linkedAccou3 = userInfo.linkedAccounts) !== null && _userInfo$linkedAccou3 !== void 0 ? _userInfo$linkedAccou3 : [];
+      }
+    } else if (!accessToken || !idToken) {
+      const tokenInfo = await this.getAuthTokenInfo();
+      accessToken = tokenInfo.accessToken;
+      idToken = tokenInfo.idToken;
+    }
+    if (!accessToken || !idToken) {
+      throw AccountLinkingError.primaryTokenNotAvailable("Could not obtain an identity token from the current AUTH session.");
+    }
+    return {
+      accessToken,
+      idToken,
+      linkedAccounts
+    };
+  }
+  getNetworkForUnlinkAddress(accounts, address) {
+    const matchedAccount = accounts.find(account => {
+      var _account$address, _account$eoaAddress2;
+      if (!account.chainNamespace || parseChainNamespaceFromCitadelResponse(account.chainNamespace) !== CHAIN_NAMESPACES.EIP155) {
+        return false;
+      }
+      const normalizedAddress = address.toLowerCase();
+      return ((_account$address = account.address) === null || _account$address === void 0 ? void 0 : _account$address.toLowerCase()) === normalizedAddress || ((_account$eoaAddress2 = account.eoaAddress) === null || _account$eoaAddress2 === void 0 ? void 0 : _account$eoaAddress2.toLowerCase()) === normalizedAddress;
+    });
+    if (!matchedAccount) {
+      throw AccountLinkingError.requestFailed(`No connected wallet matches address "${address}".`);
+    }
+    if (!matchedAccount.chainNamespace) {
+      throw AccountLinkingError.requestFailed(`Could not determine the chain namespace for address "${address}".`);
+    }
+    const chainNamespace = parseChainNamespaceFromCitadelResponse(matchedAccount.chainNamespace);
+    if (chainNamespace === CHAIN_NAMESPACES.EIP155) {
+      return "ethereum";
+    }
+    if (chainNamespace === CHAIN_NAMESPACES.SOLANA) {
+      return "solana";
+    }
+    throw AccountLinkingError.requestFailed(`Unsupported chain namespace "${matchedAccount.chainNamespace}" for address "${address}".`);
+  }
+  async createWalletLinkingProof(connector) {
+    // Notify listeners that the linking wallet is about to be asked for a signature so the UI
+    // (e.g. modal) can switch from a "connecting" loader to an "authorizing" prompt while the
+    // user reviews the signature request inside their wallet. Emitted on the isolated wallet
+    // connector (not the auth connector) so it doesn't mutate the global SDK status.
+    connector.emit(CONNECTOR_EVENTS.AUTHORIZING, {
+      connector: connector.name
+    });
+    const {
+      challenge,
+      signature,
+      chainNamespace
+    } = await connector.generateChallengeAndSign();
+    const address = await this.getLinkingWalletAddress(connector, chainNamespace);
+    if (chainNamespace === CHAIN_NAMESPACES.EIP155) {
+      return {
+        address,
+        challenge,
+        signature,
+        signatureType: "eip191",
+        network: "ethereum"
+      };
+    }
+    if (chainNamespace === CHAIN_NAMESPACES.SOLANA) {
+      return {
+        address,
+        challenge,
+        signature,
+        signatureType: "sip99",
+        network: "solana"
+      };
+    }
+    throw AccountLinkingError.unsupportedConnector(`Connector "${connector.name}" returned unsupported chain namespace "${chainNamespace}".`);
+  }
+  async getLinkingWalletAddress(connector, chainNamespace) {
+    if (chainNamespace === CHAIN_NAMESPACES.SOLANA) {
+      var _connector$solanaWall3;
+      const address = (_connector$solanaWall3 = connector.solanaWallet) === null || _connector$solanaWall3 === void 0 || (_connector$solanaWall3 = _connector$solanaWall3.accounts) === null || _connector$solanaWall3 === void 0 || (_connector$solanaWall3 = _connector$solanaWall3[0]) === null || _connector$solanaWall3 === void 0 ? void 0 : _connector$solanaWall3.address;
+      if (!address) {
+        throw AccountLinkingError.walletProofFailed("No connected Solana account found for account linking.");
+      }
+      return address;
+    }
+    if (!connector.provider) {
+      throw AccountLinkingError.walletProofFailed("No connected EVM account found for account linking.");
+    }
+    const accounts = await connector.provider.request({
+      method: "eth_accounts"
+    });
+    if (!(accounts !== null && accounts !== void 0 && accounts.length)) {
+      throw AccountLinkingError.walletProofFailed("No connected EVM account found for account linking.");
+    }
+    return accounts[0];
+  }
   setupSolanaWallet() {
     const solanaChains = this.coreOptions.chains.filter(c => c.chainNamespace === CHAIN_NAMESPACES.SOLANA);
     if (solanaChains.length === 0 || !this.provider) return;
@@ -653,7 +1016,8 @@ class AuthConnector extends BaseConnector {
 const authConnector = params => {
   return ({
     projectConfig,
-    coreOptions
+    coreOptions,
+    analytics
   }) => {
     var _coreOptions$uiConfig, _coreOptions$walletSe, _coreOptions$walletSe2, _coreOptions$walletSe3;
     // Connector settings
@@ -698,9 +1062,22 @@ const authConnector = params => {
         mfaLevel: coreOptions.mfaLevel
       }),
       coreOptions,
+      analytics,
       authConnectionConfig: projectConfig.embeddedWalletAuth
     });
   };
 };
+function isAuthConnector(connector) {
+  if (!connector || connector.name !== WALLET_CONNECTORS.AUTH) {
+    return false;
+  }
+  const maybeAuthConnector = connector;
+  return typeof maybeAuthConnector.switchAccount === "function" && typeof maybeAuthConnector.linkAccount === "function" && typeof maybeAuthConnector.unlinkAccount === "function";
+}
+function assertAuthConnector(connector, errorMessage = "Account linking is only supported when connected with the AUTH connector.") {
+  if (!isAuthConnector(connector)) {
+    throw WalletLoginError.unsupportedOperation(errorMessage);
+  }
+}
 
-export { authConnector };
+export { assertAuthConnector, authConnector, isAuthConnector };

package/dist/lib.esm/connectors/base-evm-connector/baseEvmConnector.js

@@ -2,9 +2,9 @@ import { signChallenge } from '@toruslabs/base-controllers';
 import { bytesToHexPrefixedString, utf8ToBytes } from '@toruslabs/metadata-helpers';
 import { EVM_METHOD_TYPES } from '@web3auth/ws-embed';
 import { generateSiweNonce } from 'viem/siwe';
+import { WalletLoginError, WalletInitializationError } from '../../base/errors/index.js';
 import { citadelServerUrl } from '../../base/utils.js';
 import { BaseConnector } from '../../base/connector/baseConnector.js';
-import { WalletLoginError, WalletInitializationError } from '../../base/errors/index.js';
 import { CONNECTOR_STATUS, CONNECTOR_EVENTS } from '../../base/connector/constants.js';
 
 class BaseEvmConnector extends BaseConnector {
@@ -22,39 +22,58 @@ class BaseEvmConnector extends BaseConnector {
     if (accounts && accounts.length > 0) {
       const cached = await this.getCachedOrNullAuthTokenInfo(accounts[0]);
       if (cached) return cached;
-      const chainId = await this.provider.request({
-        method: "eth_chainId"
-      });
-      const currentChainConfig = this.coreOptions.chains.find(x => x.chainId === chainId);
-      if (!currentChainConfig) throw WalletInitializationError.invalidParams("chainConfig is required before authentication");
+      const authServer = citadelServerUrl(this.coreOptions.authBuildEnv);
       const {
+        challenge,
+        signature,
         chainNamespace
-      } = currentChainConfig;
-      const authServer = citadelServerUrl(this.coreOptions.authBuildEnv);
-      const payload = {
-        domain: window.location.origin,
-        uri: window.location.href,
-        address: accounts[0],
-        chainId: parseInt(chainId, 16),
-        version: "1",
-        nonce: generateSiweNonce(),
-        issuedAt: new Date().toISOString()
-      };
-      const challenge = await signChallenge(payload, chainNamespace, authServer);
-      const hexChallenge = bytesToHexPrefixedString(utf8ToBytes(challenge));
-      const signedMessage = await this.provider.request({
-        method: EVM_METHOD_TYPES.PERSONAL_SIGN,
-        params: [hexChallenge, accounts[0]]
-      });
+      } = await this.generateChallengeAndSign(authServer, accounts);
       return this.verifyAndAuthorize({
         chainNamespace,
-        signedMessage,
+        signedMessage: signature,
         challenge,
         authServer
       });
     }
     throw WalletLoginError.notConnectedError("Not connected with wallet, Please login/connect first");
   }
+  async generateChallengeAndSign(authServerUrl, accounts) {
+    const accountsToUse = accounts || (await this.provider.request({
+      method: EVM_METHOD_TYPES.GET_ACCOUNTS
+    }));
+    if (!accountsToUse || accountsToUse.length === 0) {
+      throw WalletLoginError.notConnectedError("No accounts found in the connected wallet");
+    }
+    const chainId = await this.provider.request({
+      method: "eth_chainId"
+    });
+    const currentChainConfig = this.coreOptions.chains.find(x => x.chainId === chainId);
+    if (!currentChainConfig) throw WalletInitializationError.invalidParams("chainConfig is required before authentication");
+    const {
+      chainNamespace
+    } = currentChainConfig;
+    const authServer = authServerUrl || citadelServerUrl(this.coreOptions.authBuildEnv);
+    const payload = {
+      domain: window.location.origin,
+      uri: window.location.href,
+      address: accountsToUse[0],
+      chainId: parseInt(chainId, 16),
+      version: "1",
+      nonce: generateSiweNonce(),
+      issuedAt: new Date().toISOString()
+    };
+    const challenge = await signChallenge(payload, chainNamespace, authServer);
+    const hexChallenge = bytesToHexPrefixedString(utf8ToBytes(challenge));
+    const signature = await this.provider.request({
+      method: EVM_METHOD_TYPES.PERSONAL_SIGN,
+      params: [hexChallenge, accountsToUse[0]]
+    });
+    return {
+      challenge,
+      signature,
+      chainNamespace
+    };
+  }
   async disconnectSession() {
     super.checkDisconnectionRequirements();
     await this.clearWalletSession();

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

@@ -1,10 +1,10 @@
 import { CHAIN_NAMESPACES, signChallenge } from '@toruslabs/base-controllers';
 import { generateSiweNonce } from 'viem/siwe';
+import { WalletLoginError, WalletInitializationError } from '../../base/errors/index.js';
+import { citadelServerUrl } from '../../base/utils.js';
 import { getSolanaChainByChainConfig, walletSignMessage } from '../../base/wallet/solana.js';
 import { BaseConnector } from '../../base/connector/baseConnector.js';
-import { WalletLoginError, WalletInitializationError } from '../../base/errors/index.js';
 import { CONNECTOR_STATUS, CONNECTOR_EVENTS } from '../../base/connector/constants.js';
-import { citadelServerUrl } from '../../base/utils.js';
 
 class BaseSolanaConnector extends BaseConnector {
   async init(_) {}
@@ -19,40 +19,57 @@ class BaseSolanaConnector extends BaseConnector {
     if (accounts.length > 0) {
       const cached = await this.getCachedOrNullAuthTokenInfo(accounts[0]);
       if (cached) return cached;
-      const walletChains = new Set(this.solanaWallet.chains);
-      const currentChainConfig = this.coreOptions.chains.find(c => {
-        if (c.chainNamespace !== CHAIN_NAMESPACES.SOLANA) return false;
-        const id = getSolanaChainByChainConfig(c);
-        return id != null && walletChains.has(id);
-      });
-      if (!currentChainConfig) {
-        throw WalletInitializationError.invalidParams("No Solana chain in common between the connected wallet and Web3Auth chain configuration");
-      }
+      const authServer = citadelServerUrl(this.coreOptions.authBuildEnv);
       const {
-        chainId,
+        challenge,
+        signature,
         chainNamespace
-      } = currentChainConfig;
-      const authServer = citadelServerUrl(this.coreOptions.authBuildEnv);
-      const payload = {
-        domain: window.location.origin,
-        uri: window.location.href,
-        address: accounts[0],
-        chainId: parseInt(chainId, 16),
-        version: "1",
-        nonce: generateSiweNonce(),
-        issuedAt: new Date().toISOString()
-      };
-      const challenge = await signChallenge(payload, chainNamespace, authServer);
-      const signedMessage = await walletSignMessage(this.solanaWallet, challenge, accounts[0]);
+      } = await this.generateChallengeAndSign(authServer);
       return this.verifyAndAuthorize({
         chainNamespace,
-        signedMessage,
+        signedMessage: signature,
         challenge,
         authServer
       });
     }
     throw WalletLoginError.notConnectedError("Not connected with wallet, Please login/connect first");
   }
+  async generateChallengeAndSign(authServerUrl, accounts) {
+    const accountsToUse = accounts || this.solanaWallet.accounts.map(a => a.address);
+    if (!accountsToUse || accountsToUse.length === 0) {
+      throw WalletLoginError.notConnectedError("No accounts found in the connected wallet");
+    }
+    const walletChains = new Set(this.solanaWallet.chains);
+    const currentChainConfig = this.coreOptions.chains.find(c => {
+      if (c.chainNamespace !== CHAIN_NAMESPACES.SOLANA) return false;
+      const id = getSolanaChainByChainConfig(c);
+      return id != null && walletChains.has(id);
+    });
+    if (!currentChainConfig) {
+      throw WalletInitializationError.invalidParams("No Solana chain in common between the connected wallet and Web3Auth chain configuration");
+    }
+    const {
+      chainId,
+      chainNamespace
+    } = currentChainConfig;
+    const authServer = authServerUrl || citadelServerUrl(this.coreOptions.authBuildEnv);
+    const payload = {
+      domain: window.location.origin,
+      uri: window.location.href,
+      address: accountsToUse[0],
+      chainId: parseInt(chainId, 16),
+      version: "1",
+      nonce: generateSiweNonce(),
+      issuedAt: new Date().toISOString()
+    };
+    const challenge = await signChallenge(payload, chainNamespace, authServer);
+    const signedMessage = await walletSignMessage(this.solanaWallet, challenge, accountsToUse[0]);
+    return {
+      challenge,
+      signature: signedMessage,
+      chainNamespace
+    };
+  }
   async disconnectSession() {
     super.checkDisconnectionRequirements();
     await this.clearWalletSession();

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

@@ -2,10 +2,10 @@ import _objectSpread from '@babel/runtime/helpers/objectSpread2';
 import _defineProperty from '@babel/runtime/helpers/defineProperty';
 import { BaseEvmConnector } from '../base-evm-connector/baseEvmConnector.js';
 import { CONNECTOR_NAMESPACES } from '../../base/chain/IChainInterface.js';
-import { CHAIN_NAMESPACES } from '@toruslabs/base-controllers';
-import { CONNECTOR_CATEGORY, CONNECTOR_STATUS, CONNECTOR_EVENTS } from '../../base/connector/constants.js';
 import { WALLET_CONNECTORS } from '../../base/wallet/index.js';
 import { WalletLoginError, Web3AuthError } from '../../base/errors/index.js';
+import { CHAIN_NAMESPACES } from '@toruslabs/base-controllers';
+import { CONNECTOR_CATEGORY, CONNECTOR_STATUS, CONNECTOR_EVENTS } from '../../base/connector/constants.js';
 
 class CoinbaseConnector extends BaseEvmConnector {
   constructor(connectorOptions) {

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

@@ -2,10 +2,10 @@ import _defineProperty from '@babel/runtime/helpers/defineProperty';
 import { normalizeWalletName } from '../../base/utils.js';
 import { BaseEvmConnector } from '../base-evm-connector/baseEvmConnector.js';
 import { CONNECTOR_NAMESPACES } from '../../base/chain/IChainInterface.js';
-import { CHAIN_NAMESPACES } from '@toruslabs/base-controllers';
-import { CONNECTOR_CATEGORY, CONNECTOR_STATUS, CONNECTOR_EVENTS } from '../../base/connector/constants.js';
 import { log } from '../../base/loglevel.js';
 import { WalletLoginError, Web3AuthError } from '../../base/errors/index.js';
+import { CHAIN_NAMESPACES } from '@toruslabs/base-controllers';
+import { CONNECTOR_CATEGORY, CONNECTOR_STATUS, CONNECTOR_EVENTS } from '../../base/connector/constants.js';
 
 class InjectedEvmConnector extends BaseEvmConnector {
   constructor(options) {