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

package/dist/lib.cjs/react/solana/provider.js

@@ -0,0 +1,169 @@
+'use strict';
+
+var _objectSpread = require('@babel/runtime/helpers/objectSpread2');
+var _objectWithoutProperties = require('@babel/runtime/helpers/objectWithoutProperties');
+var client = require('@solana/client');
+var reactHooks = require('@solana/react-hooks');
+var react = require('react');
+require('@babel/runtime/helpers/defineProperty');
+require('@segment/analytics-next');
+var loglevel = require('../../base/loglevel.js');
+var baseControllers = require('@toruslabs/base-controllers');
+require('@toruslabs/session-manager');
+require('@web3auth/auth');
+require('../../base/errors/index.js');
+require('@toruslabs/constants');
+require('@toruslabs/http-helpers');
+require('../../base/constants.js');
+require('../../base/wallet/index.js');
+require('../../base/connector/connectorStatus.js');
+require('../../base/connector/constants.js');
+require('jwt-decode');
+require('../../base/plugin/errors.js');
+require('../../base/plugin/IPlugin.js');
+require('../context/Web3AuthInnerContext.js');
+var useChain = require('../hooks/useChain.js');
+require('../context/WalletServicesInnerContext.js');
+var useWeb3Auth = require('../hooks/useWeb3Auth.js');
+
+const _excluded = ["children"];
+const DEVNET_ENDPOINT = "https://api.devnet.solana.com";
+function placeholderRpc(isInitialized, web3Auth) {
+  var _web3Auth$coreOptions;
+  if (!isInitialized || !(web3Auth !== null && web3Auth !== void 0 && (_web3Auth$coreOptions = web3Auth.coreOptions) !== null && _web3Auth$coreOptions !== void 0 && _web3Auth$coreOptions.chains)) {
+    return {
+      rpcTarget: DEVNET_ENDPOINT
+    };
+  }
+  const solanaChains = web3Auth.coreOptions.chains.filter(c => c.chainNamespace === baseControllers.CHAIN_NAMESPACES.SOLANA);
+  const current = web3Auth.currentChain;
+  const chain = (current === null || current === void 0 ? void 0 : current.chainNamespace) === baseControllers.CHAIN_NAMESPACES.SOLANA ? current : solanaChains[0];
+  if (!chain) return {
+    rpcTarget: DEVNET_ENDPOINT
+  };
+  return {
+    rpcTarget: chain.rpcTarget,
+    wsTarget: chain.wsTarget
+  };
+}
+function makePlaceholder(rpc) {
+  return client.createClient({
+    endpoint: rpc.rpcTarget,
+    websocketEndpoint: rpc.wsTarget,
+    walletConnectors: []
+  });
+}
+function dispose(client) {
+  void client.actions.disconnectWallet().catch(() => {});
+  client.destroy();
+}
+/**
+ * Builds the SolanaClient for Framework Kit React hooks: placeholder when idle, Web3Auth-backed when
+ * connected on Solana. Ref + state so React re-renders on swap and effects dispose the right instance.
+ */
+function useFrameworkKitSolanaClient() {
+  const {
+    isConnected,
+    connection,
+    web3Auth,
+    isInitialized
+  } = useWeb3Auth.useWeb3Auth();
+  const {
+    chainNamespace
+  } = useChain.useChain();
+  const ref = react.useRef(null);
+  const [client$1, setClient] = react.useState(() => {
+    const c = makePlaceholder({
+      rpcTarget: DEVNET_ENDPOINT
+    });
+    ref.current = c;
+    return c;
+  });
+  react.useEffect(() => {
+    if (isInitialized) web3Auth === null || web3Auth === void 0 || web3Auth.setAnalyticsProperties({
+      solana_framework_kit_enabled: true
+    });
+  }, [isInitialized, web3Auth]);
+  react.useEffect(() => () => {
+    const c = ref.current;
+    if (c) {
+      dispose(c);
+      ref.current = null;
+    }
+  }, []);
+  react.useEffect(() => {
+    let stale = false;
+    const adopt = next => {
+      if (stale) {
+        dispose(next);
+        return;
+      }
+      const prev = ref.current;
+      if (prev === next) return;
+      if (prev) dispose(prev);
+      ref.current = next;
+      setClient(next);
+    };
+    (async _web3Auth$currentChai => {
+      const rpc = placeholderRpc(isInitialized, web3Auth);
+      const solanaWallet = connection === null || connection === void 0 ? void 0 : connection.solanaWallet;
+      const onSolana = isConnected && Boolean(solanaWallet) && chainNamespace === baseControllers.CHAIN_NAMESPACES.SOLANA && (web3Auth === null || web3Auth === void 0 || (_web3Auth$currentChai = web3Auth.currentChain) === null || _web3Auth$currentChai === void 0 ? void 0 : _web3Auth$currentChai.chainNamespace) === baseControllers.CHAIN_NAMESPACES.SOLANA;
+      if (!onSolana) {
+        adopt(makePlaceholder(rpc));
+        return;
+      }
+      const conn = connection;
+      if (!conn || !solanaWallet) {
+        adopt(makePlaceholder(rpc));
+        return;
+      }
+      // only reconnect for the primary connector
+      if (conn.connectorName !== (web3Auth === null || web3Auth === void 0 ? void 0 : web3Auth.primaryConnectorName)) return;
+      try {
+        const solanaWalletId = "wallet-standard:" + conn.connectorName;
+        const connector = client.createWalletStandardConnector(solanaWallet, {
+          id: solanaWalletId,
+          name: conn.connectorName
+        });
+        const {
+          rpcTarget,
+          wsTarget
+        } = web3Auth.currentChain;
+        const wired = client.createClient({
+          endpoint: rpcTarget,
+          websocketEndpoint: wsTarget,
+          walletConnectors: [connector]
+        });
+        await wired.actions.connectWallet(solanaWalletId, {
+          autoConnect: true
+        });
+        if (stale) {
+          dispose(wired);
+          return;
+        }
+        adopt(wired);
+      } catch (e) {
+        loglevel.log.error("Failed to create or connect Solana client", e);
+        adopt(makePlaceholder(rpc));
+      }
+    })();
+    return () => {
+      stale = true;
+    };
+  }, [isConnected, connection === null || connection === void 0 ? void 0 : connection.solanaWallet, chainNamespace, web3Auth, isInitialized, connection === null || connection === void 0 ? void 0 : connection.connectorName]);
+  return client$1;
+}
+function SolanaProvider(_ref) {
+  let {
+      children
+    } = _ref,
+    props = _objectWithoutProperties(_ref, _excluded);
+  const client = useFrameworkKitSolanaClient();
+  return react.createElement(reactHooks.SolanaProvider, _objectSpread(_objectSpread({}, props), {}, {
+    client,
+    walletPersistence: false,
+    children
+  }));
+}
+
+exports.SolanaProvider = SolanaProvider;

