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

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

@@ -1,20 +1,22 @@
 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 { SecurePubSub } from '@toruslabs/secure-pub-sub';
-import { BUILD_ENV, UX_MODE, Auth, SDK_MODE, SUPPORTED_KEY_CURVES, randomId, version, createHandler, PopupHandler, getUserId } from '@web3auth/auth';
+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 { parseToken } from '../utils.js';
+import { generateNonce, parseToken } from '../utils.js';
+import { AuthSolanaWallet } from './authSolanaWallet.js';
 import { BaseConnector } from '../../base/connector/baseConnector.js';
 import { WALLET_CONNECTORS } from '../../base/wallet/index.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 { log } from '../../base/loglevel.js';
+import { getCaipChainId } from '../../base/utils.js';
 import { CONNECTED_STATUSES } from '../../base/connector/connectorStatus.js';
 import { CHAIN_NAMESPACES, cloneDeep } from '@toruslabs/base-controllers';
-import '@toruslabs/constants';
-import '@toruslabs/http-helpers';
 
 class AuthConnector extends BaseConnector {
   constructor(params) {
@@ -33,6 +35,7 @@ class AuthConnector extends BaseConnector {
     _defineProperty(this, "wsEmbedInstance", null);
     _defineProperty(this, "authConnectionConfig", []);
     _defineProperty(this, "wsEmbedInstancePromise", null);
+    _defineProperty(this, "_solanaWallet", null);
     this.authOptions = params.connectorSettings;
     this.loginSettings = params.loginSettings || {
       authConnection: ""
@@ -54,6 +57,9 @@ class AuthConnector extends BaseConnector {
   get wsEmbed() {
     return this.wsEmbedInstance;
   }
+  get solanaWallet() {
+    return this._solanaWallet;
+  }
   set provider(_) {
     throw new Error("Not implemented");
   }
@@ -88,7 +94,7 @@ class AuthConnector extends BaseConnector {
     // making it async here to initialize provider.
     const authInstancePromise = this.authInstance.init();
 
-    // Use this for xrpl, mpc cases
+    // Use this for xrpl cases
     if (this.coreOptions.privateKeyProvider) {
       this.privateKeyProvider = this.coreOptions.privateKeyProvider;
     } else {
@@ -110,6 +116,7 @@ class AuthConnector extends BaseConnector {
               loginMode: WS_EMBED_LOGIN_MODE.PLUGIN,
               chains: wsSupportedChains,
               chainId,
+              buildEnv: this.authOptions.buildEnv,
               whiteLabel: _objectSpread(_objectSpread({}, this.authOptions.whiteLabel), this.wsSettings.whiteLabel)
             })).then(() => {
               this.wsEmbedInstancePromise = null;
@@ -148,7 +155,7 @@ class AuthConnector extends BaseConnector {
         this.rehydrated = true;
         await this.connect({
           chainId: options.chainId,
-          getIdentityToken: options.getIdentityToken
+          getAuthTokenInfo: options.getAuthTokenInfo
         });
       } else if (!sessionId && options.autoConnect) {
         // if here, this means that the connector is cached but the sessionId is not available.
@@ -168,7 +175,11 @@ class AuthConnector extends BaseConnector {
     }));
     try {
       await this.connectWithProvider(params);
-      return this.provider;
+      return {
+        ethereumProvider: this.provider,
+        solanaWallet: this._solanaWallet,
+        connectorName: this.name
+      };
     } catch (error) {
       var _message;
       log.error("Failed to connect with auth provider", error);
@@ -233,9 +244,10 @@ class AuthConnector extends BaseConnector {
       this.status = CONNECTOR_STATUS.READY;
     }
     this.rehydrated = false;
+    this._solanaWallet = null;
     this.emit(CONNECTOR_EVENTS.DISCONNECTED);
   }
-  async getIdentityToken() {
+  async getAuthTokenInfo() {
     if (!this.canAuthorize) throw WalletLoginError.notConnectedError("Not connected with wallet, Please login/connect first");
     this.status = CONNECTOR_STATUS.AUTHORIZING;
     this.emit(CONNECTOR_EVENTS.AUTHORIZING, {
@@ -243,14 +255,19 @@ class AuthConnector extends BaseConnector {
     });
     const userInfo = await this.getUserInfo();
     this.status = CONNECTOR_STATUS.AUTHORIZED;
+    const [accessToken, refreshToken] = await Promise.all([this.authInstance.authSessionManager.getAccessToken(), this.authInstance.authSessionManager.getRefreshToken()]);
     this.emit(CONNECTOR_EVENTS.AUTHORIZED, {
       connector: WALLET_CONNECTORS.AUTH,
-      identityTokenInfo: {
-        idToken: userInfo.idToken
+      authTokenInfo: {
+        idToken: userInfo.idToken,
+        accessToken,
+        refreshToken
       }
     });
     return {
-      idToken: userInfo.idToken
+      idToken: userInfo.idToken,
+      accessToken,
+      refreshToken
     };
   }
   async getUserInfo() {
@@ -259,41 +276,29 @@ class AuthConnector extends BaseConnector {
     const userInfo = this.authInstance.getUserInfo();
     return userInfo;
   }
-
-  // we don't support switching between different namespaces, except for solana and evm
   async switchChain(params, init = false) {
     super.checkSwitchChainRequirements(params, init);
-    // get chains and namespaces
     const {
       chainId: newChainId
     } = params;
     const {
       chainId: currentChainId
     } = this.provider;
-    const {
-      chainNamespace: currentNamespace
-    } = this.getChain(currentChainId);
-    const {
-      chainNamespace: newNamespace
-    } = this.getChain(newChainId);
-
-    // skip if chainId is the same
     if (currentChainId === newChainId) return;
-    if (currentNamespace === CHAIN_NAMESPACES.SOLANA || currentNamespace === CHAIN_NAMESPACES.EIP155) {
+    const newChainConfig = this.coreOptions.chains.find(c => c.chainId === newChainId);
+    if (!newChainConfig) throw WalletInitializationError.invalidParams("Chain config is not available");
+    if (newChainConfig.chainNamespace === CHAIN_NAMESPACES.SOLANA || newChainConfig.chainNamespace === CHAIN_NAMESPACES.EIP155) {
       var _this$wsEmbedInstance2;
-      // can only switch to solana or evm
-      if (newNamespace !== CHAIN_NAMESPACES.SOLANA && newNamespace !== CHAIN_NAMESPACES.EIP155) throw WalletLoginError.connectionError("Cannot switch to other chain namespace");
-      const fullChainId = `${newNamespace}:${Number(params.chainId)}`;
-      await ((_this$wsEmbedInstance2 = this.wsEmbedInstance.provider) === null || _this$wsEmbedInstance2 === void 0 ? void 0 : _this$wsEmbedInstance2.request({
+      if (!((_this$wsEmbedInstance2 = this.wsEmbedInstance) !== null && _this$wsEmbedInstance2 !== void 0 && _this$wsEmbedInstance2.provider)) throw WalletInitializationError.notReady("Wallet embed is not ready");
+      const fullChainId = getCaipChainId(newChainConfig);
+      await this.wsEmbedInstance.provider.request({
         method: "wallet_switchChain",
         params: {
           chainId: fullChainId
         }
-      }));
+      });
     } else {
       var _this$privateKeyProvi;
-      // cannot switch to other namespaces
-      if (currentNamespace !== newNamespace) throw WalletLoginError.connectionError("Cannot switch to other chain namespace");
       await ((_this$privateKeyProvi = this.privateKeyProvider) === null || _this$privateKeyProvi === void 0 ? void 0 : _this$privateKeyProvi.switchChain(params));
     }
   }
@@ -322,8 +327,10 @@ class AuthConnector extends BaseConnector {
     });
     return providerConfig;
   }
-  getChain(chainId) {
-    return this.coreOptions.chains.find(x => x.chainId === chainId);
+  setupSolanaWallet() {
+    const solanaChains = this.coreOptions.chains.filter(c => c.chainNamespace === CHAIN_NAMESPACES.SOLANA);
+    if (solanaChains.length === 0 || !this.provider) return;
+    this._solanaWallet = new AuthSolanaWallet(this.provider, solanaChains);
   }
   _getFinalPrivKey() {
     if (!this.authInstance) return "";
@@ -384,24 +391,26 @@ class AuthConnector extends BaseConnector {
         sessionNamespace
       } = this.authInstance || {};
       if (sessionId) {
-        const isLoggedIn = await this.wsEmbedInstance.loginWithSessionId({
+        this.wsEmbedInstance.setAccessTokenProvider(this.accessTokenProvider.bind(this));
+        const isLoggedIn = await this.wsEmbedInstance.connectWithSession({
           sessionId,
-          sessionNamespace
+          sessionNamespace,
+          idToken: await this.getIdToken()
         });
         if (isLoggedIn) {
           var _this$wsEmbedInstance3;
-          // if getIdentityToken is true, then get the identity token
-          // No need to get the identity token for auth connector as it is already handled
-          let identityTokenInfo;
+          this.setupSolanaWallet();
+          // if getAuthTokenInfo is true, then get auth token info
+          // No need to get auth token info for auth connector as it is already handled
           this.status = CONNECTOR_STATUS.CONNECTED;
           this.emit(CONNECTOR_EVENTS.CONNECTED, {
-            connector: WALLET_CONNECTORS.AUTH,
+            connectorName: WALLET_CONNECTORS.AUTH,
             reconnected: this.rehydrated,
-            provider: this.provider,
-            identityTokenInfo
+            ethereumProvider: this.provider,
+            solanaWallet: this._solanaWallet
           });
-          if (params.getIdentityToken) {
-            identityTokenInfo = await this.getIdentityToken();
+          if (params.getAuthTokenInfo) {
+            await this.getAuthTokenInfo();
           }
           // handle disconnect from ws embed
           (_this$wsEmbedInstance3 = this.wsEmbedInstance) === null || _this$wsEmbedInstance3 === void 0 || _this$wsEmbedInstance3.provider.on("accountsChanged", (accounts = []) => {
@@ -418,9 +427,10 @@ class AuthConnector extends BaseConnector {
         await this.privateKeyProvider.setupProvider(finalPrivKey, params.chainId);
         this.status = CONNECTOR_STATUS.CONNECTED;
         this.emit(CONNECTOR_EVENTS.CONNECTED, {
-          connector: WALLET_CONNECTORS.AUTH,
-          reconnected: this.rehydrated,
-          provider: this.provider
+          connectorName: WALLET_CONNECTORS.AUTH,
+          ethereumProvider: this.provider,
+          solanaWallet: this._solanaWallet,
+          reconnected: this.rehydrated
         });
       }
     }
@@ -436,10 +446,13 @@ class AuthConnector extends BaseConnector {
     const jwtParams = _objectSpread(_objectSpread(_objectSpread({}, providerConfig.jwtParameters || {}), params.extraLoginOptions || {}), {}, {
       login_hint: params.loginHint || ((_params$extraLoginOpt3 = params.extraLoginOptions) === null || _params$extraLoginOpt3 === void 0 ? void 0 : _params$extraLoginOpt3.login_hint)
     });
-    const nonce = randomId();
+    const nonce = generateNonce();
 
     // post a message to the auth provider to indicate that login has been initiated.
-    const loginParams = cloneDeep(params);
+    const loginParams = _objectSpread(_objectSpread({}, cloneDeep(params)), {}, {
+      recordId: generateRecordId(),
+      loginSource: "web3auth-web"
+    });
     loginParams.extraLoginOptions = _objectSpread(_objectSpread({}, loginParams.extraLoginOptions || {}), {}, {
       login_hint: params.loginHint || ((_params$extraLoginOpt4 = params.extraLoginOptions) === null || _params$extraLoginOpt4 === void 0 ? void 0 : _params$extraLoginOpt4.login_hint)
     });
@@ -462,10 +475,11 @@ class AuthConnector extends BaseConnector {
         version: version.split(".")[0],
         web3AuthNetwork: this.coreOptions.web3AuthNetwork,
         web3AuthClientId: this.coreOptions.clientId,
-        originData: this.authInstance.options.originData ? JSON.stringify(this.authInstance.options.originData) : undefined
+        originData: this.getOriginData()
       },
       web3AuthClientId: this.coreOptions.clientId,
-      web3AuthNetwork: this.coreOptions.web3AuthNetwork
+      web3AuthNetwork: this.coreOptions.web3AuthNetwork,
+      storageServerUrl: this.authInstance.options.storageServerUrl
     };
     const loginHandler = createHandler(popupParams);
     const verifierWindow = new PopupHandler({
@@ -474,6 +488,9 @@ class AuthConnector extends BaseConnector {
     });
     if (this.authOptions.uxMode === UX_MODE.REDIRECT) return verifierWindow.redirect(this.authOptions.replaceUrlOnRedirect);
     let isClosedWindow = false;
+    this.auditOAuditProgress(loginParams).catch(error => {
+      log.error("Error reporting `oauthInitiated` audit progress", error);
+    });
     return new Promise((resolve, reject) => {
       verifierWindow.open().catch(error => {
         log.error("Error during login with social", error);
@@ -483,7 +500,9 @@ class AuthConnector extends BaseConnector {
 
       // this is to close the popup when the login is finished.
       const securePubSub = new SecurePubSub({
-        sameIpCheck: true
+        sameIpCheck: true,
+        serverUrl: this.authInstance.options.storageServerUrl,
+        socketUrl: this.authInstance.options.sessionSocketUrl
       });
       securePubSub.subscribe(`web3auth-login-${nonce}`).then(data => {
         const parsedData = JSON.parse(data || "{}");
@@ -500,6 +519,9 @@ class AuthConnector extends BaseConnector {
       }).catch(error => {
         // swallow the error, dont need to throw.
         log.error("Error during login with social", error);
+        this.auditOAuditProgress(loginParams, "failed").catch(error => {
+          log.error("Error reporting `oauthFailed` audit progress", error);
+        });
       });
       verifierWindow.once("close", () => {
         if (!isClosedWindow) {
@@ -509,6 +531,9 @@ class AuthConnector extends BaseConnector {
         }
       });
       this.authInstance.postLoginInitiatedMessage(loginParams, nonce).then(resolve).catch(error => {
+        this.auditOAuditProgress(loginParams, "failed").catch(error => {
+          log.error("Error reporting `oauthFailed` audit progress", error);
+        });
         if (error instanceof Web3AuthError) {
           throw error;
         }
@@ -516,6 +541,39 @@ class AuthConnector extends BaseConnector {
       });
     });
   }
+  async accessTokenProvider({
+    forceRefresh
+  }) {
+    if (forceRefresh) {
+      await this.authInstance.refreshSession();
+    }
+    return this.authInstance.getAccessToken();
+  }
+  async getIdToken() {
+    if (!this.authInstance) throw WalletInitializationError.notReady("authInstance is not ready");
+    return this.authInstance.authSessionManager.getIdToken();
+  }
+  getOriginData() {
+    try {
+      const {
+        originData,
+        redirectUrl
+      } = this.authInstance.options;
+      const origin = new URL(redirectUrl).origin;
+      if (originData) {
+        const dappOriginData = originData[origin];
+        if (dappOriginData) {
+          return JSON.stringify({
+            [origin]: dappOriginData
+          });
+        }
+      }
+      return undefined;
+    } catch (error) {
+      log.error("Error getting origin data", error);
+      return undefined;
+    }
+  }
   connectWithJwtLogin(params) {
     var _params$extraLoginOpt5, _params$extraLoginOpt7;
     const loginConfig = this.getOAuthProviderConfig({
@@ -556,6 +614,41 @@ class AuthConnector extends BaseConnector {
     delete loginParams.chainId;
     return this.authInstance.postLoginInitiatedMessage(loginParams);
   }
+  async auditOAuditProgress(loginParams, status) {
+    const {
+      authConnection,
+      authConnectionId,
+      groupedAuthConnectionId,
+      recordId,
+      loginSource
+    } = loginParams;
+    const {
+      authBuildEnv = BUILD_ENV.PRODUCTION,
+      web3AuthNetwork,
+      clientId
+    } = this.coreOptions;
+    const auditServerUrl = `${CITADEL_SERVER_MAP[authBuildEnv]}/v1/auth/audit`;
+    const progressFlag = {
+      oauthInitiated: true
+    };
+    const auditPayload = _objectSpread({
+      authConnection,
+      authConnectionId,
+      groupedAuthConnectionId,
+      recordId,
+      source: loginSource,
+      web3AuthNetwork,
+      web3AuthClientId: clientId
+    }, progressFlag);
+    if (status === "failed") {
+      auditPayload.oauthFailed = true;
+    } else if (status === "completed") {
+      auditPayload.oauthCompleted = true;
+    } else {
+      auditPayload.oauthInitiated = true;
+    }
+    await put(auditServerUrl, auditPayload);
+  }
 }
 const authConnector = params => {
   return ({

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

@@ -0,0 +1,175 @@
+import _objectSpread from '@babel/runtime/helpers/objectSpread2';
+import _defineProperty from '@babel/runtime/helpers/defineProperty';
+import { getBase64EncodedWireTransaction, getBase64Decoder, getBase58Encoder, getTransactionDecoder, getBase64Encoder } from '@solana/kit';
+import { SolanaSignTransaction, SolanaSignMessage, SolanaSignAndSendTransaction } from '@solana/wallet-standard-features';
+import { StandardEvents, StandardDisconnect, StandardConnect } from '@wallet-standard/features';
+import { SOLANA_METHOD_TYPES } from '@web3auth/ws-embed';
+import { WEB3AUTH_ICON } from '../../base/wallet/index.js';
+import { WalletLoginError } from '../../base/errors/index.js';
+import { getSolanaChainByChainConfig } from '../../base/wallet/solana.js';
+import { SOLANA_CAIP_CHAIN_MAP } from '../../base/constants.js';
+
+const base58Encoder = getBase58Encoder();
+const base64Decoder = getBase64Decoder();
+const base64Encoder = getBase64Encoder();
+const transactionDecoder = getTransactionDecoder();
+const ACCOUNT_FEATURES = [SolanaSignAndSendTransaction, SolanaSignMessage, SolanaSignTransaction];
+function solanaWalletChainsFromConfigs(solanaChainConfigs) {
+  const ids = solanaChainConfigs.map(getSolanaChainByChainConfig).filter(id => id != null);
+  const unique = [...new Set(ids)];
+  return unique;
+}
+const SOLANA_PROVIDER_HEX_CHAIN_IDS = new Set(Object.keys(SOLANA_CAIP_CHAIN_MAP).map(id => id.toLowerCase()));
+
+/**
+ * AuthSolanaWallet implements the Wallet Standard interface, wrapping a JRPC provider.
+ * Used by AuthConnector so consumers get a standards-compliant Wallet from `connection.solanaWallet`.
+ *
+ * {@link Wallet.accounts} is synchronous in the Wallet Standard; it returns `[]` until accounts have been loaded
+ * (`null` internally). The first async operation ({@link StandardConnect}, sign, etc.) calls `ensureAccountsLoaded`, which
+ * requires {@link IProvider.chainId} to be a configured Solana network (see {@link SOLANA_CAIP_CHAIN_MAP}) before {@link SOLANA_METHOD_TYPES.GET_ACCOUNTS}.
+ */
+class AuthSolanaWallet {
+  /**
+   * @param solanaChainConfigs - All configured Solana {@link CustomChainConfig} entries (same namespace).
+   */
+  constructor(_provider, solanaChainConfigs) {
+    this._provider = _provider;
+    _defineProperty(this, "version", "1.0.0");
+    _defineProperty(this, "name", "Web3Auth");
+    _defineProperty(this, "icon", WEB3AUTH_ICON);
+    _defineProperty(this, "chains", void 0);
+    _defineProperty(this, "features", void 0);
+    _defineProperty(this, "_accounts", null);
+    _defineProperty(this, "_listeners", {});
+    this.chains = solanaWalletChainsFromConfigs(solanaChainConfigs);
+    this.features = {
+      [StandardConnect]: {
+        version: "1.0.0",
+        connect: async () => {
+          await this.ensureAccountsLoaded();
+          return {
+            accounts: this.accounts
+          };
+        }
+      },
+      [StandardDisconnect]: {
+        version: "1.0.0",
+        disconnect: async () => {}
+      },
+      [StandardEvents]: {
+        version: "1.0.0",
+        on: (event, listener) => {
+          var _this$_listeners, _this$_listeners$even;
+          ((_this$_listeners$even = (_this$_listeners = this._listeners)[event]) !== null && _this$_listeners$even !== void 0 ? _this$_listeners$even : _this$_listeners[event] = new Set()).add(listener);
+          return () => this._listeners[event].delete(listener);
+        }
+      },
+      [SolanaSignAndSendTransaction]: {
+        version: "1.0.0",
+        supportedTransactionVersions: ["legacy", 0],
+        signAndSendTransaction: async (...inputs) => {
+          await this.ensureAccountsLoaded();
+          return Promise.all(inputs.map(async input => {
+            const base64Tx = base64Decoder.decode(input.transaction);
+            const signature = await this._provider.request({
+              method: SOLANA_METHOD_TYPES.SEND_TRANSACTION,
+              params: {
+                message: base64Tx
+              }
+            });
+            return {
+              signature: new Uint8Array(base58Encoder.encode(signature))
+            };
+          }));
+        }
+      },
+      [SolanaSignMessage]: {
+        version: "1.0.0",
+        signMessage: async (...inputs) => {
+          await this.ensureAccountsLoaded();
+          return Promise.all(inputs.map(async input => {
+            const message = new TextDecoder().decode(input.message);
+            const signature = await this._provider.request({
+              method: SOLANA_METHOD_TYPES.SIGN_MESSAGE,
+              params: {
+                data: message,
+                from: input.account.address
+              }
+            });
+            return {
+              signedMessage: new Uint8Array(input.message),
+              signature: new Uint8Array(base58Encoder.encode(signature))
+            };
+          }));
+        }
+      },
+      [SolanaSignTransaction]: {
+        version: "1.0.0",
+        supportedTransactionVersions: ["legacy", 0],
+        signTransaction: async (...inputs) => {
+          await this.ensureAccountsLoaded();
+          return Promise.all(inputs.map(async input => {
+            const base64Tx = base64Decoder.decode(input.transaction);
+            const signatureBase58 = await this._provider.request({
+              method: SOLANA_METHOD_TYPES.SIGN_TRANSACTION,
+              params: {
+                message: base64Tx
+              }
+            });
+            const sigBytes = new Uint8Array(base58Encoder.encode(signatureBase58));
+            const decodedTx = transactionDecoder.decode(input.transaction);
+            const signedTx = _objectSpread(_objectSpread({}, decodedTx), {}, {
+              signatures: _objectSpread(_objectSpread({}, decodedTx.signatures), {}, {
+                [input.account.address]: sigBytes
+              })
+            });
+            const signedBase64 = getBase64EncodedWireTransaction(signedTx);
+            return {
+              signedTransaction: new Uint8Array(base64Encoder.encode(signedBase64))
+            };
+          }));
+        }
+      }
+    };
+  }
+
+  /**
+   * Wallet Standard requires a synchronous getter; RPC runs on first async wallet operation instead.
+   */
+  get accounts() {
+    var _this$_accounts;
+    return (_this$_accounts = this._accounts) !== null && _this$_accounts !== void 0 ? _this$_accounts : [];
+  }
+
+  /** Throws if the embed is not on Solana; otherwise loads accounts once via {@link SOLANA_METHOD_TYPES.GET_ACCOUNTS}. */
+  async ensureAccountsLoaded() {
+    var _await$this$_provider;
+    // assert solana chain
+    const chainId = this._provider.chainId;
+    if (!SOLANA_PROVIDER_HEX_CHAIN_IDS.has(chainId.toLowerCase())) throw WalletLoginError.unsupportedOperation(`Solana wallet operations require the embedded provider to be on a Solana network (current chainId: ${chainId}). Switch chain first.`);
+    if (this._accounts !== null) return;
+    const addresses = (_await$this$_provider = await this._provider.request({
+      method: SOLANA_METHOD_TYPES.GET_ACCOUNTS
+    })) !== null && _await$this$_provider !== void 0 ? _await$this$_provider : [];
+    const accountChains = this.chains;
+    this._accounts = addresses.map(address => ({
+      address,
+      publicKey: new Uint8Array(base58Encoder.encode(address)),
+      chains: accountChains.length ? accountChains : [],
+      features: ACCOUNT_FEATURES
+    }));
+    this.emitChange({
+      accounts: this.accounts
+    });
+  }
+  emitChange(properties) {
+    const listeners = this._listeners.change;
+    if (!listeners) return;
+    listeners.forEach(listener => {
+      listener(properties);
+    });
+  }
+}
+
+export { AuthSolanaWallet };

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

@@ -1,13 +1,15 @@
-import { signChallenge, verifySignedChallenge } from '@toruslabs/base-controllers';
+import { signChallenge } from '@toruslabs/base-controllers';
+import { bytesToHexPrefixedString, utf8ToBytes } from '@toruslabs/metadata-helpers';
 import { EVM_METHOD_TYPES } from '@web3auth/ws-embed';
-import { getSavedToken, checkIfTokenIsExpired, saveToken, clearToken } from '../../base/connector/utils.js';
+import { generateSiweNonce } from 'viem/siwe';
+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 {
   async init(_) {}
-  async getIdentityToken() {
+  async getAuthTokenInfo() {
     if (!this.provider || !this.canAuthorize) throw WalletLoginError.notConnectedError();
     if (!this.coreOptions) throw WalletInitializationError.invalidParams("Please initialize Web3Auth with valid options");
     this.status = CONNECTOR_STATUS.AUTHORIZING;
@@ -18,22 +20,8 @@ class BaseEvmConnector extends BaseConnector {
       method: EVM_METHOD_TYPES.GET_ACCOUNTS
     });
     if (accounts && accounts.length > 0) {
-      const existingToken = getSavedToken(accounts[0], this.name);
-      if (existingToken) {
-        const isExpired = checkIfTokenIsExpired(existingToken);
-        if (!isExpired) {
-          this.status = CONNECTOR_STATUS.AUTHORIZED;
-          this.emit(CONNECTOR_EVENTS.AUTHORIZED, {
-            connector: this.name,
-            identityTokenInfo: {
-              idToken: existingToken
-            }
-          });
-          return {
-            idToken: existingToken
-          };
-        }
-      }
+      const cached = await this.getCachedOrNullAuthTokenInfo(accounts[0]);
+      if (cached) return cached;
       const chainId = await this.provider.request({
         method: "eth_chainId"
       });
@@ -42,44 +30,34 @@ class BaseEvmConnector extends BaseConnector {
       const {
         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: Math.random().toString(36).slice(2),
+        nonce: generateSiweNonce(),
         issuedAt: new Date().toISOString()
       };
-      const challenge = await signChallenge(payload, chainNamespace);
-      const hexChallenge = `0x${Buffer.from(challenge, "utf8").toString("hex")}`;
+      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]]
       });
-      const idToken = await verifySignedChallenge(chainNamespace, signedMessage, challenge, this.name, this.coreOptions.sessionTime, this.coreOptions.clientId, this.coreOptions.web3AuthNetwork);
-      saveToken(accounts[0], this.name, idToken);
-      this.status = CONNECTOR_STATUS.AUTHORIZED;
-      this.emit(CONNECTOR_EVENTS.AUTHORIZED, {
-        connector: this.name,
-        identityTokenInfo: {
-          idToken
-        }
+      return this.verifyAndAuthorize({
+        chainNamespace,
+        signedMessage,
+        challenge,
+        authServer
       });
-      return {
-        idToken
-      };
     }
     throw WalletLoginError.notConnectedError("Not connected with wallet, Please login/connect first");
   }
   async disconnectSession() {
     super.checkDisconnectionRequirements();
-    const accounts = await this.provider.request({
-      method: "eth_accounts"
-    });
-    if (accounts && accounts.length > 0) {
-      clearToken(accounts[0], this.name);
-    }
+    await this.clearWalletSession();
   }
   async disconnect() {
     this.rehydrated = false;