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

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 { BaseConnector } from '../../base/connector/baseConnector.js';
+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 { 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,68 +20,63 @@ 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 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 cached = await this.getCachedOrNullAuthTokenInfo(accounts[0]);
+      if (cached) return cached;
+      const authServer = citadelServerUrl(this.coreOptions.authBuildEnv);
       const {
+        challenge,
+        signature,
         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 signChallenge(payload, chainNamespace);
-      const hexChallenge = `0x${Buffer.from(challenge, "utf8").toString("hex")}`;
-      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
-        }
+      } = await this.generateChallengeAndSign(authServer, accounts);
+      return this.verifyAndAuthorize({
+        chainNamespace,
+        signedMessage: signature,
+        challenge,
+        authServer
       });
-      return {
-        idToken
-      };
     }
     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();
-    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;

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

@@ -1,87 +1,78 @@
-import { signChallenge, verifySignedChallenge } from '@toruslabs/base-controllers';
-import { SOLANA_METHOD_TYPES } from '@web3auth/ws-embed';
-import { BaseConnector } from '../../base/connector/baseConnector.js';
+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 { CONNECTOR_STATUS, CONNECTOR_EVENTS } from '../../base/connector/constants.js';
-import { getSavedToken, checkIfTokenIsExpired, saveToken, clearToken } from '../../base/connector/utils.js';
 
 class BaseSolanaConnector extends BaseConnector {
   async init(_) {}
-  async getIdentityToken() {
-    if (!this.provider || !this.canAuthorize) throw WalletLoginError.notConnectedError();
+  async getAuthTokenInfo() {
+    if (!this.solanaWallet || !this.canAuthorize) throw WalletLoginError.notConnectedError();
     if (!this.coreOptions) throw WalletInitializationError.invalidParams("Please initialize Web3Auth with a valid options");
     this.status = CONNECTOR_STATUS.AUTHORIZING;
     this.emit(CONNECTOR_EVENTS.AUTHORIZING, {
       connector: this.name
     });
-    const accounts = await this.provider.request({
-      method: SOLANA_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 chainId = await this.provider.request({
-        method: "solana_chainId"
-      });
-      const currentChainConfig = this.coreOptions.chains.find(x => x.chainId === chainId);
-      if (!currentChainConfig) throw WalletInitializationError.invalidParams("chainConfig is required before authentication");
+    const accounts = this.solanaWallet.accounts.map(a => a.address);
+    if (accounts.length > 0) {
+      const cached = await this.getCachedOrNullAuthTokenInfo(accounts[0]);
+      if (cached) return cached;
+      const authServer = citadelServerUrl(this.coreOptions.authBuildEnv);
       const {
+        challenge,
+        signature,
         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 signChallenge(payload, chainNamespace);
-      const signedMessage = await this.provider.request({
-        method: SOLANA_METHOD_TYPES.SIGN_MESSAGE,
-        params: {
-          data: challenge,
-          display: "utf8"
-        }
-      });
-      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
-        }
+      } = await this.generateChallengeAndSign(authServer);
+      return this.verifyAndAuthorize({
+        chainNamespace,
+        signedMessage: signature,
+        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: SOLANA_METHOD_TYPES.GET_ACCOUNTS
+  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 (accounts && accounts.length > 0) {
-      clearToken(accounts[0], this.name);
+    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();
   }
   async disconnect() {
     this.rehydrated = false;

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) {
@@ -53,12 +53,12 @@ class CoinbaseConnector extends BaseEvmConnector {
     try {
       if (options.autoConnect) {
         this.rehydrated = true;
-        const provider = await this.connect({
+        const connection = await this.connect({
           chainId: options.chainId,
-          getIdentityToken: options.getIdentityToken
+          getAuthTokenInfo: options.getAuthTokenInfo
         });
         // the connect function could fail silently as well.
-        if (!provider) {
+        if (!connection) {
           this.rehydrated = false;
           throw WalletLoginError.connectionError("Failed to rehydrate.");
         }
@@ -69,7 +69,7 @@ class CoinbaseConnector extends BaseEvmConnector {
   }
   async connect({
     chainId,
-    getIdentityToken
+    getAuthTokenInfo
   }) {
     super.checkConnectionRequirements();
     if (!this.coinbaseProvider) throw WalletLoginError.notConnectedError("Connector is not initialized");
@@ -95,17 +95,20 @@ class CoinbaseConnector extends BaseEvmConnector {
         // ready to be connected again
         this.disconnect();
       });
-      let identityTokenInfo;
       this.emit(CONNECTOR_EVENTS.CONNECTED, {
-        connector: WALLET_CONNECTORS.COINBASE,
+        connectorName: WALLET_CONNECTORS.COINBASE,
         reconnected: this.rehydrated,
-        provider: this.provider,
-        identityTokenInfo
+        ethereumProvider: this.provider,
+        solanaWallet: null
       });
-      if (getIdentityToken) {
-        identityTokenInfo = await this.getIdentityToken();
+      if (getAuthTokenInfo) {
+        await this.getAuthTokenInfo();
       }
-      return this.provider;
+      return {
+        ethereumProvider: this.provider,
+        solanaWallet: null,
+        connectorName: this.name
+      };
     } catch (error) {
       // ready again to be connected
       this.status = CONNECTOR_STATUS.READY;

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) {
@@ -42,11 +42,11 @@ class InjectedEvmConnector extends BaseEvmConnector {
       log.debug(`initializing ${this.name} injected connector`);
       if (options.autoConnect) {
         this.rehydrated = true;
-        const provider = await this.connect({
+        const connection = await this.connect({
           chainId: options.chainId,
-          getIdentityToken: options.getIdentityToken
+          getAuthTokenInfo: options.getAuthTokenInfo
         });
-        if (!provider) {
+        if (!connection) {
           this.rehydrated = false;
           throw WalletLoginError.connectionError("Failed to rehydrate.");
         }
@@ -57,7 +57,7 @@ class InjectedEvmConnector extends BaseEvmConnector {
   }
   async connect({
     chainId,
-    getIdentityToken
+    getAuthTokenInfo
   }) {
     super.checkConnectionRequirements();
     if (!this.injectedProvider) throw WalletLoginError.connectionError("Injected provider is not available");
@@ -89,17 +89,20 @@ class InjectedEvmConnector extends BaseEvmConnector {
         }
       };
       this.injectedProvider.on("accountsChanged", accountDisconnectHandler);
-      let identityTokenInfo;
       this.emit(CONNECTOR_EVENTS.CONNECTED, {
-        connector: this.name,
+        connectorName: this.name,
         reconnected: this.rehydrated,
-        provider: this.injectedProvider,
-        identityTokenInfo
+        ethereumProvider: this.injectedProvider,
+        solanaWallet: null
       });
-      if (getIdentityToken) {
-        identityTokenInfo = await this.getIdentityToken();
+      if (getAuthTokenInfo) {
+        await this.getAuthTokenInfo();
       }
-      return this.injectedProvider;
+      return {
+        ethereumProvider: this.injectedProvider,
+        solanaWallet: null,
+        connectorName: this.name
+      };
     } catch (error) {
       // ready again to be connected
       this.status = CONNECTOR_STATUS.READY;