package/dist/lib.cjs/react/wagmi/provider.js

@@ -10,16 +10,18 @@ require('@babel/runtime/helpers/defineProperty');
 require('@segment/analytics-next');
 var loglevel = require('../../base/loglevel.js');
 var baseControllers = require('@toruslabs/base-controllers');
+require('@toruslabs/session-manager');
 require('@web3auth/auth');
 var index = require('../../base/errors/index.js');
+require('@toruslabs/constants');
+require('@toruslabs/http-helpers');
+require('../../base/constants.js');
 require('../../base/wallet/index.js');
 require('../../base/connector/connectorStatus.js');
 require('../../base/connector/constants.js');
 require('jwt-decode');
 require('../../base/plugin/errors.js');
 require('../../base/plugin/IPlugin.js');
-require('@toruslabs/constants');
-require('@toruslabs/http-helpers');
 require('../context/Web3AuthInnerContext.js');
 require('../context/WalletServicesInnerContext.js');
 var useWeb3Auth = require('../hooks/useWeb3Auth.js');
@@ -90,16 +92,16 @@ function Web3AuthWagmiProvider({
 }) {
   const {
     isConnected,
-    provider
+    connection
   } = useWeb3Auth.useWeb3Auth();
   const {
     disconnect
   } = useWeb3AuthDisconnect.useWeb3AuthDisconnect();
   const wagmiConfig = wagmi.useConfig();
   const {
-    reconnect
+    mutate: reconnect
   } = wagmi.useReconnect();
-  wagmi.useAccountEffect({
+  wagmi.useConnectionEffect({
     onDisconnect: async () => {
       loglevel.log.info("Disconnected from wagmi");
       if (isConnected) await disconnect();
@@ -113,8 +115,8 @@ function Web3AuthWagmiProvider({
   });
   react.useEffect(() => {
     (async () => {
-      if (isConnected && provider) {
-        const connector = await setupConnector(provider, wagmiConfig);
+      if (isConnected && connection !== null && connection !== void 0 && connection.ethereumProvider) {
+        const connector = await setupConnector(connection.ethereumProvider, wagmiConfig);
         if (!connector) {
           throw new Error("Failed to setup connector");
         }
@@ -126,7 +128,7 @@ function Web3AuthWagmiProvider({
         }
       }
     })();
-  }, [isConnected, wagmiConfig, provider, reconnect]);
+  }, [isConnected, wagmiConfig, connection, reconnect]);
   return react.createElement(react.Fragment, null, children);
 }
 function WagmiProvider(_ref) {

package/dist/lib.cjs/types/account-linking/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./interfaces";
+export * from "./rest";

package/dist/lib.cjs/types/account-linking/interfaces.d.ts

@@ -0,0 +1,90 @@
+import type { WALLET_CONNECTOR_TYPE } from "../base/wallet";
+export type CITADEL_NETWORK = "ethereum" | "solana";
+export interface LinkAccountParams {
+    /**
+     * Name of the external wallet connector to link.
+     * Example: WALLET_CONNECTORS.METAMASK, WALLET_CONNECTORS.WALLET_CONNECT_V2.
+     *
+     * Optional in the modal SDK (`@web3auth/modal`): when omitted, the modal opens
+     * a wallet picker dedicated to account linking and uses the wallet selected by
+     * the user. Required in the no-modal SDK (`@web3auth/no-modal`).
+     */
+    connectorName: WALLET_CONNECTOR_TYPE | string;
+    /**
+     * Chain ID to use when generating the wallet identity proof.
+     * Defaults to the currently active chain if not specified.
+     */
+    chainId?: string;
+}
+/**
+ * Linked account info returned from the Citadel server
+ */
+export interface BaseLinkedAccountInfo {
+    /** Type of the account (e.g. "social", "external_wallet", "account_abstraction") */
+    accountType: string;
+    /** Address of the account */
+    address: string | null;
+    /** Auth connection id of the account */
+    authConnectionId: string | null;
+    /** Grouped auth connection id of the account */
+    groupedAuthConnectionId?: string | null;
+    /** Chain namespace of the account */
+    chainNamespace: string | null;
+}
+/**
+ * Result returned after a successful account-linking operation.
+ */
+export interface LinkAccountResult {
+    /** Whether the Citadel server accepted the linking request. */
+    success: boolean;
+    /** Refreshed id token for the user */
+    idToken: string;
+    /** Linked account info */
+    linkedAccounts: BaseLinkedAccountInfo[];
+    /** Error message from the Citadel server */
+    message?: string;
+}
+/**
+ * Result returned after a successful account-unlinking operation.
+ */
+export interface UnlinkAccountResult {
+    /** Whether the Citadel server accepted the linking request. */
+    success: boolean;
+    /** Refreshed id token for the user */
+    idToken: string;
+    /** Remaining linked account info */
+    linkedAccounts: BaseLinkedAccountInfo[];
+    /** Error message from the Citadel server */
+    message?: string;
+}
+/**
+ * Payload sent to the Citadel account-linking endpoint.
+ */
+export interface CitadelLinkAccountPayload {
+    /** Current idToken to refresh with updated linked accounts */
+    idToken: string;
+    /** Network of the account being linked */
+    network: CITADEL_NETWORK;
+    /** Name of the connector being linked */
+    connector: string;
+    /** Challenge message to be signed by the user */
+    message: string;
+    /** Sign In with Web3 signature object */
+    signature: {
+        /** signature value */
+        s: string;
+        /** signature type (e.g. "eip191", "sip99") */
+        t: string;
+    };
+}
+/**
+ * Payload sent to the Citadel account-unlinking endpoint.
+ */
+export interface UnlinkAccountPayload {
+    /** Current idToken to refresh with updated linked accounts */
+    idToken: string;
+    /** Address of the account to unlink */
+    address: string;
+    /** Network of the account being unlinked */
+    network: CITADEL_NETWORK;
+}

package/dist/lib.cjs/types/account-linking/react.d.ts

@@ -0,0 +1,19 @@
+import { type LinkedAccountInfo, Web3AuthError } from "../base";
+import { makeAccountLinkingRequest, makeAccountUnlinkingRequest } from "./index";
+import type { BaseLinkedAccountInfo, LinkAccountParams, LinkAccountResult, UnlinkAccountResult } from "./interfaces";
+export { makeAccountLinkingRequest, makeAccountUnlinkingRequest };
+export type { CITADEL_NETWORK, CitadelLinkAccountPayload, LinkAccountParams, LinkAccountResult, BaseLinkedAccountInfo as LinkedAccountInfo, UnlinkAccountPayload, UnlinkAccountResult, } from "./interfaces";
+export interface IUseLinkAccount {
+    loading: boolean;
+    error: Web3AuthError | null;
+    linkedAccounts: BaseLinkedAccountInfo[];
+    linkAccount(params?: LinkAccountParams): Promise<LinkAccountResult | void>;
+    unlinkAccount(address: string): Promise<UnlinkAccountResult | void>;
+}
+export interface IUseSwitchAccount {
+    loading: boolean;
+    error: Web3AuthError | null;
+    switchAccount(account: LinkedAccountInfo): Promise<void>;
+}
+export declare const useLinkAccount: () => IUseLinkAccount;
+export declare const useSwitchAccount: () => IUseSwitchAccount;

package/dist/lib.cjs/types/account-linking/rest.d.ts

@@ -0,0 +1,9 @@
+import { CitadelLinkAccountPayload, LinkAccountResult, UnlinkAccountPayload, UnlinkAccountResult } from "./interfaces";
+/**
+ * Send both identity proofs to the Citadel account-linking endpoint and
+ * return a normalized result.
+ *
+ * Throws AccountLinkingError when the server returns an error or the request itself fails.
+ */
+export declare function makeAccountLinkingRequest(authServerUrl: string, accessToken: string, payload: CitadelLinkAccountPayload): Promise<LinkAccountResult>;
+export declare function makeAccountUnlinkingRequest(authServerUrl: string, accessToken: string, payload: UnlinkAccountPayload): Promise<UnlinkAccountResult>;

package/dist/lib.cjs/types/account-linking/vue.d.ts

@@ -0,0 +1,20 @@
+import { Ref } from "vue";
+import { type LinkedAccountInfo, Web3AuthError } from "../base";
+import { makeAccountLinkingRequest, makeAccountUnlinkingRequest } from "./index";
+import type { BaseLinkedAccountInfo, LinkAccountParams, LinkAccountResult, UnlinkAccountResult } from "./interfaces";
+export { makeAccountLinkingRequest, makeAccountUnlinkingRequest };
+export type { CITADEL_NETWORK, CitadelLinkAccountPayload, LinkAccountParams, LinkAccountResult, BaseLinkedAccountInfo as LinkedAccountInfo, UnlinkAccountPayload, UnlinkAccountResult, } from "./interfaces";
+export interface IUseLinkAccount {
+    loading: Ref<boolean>;
+    error: Ref<Web3AuthError | null>;
+    linkedAccounts: Ref<BaseLinkedAccountInfo[]>;
+    linkAccount(params?: LinkAccountParams): Promise<LinkAccountResult | void>;
+    unlinkAccount(address: string): Promise<UnlinkAccountResult | void>;
+}
+export interface IUseSwitchAccount {
+    loading: Ref<boolean>;
+    error: Ref<Web3AuthError | null>;
+    switchAccount(account: LinkedAccountInfo): Promise<void>;
+}
+export declare const useLinkAccount: () => IUseLinkAccount;
+export declare const useSwitchAccount: () => IUseSwitchAccount;

package/dist/lib.cjs/types/base/analytics.d.ts

@@ -37,6 +37,15 @@ export declare const ANALYTICS_EVENTS: {
     WALLET_CHECKOUT_CLICKED: string;
     WALLET_RECEIVE_CLICKED: string;
     WALLET_SWAP_CLICKED: string;
+    ACCOUNT_LINKING_STARTED: string;
+    ACCOUNT_LINKING_COMPLETED: string;
+    ACCOUNT_LINKING_FAILED: string;
+    ACCOUNT_UNLINKING_STARTED: string;
+    ACCOUNT_UNLINKING_COMPLETED: string;
+    ACCOUNT_UNLINKING_FAILED: string;
+    ACCOUNT_SWITCH_STARTED: string;
+    ACCOUNT_SWITCH_COMPLETED: string;
+    ACCOUNT_SWITCH_FAILED: string;
 };
 export declare const ANALYTICS_INTEGRATION_TYPE: {
     REACT_HOOKS: string;

package/dist/lib.cjs/types/base/connector/baseConnector.d.ts

@@ -1,13 +1,17 @@
+import { type SiwwTokens } from "@toruslabs/base-controllers";
+import { AuthSessionManager } from "@toruslabs/session-manager";
+import type { Wallet } from "@wallet-standard/base";
 import { SafeEventEmitter } from "@web3auth/auth";
-import { ConnectorNamespaceType, CustomChainConfig } from "../chain/IChainInterface";
+import { type ChainNamespaceType, ConnectorNamespaceType, CustomChainConfig } from "../chain/IChainInterface";
 import { WALLET_CONNECTOR_TYPE } from "../wallet";
-import type { BaseConnectorLoginParams, BaseConnectorSettings, CONNECTOR_CATEGORY_TYPE, CONNECTOR_STATUS_TYPE, ConnectorEvents, ConnectorInitOptions, IConnector, IdentityTokenInfo, IProvider, UserInfo } from "./interfaces";
+import type { AuthTokenInfo, BaseConnectorLoginParams, BaseConnectorSettings, Connection, CONNECTOR_CATEGORY_TYPE, CONNECTOR_STATUS_TYPE, ConnectorEvents, ConnectorInitOptions, IConnector, IProvider, UserInfo } from "./interfaces";
 export declare abstract class BaseConnector<T> extends SafeEventEmitter<ConnectorEvents> implements IConnector<T> {
     connectorData?: unknown;
     isInjected?: boolean;
     icon?: string;
     coreOptions: BaseConnectorSettings["coreOptions"];
     protected rehydrated: boolean;
+    protected authSessionManager: AuthSessionManager | null;
     abstract connectorNamespace: ConnectorNamespaceType;
     abstract type: CONNECTOR_CATEGORY_TYPE;
     abstract name: WALLET_CONNECTOR_TYPE | string;
@@ -15,7 +19,8 @@ export declare abstract class BaseConnector<T> extends SafeEventEmitter<Connecto
     constructor(options: BaseConnectorSettings);
     get connected(): boolean;
     get canAuthorize(): boolean;
-    abstract get provider(): IProvider | null;
+    get solanaWallet(): Wallet | null;
+    get provider(): IProvider | null;
     checkConnectionRequirements(): void;
     checkInitializationRequirements({ chainConfig }: {
         chainConfig?: CustomChainConfig;
@@ -25,13 +30,29 @@ export declare abstract class BaseConnector<T> extends SafeEventEmitter<Connecto
         chainId: string;
     }, init?: boolean): void;
     updateConnectorData(data: unknown): void;
+    protected initSessionManager(address: string): void;
+    protected getCachedAuthTokenInfo(): Promise<AuthTokenInfo | null>;
+    protected saveAuthTokenInfo(tokens: SiwwTokens): Promise<void>;
+    protected getCachedOrNullAuthTokenInfo(account: string): Promise<AuthTokenInfo | null>;
+    protected verifyAndAuthorize(params: {
+        chainNamespace: ChainNamespaceType;
+        signedMessage: string;
+        challenge: string;
+        authServer: string;
+    }): Promise<AuthTokenInfo>;
+    protected clearWalletSession(): Promise<void>;
     abstract init(options?: ConnectorInitOptions): Promise<void>;
-    abstract connect(params: T & BaseConnectorLoginParams): Promise<IProvider | null>;
+    abstract connect(params: T & BaseConnectorLoginParams): Promise<Connection | null>;
     abstract disconnect(): Promise<void>;
     abstract getUserInfo(): Promise<Partial<UserInfo>>;
     abstract enableMFA(params?: T): Promise<void>;
     abstract manageMFA(params?: T): Promise<void>;
-    abstract getIdentityToken(): Promise<IdentityTokenInfo>;
+    abstract getAuthTokenInfo(): Promise<AuthTokenInfo>;
+    abstract generateChallengeAndSign(authServerUrl?: string, accounts?: string[]): Promise<{
+        challenge: string;
+        signature: string;
+        chainNamespace: ChainNamespaceType;
+    }>;
     abstract switchChain(params: {
         chainId: string;
     }): Promise<void>;

package/dist/lib.cjs/types/base/connector/connectorStatus.d.ts

@@ -1,3 +1,4 @@
 import { CONNECTOR_STATUS_TYPE } from "./interfaces";
 export declare const CONNECTED_STATUSES: CONNECTOR_STATUS_TYPE[];
 export declare const CAN_AUTHORIZE_STATUSES: CONNECTOR_STATUS_TYPE[];
+export declare const CAN_LOGOUT_STATUSES: CONNECTOR_STATUS_TYPE[];

package/dist/lib.cjs/types/base/connector/constants.d.ts

@@ -8,6 +8,7 @@ export declare const CONNECTOR_STATUS: {
     readonly ERRORED: "errored";
     readonly AUTHORIZED: "authorized";
     readonly AUTHORIZING: "authorizing";
+    readonly CONSENT_REQUIRING: "consent_requiring";
 };
 export declare const CONNECTOR_EVENTS: {
     readonly CONNECTOR_DATA_UPDATED: "connector_data_updated";
@@ -15,6 +16,9 @@ export declare const CONNECTOR_EVENTS: {
     readonly CONNECTORS_UPDATED: "connectors_updated";
     readonly MFA_ENABLED: "mfa_enabled";
     readonly REHYDRATION_ERROR: "rehydration_error";
+    /** Emitted when the active public `connection` changes without a full reconnect (e.g. account switch). */
+    readonly CONNECTION_UPDATED: "connection_updated";
+    readonly CONSENT_ACCEPTED: "consent_accepted";
     readonly NOT_READY: "not_ready";
     readonly READY: "ready";
     readonly CONNECTING: "connecting";
@@ -24,6 +28,7 @@ export declare const CONNECTOR_EVENTS: {
     readonly ERRORED: "errored";
     readonly AUTHORIZED: "authorized";
     readonly AUTHORIZING: "authorizing";
+    readonly CONSENT_REQUIRING: "consent_requiring";
 };
 export declare const CONNECTOR_CATEGORY: {
     readonly EXTERNAL: "external";

package/dist/lib.cjs/types/base/connector/interfaces.d.ts

@@ -1,13 +1,37 @@
+import { CaipAccountId } from "@metamask/connect-evm";
+import type { Wallet } from "@wallet-standard/base";
 import { AUTH_CONNECTION_TYPE, AuthUserInfo, ExtraLoginOptions, JRPCRequest, JRPCResponse, Maybe, RequestArguments, SafeEventEmitter, SendCallBack, UX_MODE, type UX_MODE_TYPE, WEB3AUTH_NETWORK, type WEB3AUTH_NETWORK_TYPE } from "@web3auth/auth";
+import { BaseLinkedAccountInfo } from "../../account-linking/interfaces";
 import { type Analytics } from "../analytics";
 import type { ChainNamespaceType, ConnectorNamespaceType, CustomChainConfig } from "../chain/IChainInterface";
 import type { IWeb3AuthCoreOptions } from "../core/IWeb3Auth";
 import { Web3AuthError } from "../errors";
-import type { ProjectConfig } from "../interfaces";
+import type { LoginModeType, ProjectConfig } from "../interfaces";
 import type { ProviderEvents, SafeEventEmitterProvider } from "../provider/IProvider";
 import { WALLET_CONNECTOR_TYPE } from "../wallet";
 import { CONNECTOR_CATEGORY, CONNECTOR_EVENTS, CONNECTOR_STATUS } from "./constants";
-export type UserInfo = AuthUserInfo;
+/**
+ *
+ */
+export interface LinkedAccountInfo extends BaseLinkedAccountInfo {
+    /** Linked account id */
+    id: string;
+    /** Whether the account is the primary account for the user */
+    isPrimary: boolean;
+    /** Wallet address of the connected account */
+    eoaAddress: string;
+    /** Address of the account abstraction for the account */
+    aaAddress?: string;
+    /** Provider of the account abstraction for the account */
+    aaProvider?: string;
+    /** Connector name of the account */
+    connector: string;
+    /** Indicates if the account is the active account */
+    active: boolean;
+}
+export type UserInfo = AuthUserInfo & {
+    linkedAccounts?: LinkedAccountInfo[];
+};
 export { UX_MODE, UX_MODE_TYPE, WEB3AUTH_NETWORK, WEB3AUTH_NETWORK_TYPE };
 export type CONNECTOR_CATEGORY_TYPE = (typeof CONNECTOR_CATEGORY)[keyof typeof CONNECTOR_CATEGORY];
 export interface ConnectorInitOptions {
@@ -20,13 +44,15 @@ export interface ConnectorInitOptions {
      */
     chainId: string;
     /**
-     * Whether to get the identity token
+     * Whether to fetch auth token info (id / access / refresh tokens)
      */
-    getIdentityToken?: boolean;
+    getAuthTokenInfo?: boolean;
 }
 export type CONNECTOR_STATUS_TYPE = (typeof CONNECTOR_STATUS)[keyof typeof CONNECTOR_STATUS];
-export type IdentityTokenInfo = {
+export type AuthTokenInfo = {
     idToken: string;
+    accessToken?: string;
+    refreshToken?: string;
 };
 export interface BaseConnectorSettings {
     coreOptions: IWeb3AuthCoreOptions;
@@ -49,12 +75,18 @@ export interface IBaseProvider<T> extends IProvider {
     updateProviderEngineProxy(provider: SafeEventEmitterProvider): void;
     setKeyExportFlag(flag: boolean): void;
 }
+export interface Connection {
+    readonly ethereumProvider: IProvider | null;
+    readonly solanaWallet: Wallet | null;
+    readonly connectorName: WALLET_CONNECTOR_TYPE | string;
+}
 export interface IConnector<T> extends SafeEventEmitter {
     connectorNamespace: ConnectorNamespaceType;
     type: CONNECTOR_CATEGORY_TYPE;
     name: WALLET_CONNECTOR_TYPE | string;
     status: CONNECTOR_STATUS_TYPE;
     provider: IProvider | null;
+    readonly solanaWallet: Wallet | null;
     connectorData?: unknown;
     connected: boolean;
     isInjected?: boolean;
@@ -63,16 +95,19 @@ export interface IConnector<T> extends SafeEventEmitter {
     disconnect(options?: {
         cleanup: boolean;
     }): Promise<void>;
-    connect(params: T & {
-        chainId: string;
-    }): Promise<IProvider | null>;
+    connect(params: T & BaseConnectorLoginParams): Promise<Connection | null>;
     getUserInfo(): Promise<Partial<UserInfo>>;
     enableMFA(params?: T): Promise<void>;
     manageMFA(params?: T): Promise<void>;
     switchChain(params: {
         chainId: string;
     }): Promise<void>;
-    getIdentityToken(): Promise<IdentityTokenInfo>;
+    getAuthTokenInfo(): Promise<AuthTokenInfo>;
+    generateChallengeAndSign(authServerUrl?: string, accounts?: string[]): Promise<{
+        challenge: string;
+        signature: string;
+        chainNamespace: ChainNamespaceType;
+    }>;
     cleanup?(): Promise<void>;
 }
 export type ConnectorParams = {
@@ -82,28 +117,38 @@ export type ConnectorParams = {
 };
 export type BaseConnectorLoginParams = {
     chainId: string;
-    getIdentityToken: boolean;
+    getAuthTokenInfo?: boolean;
+    /**
+     * for metamask connector, array of caip account ids to be used for connecting to the wallet
+     */
+    caipAccountIds?: CaipAccountId[];
+    /**
+     * Whether the connection is for the primary account or account linking
+     */
+    isAccountLinking?: boolean;
 };
 export type ConnectorFn = (params: ConnectorParams) => IConnector<unknown>;
-export type CONNECTED_EVENT_DATA = {
-    connector: WALLET_CONNECTOR_TYPE | string;
-    provider: IProvider;
+export type CONNECTED_EVENT_DATA = Connection & {
     reconnected: boolean;
-    identityTokenInfo: IdentityTokenInfo;
+    pendingUserConsent?: boolean;
+};
+export type DISCONNECTED_EVENT_DATA = {
+    connector: WALLET_CONNECTOR_TYPE | string;
 };
 export type AUTHORIZED_EVENT_DATA = {
     connector: WALLET_CONNECTOR_TYPE | string;
-    identityTokenInfo: IdentityTokenInfo;
+    authTokenInfo: AuthTokenInfo;
 };
 export interface IConnectorDataEvent {
     connectorName: string;
     data: unknown;
 }
+export type CONNECTION_UPDATED_EVENT_DATA = Connection;
 export type ConnectorEvents = {
     [CONNECTOR_EVENTS.NOT_READY]: () => void;
     [CONNECTOR_EVENTS.READY]: (connector: WALLET_CONNECTOR_TYPE | string) => void;
     [CONNECTOR_EVENTS.CONNECTED]: (data: CONNECTED_EVENT_DATA) => void;
-    [CONNECTOR_EVENTS.DISCONNECTED]: () => void;
+    [CONNECTOR_EVENTS.DISCONNECTED]: (data?: DISCONNECTED_EVENT_DATA) => void;
     [CONNECTOR_EVENTS.CONNECTING]: (data: {
         connector: WALLET_CONNECTOR_TYPE | string;
     }) => void;
@@ -119,6 +164,11 @@ export type ConnectorEvents = {
         connectors: IConnector<unknown>[];
     }) => void;
     [CONNECTOR_EVENTS.MFA_ENABLED]: (isMFAEnabled: boolean) => void;
+    [CONNECTOR_EVENTS.CONSENT_REQUIRING]: (data: CONNECTED_EVENT_DATA) => void;
+    [CONNECTOR_EVENTS.CONSENT_ACCEPTED]: (data: CONNECTED_EVENT_DATA & {
+        loginMode: LoginModeType;
+    }) => void;
+    [CONNECTOR_EVENTS.CONNECTION_UPDATED]: (data: CONNECTION_UPDATED_EVENT_DATA) => void;
 };
 export interface BaseConnectorConfig {
     label: string;
@@ -188,3 +238,9 @@ export type WalletConnectV2Data = {
 export type MetaMaskConnectorData = {
     uri: string;
 };
+export type ConnectedAccountsWithProviders = Omit<LinkedAccountInfo, "connector"> & {
+    connector: IConnector<unknown>;
+    signingProvider: IProvider | null;
+    solanaWallet: Connection["solanaWallet"];
+    connected: boolean;
+};

package/dist/lib.cjs/types/base/connector/utils.d.ts

@@ -1,5 +1,2 @@
 export declare function storageAvailable(type: "sessionStorage" | "localStorage"): boolean;
 export declare const checkIfTokenIsExpired: (token: string) => boolean;
-export declare const getSavedToken: (userAddress: string, issuer: string) => string;
-export declare const saveToken: (userAddress: string, issuer: string, token: string) => void;
-export declare const clearToken: (userAddress: string, issuer: string) => void;

package/dist/lib.cjs/types/base/constants.d.ts

@@ -17,4 +17,5 @@ export declare const LOGIN_MODE: {
     readonly NO_MODAL: "no-modal";
 };
 export declare const SOLANA_CAIP_CHAIN_MAP: Record<string, string>;
+export declare const EIP_7702_SUPPORTED_SMART_ACCOUNTS: readonly ["metamask"];
 export declare const WALLET_REGISTRY_URL = "https://assets.web3auth.io/v2/wallet-registry.json";