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

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

@@ -1,5 +1,7 @@
+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";
@@ -8,7 +10,28 @@ 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 {
@@ -72,9 +95,7 @@ export interface IConnector<T> extends SafeEventEmitter {
     disconnect(options?: {
         cleanup: boolean;
     }): Promise<void>;
-    connect(params: T & {
-        chainId: string;
-    }): Promise<Connection | null>;
+    connect(params: T & BaseConnectorLoginParams): Promise<Connection | null>;
     getUserInfo(): Promise<Partial<UserInfo>>;
     enableMFA(params?: T): Promise<void>;
     manageMFA(params?: T): Promise<void>;
@@ -82,6 +103,11 @@ export interface IConnector<T> extends SafeEventEmitter {
         chainId: string;
     }): Promise<void>;
     getAuthTokenInfo(): Promise<AuthTokenInfo>;
+    generateChallengeAndSign(authServerUrl?: string, accounts?: string[]): Promise<{
+        challenge: string;
+        signature: string;
+        chainNamespace: ChainNamespaceType;
+    }>;
     cleanup?(): Promise<void>;
 }
 export type ConnectorParams = {
@@ -91,13 +117,24 @@ export type ConnectorParams = {
 };
 export type BaseConnectorLoginParams = {
     chainId: string;
-    getAuthTokenInfo: 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 = Connection & {
     reconnected: boolean;
     pendingUserConsent?: boolean;
 };
+export type DISCONNECTED_EVENT_DATA = {
+    connector: WALLET_CONNECTOR_TYPE | string;
+};
 export type AUTHORIZED_EVENT_DATA = {
     connector: WALLET_CONNECTOR_TYPE | string;
     authTokenInfo: AuthTokenInfo;
@@ -106,11 +143,12 @@ 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;
@@ -130,6 +168,7 @@ export type ConnectorEvents = {
     [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;
@@ -199,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/core/IWeb3Auth.d.ts

@@ -1,8 +1,9 @@
 import { type AccountAbstractionMultiChainConfig } from "@toruslabs/ethereum-controllers";
 import { type BUILD_ENV_TYPE, type CookieOptions, type LoginParams, MfaLevelType, MfaSettings, SafeEventEmitter, type StorageConfig, UX_MODE_TYPE, type WhiteLabelData } from "@web3auth/auth";
 import { type WsEmbedParams } from "@web3auth/ws-embed";
+import { type LinkAccountParams, type LinkAccountResult, UnlinkAccountResult } from "../../account-linking";
 import { type ChainNamespaceType, type CustomChainConfig } from "../chain/IChainInterface";
-import { type AuthTokenInfo, CONNECTED_EVENT_DATA, type Connection, CONNECTOR_EVENTS, CONNECTOR_INITIAL_AUTHENTICATION_MODE, type CONNECTOR_STATUS_TYPE, ConnectorEvents, type ConnectorFn, type IBaseProvider, type IConnector, type UserInfo, type WEB3AUTH_NETWORK_TYPE } from "../connector";
+import { type AuthTokenInfo, CONNECTED_EVENT_DATA, type Connection, CONNECTION_UPDATED_EVENT_DATA, CONNECTOR_EVENTS, CONNECTOR_INITIAL_AUTHENTICATION_MODE, type CONNECTOR_STATUS_TYPE, ConnectorEvents, type ConnectorFn, type IBaseProvider, type IConnector, LinkedAccountInfo, type UserInfo, type WEB3AUTH_NETWORK_TYPE } from "../connector";
 import { Web3AuthError } from "../errors";
 import { LoginModeType } from "../interfaces";
 import { type IPlugin, type PluginFn } from "../plugin";
@@ -138,6 +139,11 @@ export interface IWeb3AuthCoreOptions {
      * @defaultValue "connect-and-sign"
      */
     initialAuthenticationMode?: ConnectorInitialAuthenticationModeType;
+    /**
+     * Whether to disable analytics
+     * @defaultValue false
+     */
+    disableAnalytics?: boolean;
 }
 export type LoginParamMap = {
     [WALLET_CONNECTORS.AUTH]: Partial<AuthLoginParams>;
@@ -154,7 +160,7 @@ export type LoginParamMap = {
 export interface IWeb3AuthCore extends SafeEventEmitter {
     currentChainId: string | null;
     readonly coreOptions: IWeb3AuthCoreOptions;
-    connectedConnectorName: WALLET_CONNECTOR_TYPE | null;
+    primaryConnectorName: WALLET_CONNECTOR_TYPE | null;
     currentChain: CustomChainConfig | undefined;
     status: CONNECTOR_STATUS_TYPE;
     connection: Connection | null;
@@ -186,6 +192,36 @@ export interface IWeb3Auth extends IWeb3AuthCore {
     manageMFA<T>(params: T): Promise<void>;
     setAnalyticsProperties(properties: Record<string, unknown>): void;
     cleanup(): Promise<void>;
+    /**
+     * Switch the active connection to a linked wallet: connects an isolated
+     * instance of that wallet’s connector, updates `connection.ethereumProvider` / `solanaWallet`,
+     * and emits `connection_updated` so Wagmi/UI can resync.
+     * The auxiliary connector stays connected (not torn down after switch). The previous auxiliary
+     * connector is disconnected when starting another switch or when the primary session disconnects.
+     *
+     * Requires an AUTH primary session and a matching `userInfo.linkedAccounts` entry.
+     */
+    switchAccount(account: LinkedAccountInfo): Promise<void>;
+    /**
+     * Link an external wallet to the currently authenticated user account
+     * via the Citadel account-linking endpoint.
+     *
+     * Requires:
+     * - The user to be currently connected with the AUTH connector.
+     * - `accountLinking.serverUrl` to be set in the Web3Auth constructor options.
+     *
+     * @param params - Linking parameters including the target connector name.
+     * @returns A result object confirming the link, including the linked address.
+     */
+    linkAccount(params?: LinkAccountParams): Promise<LinkAccountResult>;
+    /**
+     * Unlink an external wallet from the currently authenticated user account
+     * via the Citadel account-unlinking endpoint.
+     *
+     * @param params - Unlinking parameters including the target account address.
+     * @returns A result object confirming the unlink.
+     */
+    unlinkAccount(address: string): Promise<UnlinkAccountResult>;
 }
 export type SDK_CONNECTED_EVENT_DATA = CONNECTED_EVENT_DATA & {
     loginMode: LoginModeType;
@@ -200,6 +236,7 @@ export type Web3AuthNoModalEvents = Omit<ConnectorEvents, "connected" | "errored
     [CONNECTOR_EVENTS.CONSENT_REQUIRING]: () => void;
     [CONNECTOR_EVENTS.CONSENT_ACCEPTED]: (data: SDK_CONSENT_ACCEPTED_EVENT_DATA) => void;
     [CONNECTOR_EVENTS.ERRORED]: (error: Web3AuthError, loginMode: LoginModeType) => void;
+    [CONNECTOR_EVENTS.CONNECTION_UPDATED]: (data: CONNECTION_UPDATED_EVENT_DATA) => void;
     MODAL_VISIBILITY: (visibility: boolean) => void;
 };
 export type Web3AuthNoModalOptions = IWeb3AuthCoreOptions;

package/dist/lib.cjs/types/base/errors/index.d.ts

@@ -57,6 +57,19 @@ export declare class WalletOperationsError extends Web3AuthError {
     static operationNotAllowed(extraMessage?: string, cause?: unknown): IWeb3AuthError;
     static chainNamespaceNotAllowed(extraMessage?: string, cause?: unknown): IWeb3AuthError;
 }
+export declare class AccountLinkingError extends Web3AuthError {
+    protected static messages: ErrorCodes;
+    constructor(code: number, message?: string, cause?: unknown);
+    static fromCode(code: number, extraMessage?: string, cause?: unknown): AccountLinkingError;
+    static requestFailed(extraMessage?: string, cause?: unknown): AccountLinkingError;
+    static serverNotConfigured(extraMessage?: string, cause?: unknown): AccountLinkingError;
+    static primaryTokenNotAvailable(extraMessage?: string, cause?: unknown): AccountLinkingError;
+    static walletProofFailed(extraMessage?: string, cause?: unknown): AccountLinkingError;
+    static unsupportedConnector(extraMessage?: string, cause?: unknown): AccountLinkingError;
+    static cannotUnlinkActiveAccount(): AccountLinkingError;
+    static accountNotLinked(message?: string, cause?: unknown): AccountLinkingError;
+    static cannotUnlinkPrimaryAccount(): AccountLinkingError;
+}
 export declare class WalletProviderError extends Web3AuthError {
     protected static messages: ErrorCodes;
     constructor(code: number, message?: string, cause?: unknown);

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

@@ -2,6 +2,7 @@ import { type BUTTON_POSITION_TYPE } from "@toruslabs/base-controllers";
 import type { SmartAccountEipStandardType, SmartAccountType } from "@toruslabs/ethereum-controllers";
 import { AuthConnectionConfigItem, type WhiteLabelData } from "@web3auth/auth";
 import { type ChainNamespaceType, type CustomChainConfig } from "./chain/IChainInterface";
+import { LinkedAccountInfo } from "./connector";
 import { LOGIN_MODE, MODAL_SIGN_IN_METHODS, SMART_ACCOUNT_WALLET_SCOPE, WIDGET_TYPE } from "./constants";
 import { WALLET_CONNECTOR_TYPE } from "./wallet";
 export interface WhitelistResponse {
@@ -10,11 +11,12 @@ export interface WhitelistResponse {
 }
 export interface IWeb3AuthState {
     cachedConnector: string | null;
-    connectedConnectorName: WALLET_CONNECTOR_TYPE | null;
+    primaryConnectorName: WALLET_CONNECTOR_TYPE | null;
     currentChainId: string;
     idToken: string | null;
     accessToken: string | null;
     refreshToken: string | null;
+    activeAccount: LinkedAccountInfo | null;
     hasUserConsent?: boolean;
 }
 export type ChainsConfig = CustomChainConfig[];

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

@@ -1,4 +1,4 @@
-import { cloneDeep } from "@toruslabs/base-controllers";
+import { ChainNamespaceType, cloneDeep } from "@toruslabs/base-controllers";
 import { type AccountAbstractionMultiChainConfig } from "@toruslabs/ethereum-controllers";
 import { type BUILD_ENV_TYPE } from "@web3auth/auth";
 import { type Chain } from "viem";
@@ -67,3 +67,9 @@ export declare const getErrorAnalyticsProperties: (error: unknown) => {
 };
 export declare const getHostname: (url: string) => string;
 export declare const getCaipChainId: (chain: Pick<CustomChainConfig, "chainNamespace" | "chainId">) => string;
+/**
+ * Parse the chain namespace from the citadel response
+ * @param chainNamespace - The chain namespace from the citadel response
+ * @returns The parsed chain namespace
+ */
+export declare const parseChainNamespaceFromCitadelResponse: (chainNamespace: string) => ChainNamespaceType;

package/dist/lib.cjs/types/connectors/auth-connector/authConnector.d.ts

@@ -1,9 +1,11 @@
+import { ChainNamespaceType } from "@toruslabs/base-controllers";
 import type { Wallet } from "@wallet-standard/base";
 import { Auth, AuthConnectionConfigItem } from "@web3auth/auth";
 import { type default as WsEmbed } from "@web3auth/ws-embed";
-import { AuthLoginParams, AuthTokenInfo, BaseConnector, BaseConnectorLoginParams, type Connection, CONNECTOR_CATEGORY_TYPE, CONNECTOR_STATUS_TYPE, ConnectorFn, ConnectorInitOptions, ConnectorNamespaceType, IProvider, UserInfo, WALLET_CONNECTOR_TYPE } from "../../base";
-import type { AuthConnectorOptions, PrivateKeyProvider } from "./interface";
-declare class AuthConnector extends BaseConnector<AuthLoginParams> {
+import { LinkAccountResult, UnlinkAccountResult } from "../../account-linking";
+import { AccountLinkingError, AuthLoginParams, AuthTokenInfo, BaseConnector, BaseConnectorLoginParams, type Connection, CONNECTOR_CATEGORY_TYPE, CONNECTOR_STATUS_TYPE, ConnectorFn, ConnectorInitOptions, ConnectorNamespaceType, IConnector, IProvider, LinkedAccountInfo, UserInfo, WALLET_CONNECTOR_TYPE } from "../../base";
+import { type AuthConnectorLinkAccountParams, type AuthConnectorOptions, type AuthConnectorSwitchAccountContext, type AuthConnectorSwitchAccountResult, type AuthConnectorUnlinkAccountParams, IAuthConnector, type PrivateKeyProvider } from "./interface";
+declare class AuthConnector extends BaseConnector<AuthLoginParams> implements IAuthConnector {
     readonly name: WALLET_CONNECTOR_TYPE;
     readonly connectorNamespace: ConnectorNamespaceType;
     readonly type: CONNECTOR_CATEGORY_TYPE;
@@ -17,6 +19,7 @@ declare class AuthConnector extends BaseConnector<AuthLoginParams> {
     private authConnectionConfig;
     private wsEmbedInstancePromise;
     private _solanaWallet;
+    private analytics;
     constructor(params: AuthConnectorOptions);
     get provider(): IProvider | null;
     get wsEmbed(): WsEmbed;
@@ -31,6 +34,7 @@ declare class AuthConnector extends BaseConnector<AuthLoginParams> {
     }): Promise<void>;
     getAuthTokenInfo(): Promise<AuthTokenInfo>;
     getUserInfo(): Promise<Partial<UserInfo>>;
+    getLinkedAccounts(): Promise<LinkedAccountInfo[]>;
     switchChain(params: {
         chainId: string;
     }, init?: boolean): Promise<void>;
@@ -38,6 +42,24 @@ declare class AuthConnector extends BaseConnector<AuthLoginParams> {
     getOAuthProviderConfig(params: Pick<AuthLoginParams, "authConnection" | "authConnectionId" | "groupedAuthConnectionId">): AuthConnectionConfigItem & {
         isDefault?: boolean;
     };
+    generateChallengeAndSign(): Promise<{
+        challenge: string;
+        signature: string;
+        chainNamespace: ChainNamespaceType;
+    }>;
+    switchAccount(account: LinkedAccountInfo, context: AuthConnectorSwitchAccountContext): Promise<AuthConnectorSwitchAccountResult>;
+    trackSwitchAccountCompleted(account: LinkedAccountInfo): Promise<void>;
+    trackSwitchAccountFailed(account: Pick<LinkedAccountInfo, "id" | "accountType" | "eoaAddress">, error: unknown): Promise<void>;
+    linkAccount(params: AuthConnectorLinkAccountParams): Promise<LinkAccountResult>;
+    unlinkAccount(params: AuthConnectorUnlinkAccountParams): Promise<UnlinkAccountResult>;
+    getChainIdForLinkedAccount(account: Pick<LinkedAccountInfo, "chainNamespace" | "connector">, preferredChainId?: string | null): string;
+    assertSwitchAccountConnectorMatchesTarget(connector: IConnector<unknown>, account: Pick<LinkedAccountInfo, "chainNamespace" | "connector" | "eoaAddress">): Promise<void>;
+    toSwitchAccountConnectorError(account: Pick<LinkedAccountInfo, "connector" | "eoaAddress">, error: unknown): AccountLinkingError;
+    private getSwitchAccountTrackData;
+    private getPrimaryAuthSession;
+    private getNetworkForUnlinkAddress;
+    private createWalletLinkingProof;
+    private getLinkingWalletAddress;
     private setupSolanaWallet;
     private _getFinalPrivKey;
     private connectWithProvider;
@@ -52,5 +74,7 @@ type AuthConnectorFuncParams = Omit<AuthConnectorOptions, "coreOptions" | "authC
     connectorSettings?: Omit<AuthConnectorOptions["connectorSettings"], "buildEnv">;
 };
 export declare const authConnector: (params?: AuthConnectorFuncParams) => ConnectorFn;
+export declare function isAuthConnector(connector: IConnector<unknown> | null | undefined): connector is AuthConnectorType;
+export declare function assertAuthConnector(connector: IConnector<unknown> | null | undefined, errorMessage?: string): asserts connector is AuthConnectorType;
 export type AuthConnectorType = AuthConnector;
 export {};

package/dist/lib.cjs/types/connectors/auth-connector/interface.d.ts

@@ -1,11 +1,46 @@
-import { type AuthConnectionConfigItem, type AuthOptions, type LoginParams } from "@web3auth/auth";
+import type { Wallet } from "@wallet-standard/base";
+import { type AuthConnectionConfigItem, type AuthOptions, type LoginParams, type WEB3AUTH_NETWORK_TYPE } from "@web3auth/auth";
 import { type WsEmbedParams } from "@web3auth/ws-embed";
-import { type BaseConnectorSettings, type IBaseProvider } from "../../base";
+import { LinkAccountResult, UnlinkAccountResult } from "../../account-linking";
+import { type BaseConnectorSettings, type ConnectorNamespaceType, type IBaseProvider, type IConnector, type IProvider, type LinkedAccountInfo, type WALLET_CONNECTOR_TYPE } from "../../base";
 export type LoginSettings = Partial<LoginParams>;
 export type PrivateKeyProvider = IBaseProvider<string>;
 export type WalletServicesSettings = Omit<WsEmbedParams, "chains" | "chainId"> & {
     modalZIndex?: number;
 };
+export interface AuthConnectorSessionTokens {
+    accessToken: string | null;
+    idToken: string | null;
+}
+export interface AuthConnectorLinkAccountParams {
+    authSessionTokens: AuthConnectorSessionTokens;
+    walletConnector: IConnector<unknown>;
+    connectorName: WALLET_CONNECTOR_TYPE | string;
+    chainId?: string;
+}
+export interface AuthConnectorSwitchAccountContext {
+    activeAccount: LinkedAccountInfo | null;
+    currentChainId: string | null;
+}
+export type AuthConnectorSwitchAccountResult = {
+    kind: "primary";
+    targetAccount: LinkedAccountInfo;
+    activeAccount: null;
+    activeChainId: string;
+    connectorName: WALLET_CONNECTOR_TYPE;
+    connectorNamespace: ConnectorNamespaceType;
+    ethereumProvider: IProvider | null;
+    solanaWallet: Wallet | null;
+} | {
+    kind: "external";
+    targetAccount: LinkedAccountInfo;
+    activeAccount: LinkedAccountInfo;
+    activeChainId: string;
+};
+export interface AuthConnectorUnlinkAccountParams {
+    authSessionTokens: AuthConnectorSessionTokens;
+    address: string;
+}
 export interface AuthConnectorOptions extends BaseConnectorSettings {
     connectorSettings?: Omit<AuthOptions, "clientId" | "network" | "authConnectionConfig" | "mfaSettings">;
     loginSettings?: LoginSettings;
@@ -14,4 +49,44 @@ export interface AuthConnectorOptions extends BaseConnectorSettings {
         isDefault?: boolean;
     })[];
 }
+export interface UserInfoWithLinkedAccounts {
+    /** User id from the Citadel Server */
+    id: string;
+    /** Connection id of the user */
+    connectionId: string;
+    /** Identifier of the user. e.g. email, sub */
+    identifier: string;
+    /** Public address of the user */
+    publicAddress: string;
+    /** Web3Auth network of the user */
+    web3AuthNetwork: WEB3AUTH_NETWORK_TYPE;
+    /** Type of the user. e.g. v1, v2 */
+    userType: string;
+    /** Connected accounts info, including the primary account */
+    accounts: LinkedAccountInfo[];
+    /** Created at timestamp of the user */
+    createdAt: string;
+    /** Updated at timestamp of the user */
+    updatedAt: string;
+}
 export { AUTH_CONNECTION, type AUTH_CONNECTION_TYPE, type AuthConnectionConfig, type AuthOptions, type AuthUserInfo, type LoginParams, MFA_FACTOR, type MFA_FACTOR_TYPE, MFA_LEVELS, type MFA_SETTINGS, type MfaLevelType, } from "@web3auth/auth";
+export interface IAuthConnector {
+    /**
+     * Resolve the target account and connector-owned switch metadata.
+     * `noModal` applies the returned result to SDK state and providers.
+     */
+    switchAccount(account: LinkedAccountInfo, context: AuthConnectorSwitchAccountContext): Promise<AuthConnectorSwitchAccountResult>;
+    /**
+     * Link an external wallet to the authenticated user by using the
+     * `noModal`-provided isolated wallet connector to generate the proof.
+     */
+    linkAccount(params: AuthConnectorLinkAccountParams): Promise<LinkAccountResult>;
+    /**
+     * Unlink an external wallet from the authenticated user account.
+     */
+    unlinkAccount(params: AuthConnectorUnlinkAccountParams): Promise<UnlinkAccountResult>;
+    /**
+     * Get the connected accounts for the authenticated user.
+     */
+    getLinkedAccounts(): Promise<LinkedAccountInfo[]>;
+}

package/dist/lib.cjs/types/connectors/base-evm-connector/baseEvmConnector.d.ts

@@ -1,7 +1,13 @@
+import { ChainNamespaceType } from "@toruslabs/base-controllers";
 import { AuthTokenInfo, BaseConnector, ConnectorInitOptions } from "../../base";
 export declare abstract class BaseEvmConnector<T> extends BaseConnector<T> {
     init(_?: ConnectorInitOptions): Promise<void>;
     getAuthTokenInfo(): Promise<AuthTokenInfo>;
+    generateChallengeAndSign(authServerUrl?: string, accounts?: string[]): Promise<{
+        challenge: string;
+        signature: string;
+        chainNamespace: ChainNamespaceType;
+    }>;
     disconnectSession(): Promise<void>;
     disconnect(): Promise<void>;
 }

package/dist/lib.cjs/types/connectors/base-solana-connector/baseSolanaConnector.d.ts

@@ -1,7 +1,13 @@
+import { ChainNamespaceType } from "@toruslabs/base-controllers";
 import { AuthTokenInfo, BaseConnector, ConnectorInitOptions } from "../../base";
 export declare abstract class BaseSolanaConnector<T> extends BaseConnector<T> {
     init(_?: ConnectorInitOptions): Promise<void>;
     getAuthTokenInfo(): Promise<AuthTokenInfo>;
+    generateChallengeAndSign(authServerUrl?: string, accounts?: string[]): Promise<{
+        challenge: string;
+        signature: string;
+        chainNamespace: ChainNamespaceType;
+    }>;
     disconnectSession(): Promise<void>;
     disconnect(): Promise<void>;
 }

package/dist/lib.cjs/types/index.d.ts

@@ -1,3 +1,4 @@
+export * from "./account-linking";
 export * from "./base";
 export * from "./connectors";
 export * from "./noModal";

package/dist/lib.cjs/types/noModal.d.ts

@@ -1,7 +1,10 @@
 import { SafeEventEmitter } from "@web3auth/auth";
-import { Analytics, type AuthTokenInfo, type ChainNamespaceType, type Connection, type CONNECTOR_STATUS_TYPE, type CustomChainConfig, type IConnector, type IPlugin, type IProvider, type IWeb3Auth, type IWeb3AuthCoreOptions, IWeb3AuthState, LoginModeType, type LoginParamMap, type ProjectConfig, type UserInfo, type WALLET_CONNECTOR_TYPE, type Web3AuthNoModalEvents } from "./base";
+import { type LinkAccountParams, type LinkAccountResult, UnlinkAccountResult } from "./account-linking";
+import { Analytics, type AuthTokenInfo, type ChainNamespaceType, ConnectedAccountsWithProviders, type Connection, type CONNECTOR_STATUS_TYPE, type CustomChainConfig, type IConnector, type IPlugin, type IProvider, type IWeb3Auth, type IWeb3AuthCoreOptions, IWeb3AuthState, LinkedAccountInfo, LoginModeType, type LoginParamMap, type ProjectConfig, type UserInfo, type WALLET_CONNECTOR_TYPE, type Web3AuthNoModalEvents } from "./base";
+import { type AuthConnectorSwitchAccountResult, type AuthConnectorType } from "./connectors/auth-connector";
 import { type AccountAbstractionProvider } from "./providers/account-abstraction-provider";
 import { CommonJRPCProvider } from "./providers/base-provider";
+type ConnectedWalletAccountRef = LinkedAccountInfo | Pick<LinkedAccountInfo, "id" | "isPrimary"> | null | undefined;
 export declare class Web3AuthNoModal extends SafeEventEmitter<Web3AuthNoModalEvents> implements IWeb3Auth {
     readonly coreOptions: IWeb3AuthCoreOptions;
     status: CONNECTOR_STATUS_TYPE;
@@ -12,20 +15,33 @@ export declare class Web3AuthNoModal extends SafeEventEmitter<Web3AuthNoModalEve
     protected analytics: Analytics;
     protected plugins: Record<string, IPlugin>;
     protected consentRequired: boolean;
+    protected projectConfig: ProjectConfig | null;
     private storage;
-    private currentConnection;
-    private currentConnectionReconnected;
+    private connectionReconnected;
+    /** Connected wallet state keyed by linked account id; the primary session uses a reserved key. */
+    private connectedWalletConnectorMap;
+    private activeWalletConnectorKey;
     private state;
     constructor(options: IWeb3AuthCoreOptions, initialState?: Partial<IWeb3AuthState>);
     get currentChain(): CustomChainConfig | undefined;
     get connected(): boolean;
     get connection(): Connection | null;
-    get connectedConnectorName(): WALLET_CONNECTOR_TYPE | null;
+    get primaryConnectorName(): WALLET_CONNECTOR_TYPE | null;
     get cachedConnector(): string | null;
     get currentChainId(): string | null;
-    get connectedConnector(): IConnector<unknown> | null;
+    /**
+     * This is always the primary connector that is connected to the user.
+     */
+    get primaryConnector(): IConnector<unknown> | null;
     get accountAbstractionProvider(): AccountAbstractionProvider | null;
     get idToken(): string | null;
+    get accessToken(): string | null;
+    get refreshToken(): string | null;
+    protected get activeAccount(): LinkedAccountInfo | null;
+    /**
+     * This is the current active connector.
+     */
+    private get activeConnector();
     set provider(_: IProvider | null);
     init(options?: {
         signal?: AbortSignal;
@@ -45,10 +61,15 @@ export declare class Web3AuthNoModal extends SafeEventEmitter<Web3AuthNoModalEve
         cleanup: boolean;
     }): Promise<void>;
     getUserInfo(): Promise<Partial<UserInfo>>;
+    getLinkedAccounts(): Promise<LinkedAccountInfo[]>;
+    getConnectedAccountsWithProviders(): ConnectedAccountsWithProviders[];
     enableMFA<T>(loginParams?: T): Promise<void>;
     manageMFA<T>(loginParams?: T): Promise<void>;
     getAuthTokenInfo(): Promise<Pick<AuthTokenInfo, "idToken">>;
     getPlugin(name: string): IPlugin | null;
+    switchAccount(account: LinkedAccountInfo): Promise<void>;
+    linkAccount(params?: LinkAccountParams): Promise<LinkAccountResult>;
+    unlinkAccount(address: string): Promise<UnlinkAccountResult>;
     setAnalyticsProperties(properties: Record<string, unknown>): void;
     protected initChainsConfig(projectConfig: ProjectConfig): void;
     protected initAccountAbstractionConfig(projectConfig?: ProjectConfig): void;
@@ -74,10 +95,88 @@ export declare class Web3AuthNoModal extends SafeEventEmitter<Web3AuthNoModalEve
      */
     protected getInitialChainIdForConnector(connector: IConnector<unknown>): CustomChainConfig;
     protected completeConsentAcceptance(): Promise<void>;
+    protected resolveLinkAccountChainId(chainId?: string | null): string;
+    /**
+     * Resolves the chain ID for a switch account operation.
+     * If the account's chain namespace is the same as the current chain namespace, return the current chain ID.
+     * If the account's chain namespace is different from the current chain namespace, return the chainId the account was linked in.
+     *
+     * @param account - The account to switch to.
+     * @param activeChainId - The current active chain ID.
+     * @returns The resolved chain ID.
+     */
+    protected resolveSwitchAccountChainId(account: Pick<LinkedAccountInfo, "chainNamespace">, activeChainId: string): string;
+    protected createLinkingWalletConnector(connectorName: WALLET_CONNECTOR_TYPE | string, chainId: string, config?: ProjectConfig): Promise<IConnector<unknown>>;
+    protected createSwitchingWalletConnector(connectorName: WALLET_CONNECTOR_TYPE | string, chainId: string, config?: ProjectConfig): Promise<IConnector<unknown>>;
+    protected getConnectedWalletConnector(account?: Pick<LinkedAccountInfo, "id" | "isPrimary"> | null): IConnector<unknown> | null;
+    protected getConnectedWalletConnectorState(account?: Pick<LinkedAccountInfo, "id" | "isPrimary"> | null): ConnectedAccountsWithProviders | null;
+    protected setConnectedWalletConnectorState(connectedWallet: ConnectedAccountsWithProviders, account?: Pick<LinkedAccountInfo, "id" | "isPrimary"> | null): void;
+    protected setConnectedWalletConnector(connector: IConnector<unknown>, account?: Pick<LinkedAccountInfo, "id" | "isPrimary"> | null): void;
+    protected deleteConnectedWalletConnector(account?: Pick<LinkedAccountInfo, "id" | "isPrimary"> | null): void;
+    protected getConnectedWalletConnection(account?: Pick<LinkedAccountInfo, "id" | "isPrimary"> | null): Connection | null;
+    protected hasUsableConnectedSwitchConnector(connector: IConnector<unknown> | null): boolean;
+    protected setActiveWalletConnectorKey(account?: Pick<LinkedAccountInfo, "id" | "isPrimary"> | null): void;
+    protected getConnectedWalletConnectorKey(account?: Pick<LinkedAccountInfo, "id" | "isPrimary"> | null): string;
+    protected getConnectedWalletConnectorStateByKey(accountKey: string): ConnectedAccountsWithProviders | null;
+    protected isLinkedAccountInfo(account: ConnectedWalletAccountRef): account is LinkedAccountInfo;
+    protected toConnectedWalletLinkedAccountInfo(account: Omit<LinkedAccountInfo, "connector">): Omit<LinkedAccountInfo, "connector">;
+    protected getConnectedWalletLinkedAccountInfo(account?: ConnectedWalletAccountRef): Omit<LinkedAccountInfo, "connector">;
+    protected syncConnectedWalletLinkedAccounts(linkedAccounts: LinkedAccountInfo[]): void;
+    protected refreshConnectedWalletActiveStates(activeAccount: LinkedAccountInfo | null): void;
+    protected getConnectedWalletConnectionByKey(accountKey: string): Connection | null;
+    protected buildConnectionFromConnectedWalletConnectorState(connectedWallet: ConnectedAccountsWithProviders): Connection;
+    protected buildImmediateConnectedWalletConnectorState(params: {
+        connector: IConnector<unknown>;
+        ethereumProvider: IProvider | null;
+        solanaWallet: Connection["solanaWallet"];
+        usePrimaryProxy: boolean;
+        account?: ConnectedWalletAccountRef;
+    }): ConnectedAccountsWithProviders;
+    protected resolveConnectedWalletConnectorState(params: {
+        connector: IConnector<unknown>;
+        ethereumProvider: IProvider | null;
+        solanaWallet: Connection["solanaWallet"];
+        usePrimaryProxy: boolean;
+        account?: ConnectedWalletAccountRef;
+    }): Promise<ConnectedAccountsWithProviders>;
+    protected linkAccountWithConnector(connectorName: WALLET_CONNECTOR_TYPE | string, chainId: string, walletConnector: IConnector<unknown>): Promise<LinkAccountResult>;
+    protected getMainAuthConnector(): AuthConnectorType;
+    /**
+     * Processes the result of a switch account operation.
+     *
+     * - If the target account is a primary account, we will switch back to the primary account.
+     * - If the target account is an external account and already connected (i.e. connector is available with connected state), we will just switch to it without re-connecting again.
+     * - If the target account is an external account and not connected (i.e. connector is not available with connected state), we will create a new isolated connector and connect to it.
+     * @param authConnector - The main auth connector to use.
+     * @param switchResult - The result of the switch account operation.
+     * @param options - The options for the switch account operation.
+     * @returns A promise that resolves when the switch account operation is complete.
+     */
+    protected processSwitchAccountResult(authConnector: AuthConnectorType, switchResult: AuthConnectorSwitchAccountResult, options?: {
+        walletConnector?: IConnector<unknown>;
+        projectConfig?: ProjectConfig;
+    }): Promise<void>;
+    private isActiveConnectorEventSource;
+    private shouldIgnoreInactiveConnectorEvent;
+    private findLinkedAccountByAddress;
+    private findLinkedAccountByWalletAddress;
+    private getConnectedWalletAddress;
+    private cacheConnectedLinkedWalletConnector;
     private cacheWallet;
     private setCurrentChain;
     private connectToPlugins;
+    private bindPrimaryEthereumSigningProxy;
+    private getChainConfigForIsolatedConnector;
+    private resolveInstalledDiscoveredWalletConnector;
+    private resolveDiscoveredWalletConnector;
+    /**
+     * Create a new connector instance that is NOT registered in this.connectors and NOT
+     * subscribed to the main SDK event loop. Its lifecycle events are therefore isolated
+     * and will not mutate any global SDK state (connectedConnectorName, connection, idToken).
+     */
+    private createIsolatedWalletConnector;
     private setState;
     private loadState;
     private getStorageMethod;
 }
+export {};

package/dist/lib.cjs/types/providers/base-provider/baseProvider.d.ts

@@ -14,6 +14,8 @@ export interface BaseProviderConfig extends BaseConfig {
 export declare abstract class BaseProvider<C extends BaseProviderConfig, S extends BaseProviderState, P> extends BaseController<C, S, BaseProviderEvents<S>> implements IBaseProvider<P> {
     _providerEngineProxy: SafeEventEmitterProvider<ProviderEvents> | null;
     private keyExportFlagSetByCode;
+    private providerEventBridges;
+    private providerListenerBridgeRegistered;
     constructor({ config, state }: {
         config: C;
         state?: S;
@@ -30,6 +32,11 @@ export declare abstract class BaseProvider<C extends BaseProviderConfig, S exten
     setKeyExportFlag(flag: boolean): void;
     protected getProviderEngineProxy(): SafeEventEmitterProvider | null;
     protected getChain(chainId: string): CustomChainConfig;
+    private ensureProviderListenerBridge;
+    private ensureProviderEventBridge;
+    private attachProviderEventBridges;
+    private attachProviderEventBridge;
+    private detachProviderEventBridges;
     abstract setupProvider(provider: P, chainId: string): Promise<void>;
     abstract switchChain(params: {
         chainId: string;

package/dist/lib.cjs/types/react/hooks/index.d.ts

@@ -8,6 +8,7 @@ export * from "./useReceive";
 export * from "./useSwap";
 export * from "./useSwitchChain";
 export * from "./useWalletConnectScanner";
+export * from "./useWallets";
 export * from "./useWalletServicesPlugin";
 export * from "./useWalletUI";
 export * from "./useWeb3Auth";

package/dist/lib.cjs/types/react/hooks/useWallets.d.ts

@@ -0,0 +1,8 @@
+import { ConnectedAccountsWithProviders, Web3AuthError } from "../../base";
+export interface IUseWallets {
+    loading: boolean;
+    error: Web3AuthError | null;
+    wallets: ConnectedAccountsWithProviders[];
+    syncWallets(): Promise<void>;
+}
+export declare const useWallets: () => IUseWallets;

package/dist/lib.cjs/types/vue/composables/index.d.ts

@@ -9,6 +9,7 @@ export * from "./useReceive";
 export * from "./useSwap";
 export * from "./useSwitchChain";
 export * from "./useWalletConnectScanner";
+export * from "./useWallets";
 export * from "./useWalletServicesPlugin";
 export * from "./useWalletUI";
 export * from "./useWeb3Auth";