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

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

@@ -1,10 +1,3 @@
 import type { IWeb3AuthState } from "./interfaces";
-export declare const cookieStorage: (options?: {
-    expiry?: number;
-}) => {
-    getItem(key: string): string;
-    setItem(key: string, value: string): void;
-    removeItem(key: string): void;
-};
 export declare function cookieToWeb3AuthState(cookie?: string | null): IWeb3AuthState;
 export declare function parseCookie(cookie: string, key: string): string;

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 LoginParams, MfaLevelType, MfaSettings, SafeEventEmitter, UX_MODE_TYPE, type WhiteLabelData } from "@web3auth/auth";
+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 { CONNECTED_EVENT_DATA, CONNECTOR_EVENTS, CONNECTOR_INITIAL_AUTHENTICATION_MODE, type CONNECTOR_STATUS_TYPE, ConnectorEvents, type ConnectorFn, type IBaseProvider, type IConnector, type IdentityTokenInfo, type IProvider, 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";
@@ -56,11 +57,14 @@ export interface IWeb3AuthCoreOptions {
      */
     enableLogging?: boolean;
     /**
-     * setting to "local" will persist social login session across browser tabs.
-     *
-     * @defaultValue "local"
+     * Custom storage adapters for auth tokens (sessionId, accessToken, refreshToken, idToken).
+     * @defaultValue localStorage-based adapters
+     */
+    storage?: StorageConfig;
+    /**
+     * Cookie configuration used when storage adapters are cookie-based.
      */
-    storageType?: "session" | "local" | "cookies";
+    cookieOptions?: CookieOptions;
     /**
      * sessionTime (in seconds) for idToken issued by Web3Auth for server side verification.
      * @defaultValue 7 * 86400
@@ -107,7 +111,7 @@ export interface IWeb3AuthCoreOptions {
      */
     walletServicesConfig?: WalletServicesConfig;
     /**
-     * Private key provider for xrpl, mpc cases
+     * Private key provider for xrpl cases
      */
     privateKeyProvider?: IBaseProvider<string>;
     /**
@@ -132,7 +136,7 @@ export interface IWeb3AuthCoreOptions {
     mfaLevel?: MfaLevelType;
     /**
      * Initial authentication mode for the auth connector.
-     * @defaultValue "connect-only"
+     * @defaultValue "connect-and-sign"
      */
     initialAuthenticationMode?: ConnectorInitialAuthenticationModeType;
     /**
@@ -154,11 +158,12 @@ 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;
-    provider: IProvider | null;
+    connection: Connection | null;
     init(options?: {
         signal?: AbortSignal;
     }): Promise<void>;
@@ -168,12 +173,13 @@ export interface IWeb3AuthCore extends SafeEventEmitter {
         cleanup: boolean;
     }): Promise<void>;
     getUserInfo(): Promise<Partial<UserInfo>>;
-    getIdentityToken(): Promise<IdentityTokenInfo>;
+    getAuthTokenInfo(): Promise<Pick<AuthTokenInfo, "idToken">>;
     switchChain(params: {
         chainId: string;
     }): Promise<void>;
 }
 export interface IWeb3Auth extends IWeb3AuthCore {
+    loginMode: LoginModeType;
     connected: boolean;
     cachedConnector: string | null;
     getConnector(connectorName: WALLET_CONNECTOR_TYPE): IConnector<unknown> | null;
@@ -181,18 +187,56 @@ export interface IWeb3Auth extends IWeb3AuthCore {
      * Connect to a specific wallet connector
      * @param walletName - Key of the wallet connector to use.
      */
-    connectTo<T extends WALLET_CONNECTOR_TYPE>(walletName: T, loginParams?: LoginParamMap[T]): Promise<IProvider | null>;
+    connectTo<T extends WALLET_CONNECTOR_TYPE>(walletName: T, loginParams?: LoginParamMap[T]): Promise<Connection | null>;
     enableMFA<T>(params: T): Promise<void>;
     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;
+    pendingUserConsent?: boolean;
+};
+export type SDK_CONSENT_ACCEPTED_EVENT_DATA = {
+    reconnected: boolean;
 };
-export type Web3AuthNoModalEvents = Omit<ConnectorEvents, "connected" | "errored" | "ready"> & {
+export type Web3AuthNoModalEvents = Omit<ConnectorEvents, "connected" | "errored" | "ready" | "consent_requiring" | "consent_accepted"> & {
     [CONNECTOR_EVENTS.READY]: () => void;
     [CONNECTOR_EVENTS.CONNECTED]: (data: SDK_CONNECTED_EVENT_DATA) => void;
+    [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

@@ -1,5 +1,4 @@
-import { CustomError } from "ts-custom-error";
-export interface IWeb3AuthError extends CustomError {
+export interface IWeb3AuthError extends Error {
     code: number;
     message: string;
     cause?: unknown;
@@ -8,7 +7,7 @@ export interface IWeb3AuthError extends CustomError {
 export type ErrorCodes = {
     [key: number]: string;
 };
-export declare abstract class Web3AuthError extends CustomError implements IWeb3AuthError {
+export declare abstract class Web3AuthError extends Error implements IWeb3AuthError {
     code: number;
     message: string;
     cause?: unknown;
@@ -58,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/hooks/index.d.ts

@@ -1,5 +1,5 @@
 import type { ChainNamespaceType } from "../chain/IChainInterface";
-import { CONNECTOR_STATUS_TYPE, IProvider } from "../connector";
+import { type Connection, CONNECTOR_STATUS_TYPE } from "../connector";
 import { IPlugin } from "../plugin";
 export interface IBaseWeb3AuthHookContext {
     chainId: string | null;
@@ -10,7 +10,7 @@ export interface IBaseWeb3AuthHookContext {
     isConnected: boolean;
     isAuthorized: boolean;
     isMFAEnabled: boolean;
-    provider: IProvider | null;
+    connection: Connection | null;
     status: CONNECTOR_STATUS_TYPE | null;
     getPlugin(pluginName: string): IPlugin | null;
     setIsMFAEnabled(isMFAEnabled: boolean): void;

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

@@ -1,7 +1,8 @@
 import { type BUTTON_POSITION_TYPE } from "@toruslabs/base-controllers";
-import { type SmartAccountType } from "@toruslabs/ethereum-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,9 +11,13 @@ 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[];
 export interface ExternalWalletsConfig {
@@ -22,6 +27,7 @@ export interface ExternalWalletsConfig {
 }
 export type SmartAccountWalletScope = (typeof SMART_ACCOUNT_WALLET_SCOPE)[keyof typeof SMART_ACCOUNT_WALLET_SCOPE];
 export interface SmartAccountsConfig {
+    eipStandard: SmartAccountEipStandardType | undefined;
     smartAccountType: SmartAccountType;
     walletScope: SmartAccountWalletScope;
     chains: {

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";
@@ -7,7 +7,8 @@ import { type WEB3AUTH_NETWORK_TYPE } from "./connector";
 import { type UIConfig, type WalletServicesConfig } from "./core/IWeb3Auth";
 import type { ProjectConfig, WalletRegistry } from "./interfaces";
 export declare const isHexStrict: (hex: string) => boolean;
-export declare const signerHost: (web3AuthNetwork?: WEB3AUTH_NETWORK_TYPE) => string;
+export declare const dashboardPublicApiUrl: (buildEnv: BUILD_ENV_TYPE) => string;
+export declare const citadelServerUrl: (buildEnv?: BUILD_ENV_TYPE) => string;
 export declare const fetchProjectConfig: ({ clientId, web3AuthNetwork, aaProvider, authBuildEnv, }: {
     clientId: string;
     web3AuthNetwork: WEB3AUTH_NETWORK_TYPE;
@@ -66,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/base/wallet/index.d.ts

@@ -1,3 +1,5 @@
+import { WalletIcon } from "@wallet-standard/base";
+export * from "./solana";
 export declare const MULTI_CHAIN_CONNECTORS: {
     readonly AUTH: "auth";
     readonly WALLET_CONNECT_V2: "wallet-connect-v2";
@@ -30,3 +32,4 @@ export declare const CONNECTOR_NAMES: {
     coinbase: string;
     metamask: string;
 };
+export declare const WEB3AUTH_ICON: WalletIcon;

package/dist/lib.cjs/types/base/wallet/solana.d.ts

@@ -0,0 +1,19 @@
+import { type Transaction } from "@solana/kit";
+import type { IdentifierString, Wallet } from "@wallet-standard/base";
+import { type CustomChainConfig } from "../chain/IChainInterface";
+export declare const getSolanaChainByChainConfig: (chainConfig: CustomChainConfig) => IdentifierString | null;
+/**
+ * Signs and sends a transaction via the wallet standard feature.
+ * Returns the transaction signature as a base58 string.
+ */
+export declare const walletSignAndSendTransaction: (wallet: Wallet, transaction: Transaction) => Promise<string>;
+/**
+ * Signs a transaction via the wallet standard feature.
+ * Returns the first signature as a base58 string.
+ */
+export declare const walletSignTransaction: (wallet: Wallet, transaction: Transaction) => Promise<string>;
+/**
+ * Signs a message via the wallet standard feature.
+ * Returns the signature as a base58 string.
+ */
+export declare const walletSignMessage: (wallet: Wallet, message: string, from?: string) => Promise<string>;

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

@@ -1,8 +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, BaseConnector, BaseConnectorLoginParams, 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;
@@ -15,21 +18,23 @@ declare class AuthConnector extends BaseConnector<AuthLoginParams> {
     private wsEmbedInstance;
     private authConnectionConfig;
     private wsEmbedInstancePromise;
+    private _solanaWallet;
+    private analytics;
     constructor(params: AuthConnectorOptions);
     get provider(): IProvider | null;
     get wsEmbed(): WsEmbed;
+    get solanaWallet(): Wallet | null;
     set provider(_: IProvider | null);
     init(options: ConnectorInitOptions): Promise<void>;
-    connect(params: Partial<AuthLoginParams> & BaseConnectorLoginParams): Promise<IProvider | null>;
+    connect(params: Partial<AuthLoginParams> & BaseConnectorLoginParams): Promise<Connection | null>;
     enableMFA(params?: AuthLoginParams): Promise<void>;
     manageMFA(params?: AuthLoginParams): Promise<void>;
     disconnect(options?: {
         cleanup: boolean;
     }): Promise<void>;
-    getIdentityToken(): Promise<{
-        idToken: string;
-    }>;
+    getAuthTokenInfo(): Promise<AuthTokenInfo>;
     getUserInfo(): Promise<Partial<UserInfo>>;
+    getLinkedAccounts(): Promise<LinkedAccountInfo[]>;
     switchChain(params: {
         chainId: string;
     }, init?: boolean): Promise<void>;
@@ -37,15 +42,39 @@ declare class AuthConnector extends BaseConnector<AuthLoginParams> {
     getOAuthProviderConfig(params: Pick<AuthLoginParams, "authConnection" | "authConnectionId" | "groupedAuthConnectionId">): AuthConnectionConfigItem & {
         isDefault?: boolean;
     };
-    private getChain;
+    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;
     private connectWithSocialLogin;
+    private accessTokenProvider;
+    private getIdToken;
+    private getOriginData;
     private connectWithJwtLogin;
+    private auditOAuditProgress;
 }
 type AuthConnectorFuncParams = Omit<AuthConnectorOptions, "coreOptions" | "authConnectionConfig" | "connectorSettings"> & {
     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/authSolanaWallet.d.ts

@@ -0,0 +1,35 @@
+import { type SolanaSignAndSendTransactionFeature, type SolanaSignMessageFeature, type SolanaSignTransactionFeature } from "@solana/wallet-standard-features";
+import { type IdentifierArray, type Wallet, type WalletAccount, type WalletIcon, type WalletVersion } from "@wallet-standard/base";
+import { type StandardConnectFeature, type StandardDisconnectFeature, type StandardEventsFeature } from "@wallet-standard/features";
+import { type CustomChainConfig, type IProvider } from "../../base";
+type AuthSolanaFeatures = StandardConnectFeature & StandardDisconnectFeature & StandardEventsFeature & SolanaSignAndSendTransactionFeature & SolanaSignMessageFeature & SolanaSignTransactionFeature;
+/**
+ * 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}.
+ */
+export declare class AuthSolanaWallet implements Wallet {
+    private readonly _provider;
+    readonly version: WalletVersion;
+    readonly name = "Web3Auth";
+    readonly icon: WalletIcon;
+    readonly chains: IdentifierArray;
+    readonly features: AuthSolanaFeatures;
+    private _accounts;
+    private readonly _listeners;
+    /**
+     * @param solanaChainConfigs - All configured Solana {@link CustomChainConfig} entries (same namespace).
+     */
+    constructor(_provider: IProvider, solanaChainConfigs: CustomChainConfig[]);
+    /**
+     * Wallet Standard requires a synchronous getter; RPC runs on first async wallet operation instead.
+     */
+    get accounts(): readonly WalletAccount[];
+    /** Throws if the embed is not on Solana; otherwise loads accounts once via {@link SOLANA_METHOD_TYPES.GET_ACCOUNTS}. */
+    private ensureAccountsLoaded;
+    private emitChange;
+}
+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 { BaseConnector, ConnectorInitOptions, IdentityTokenInfo } from "../../base";
+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>;
-    getIdentityToken(): Promise<IdentityTokenInfo>;
+    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 { BaseConnector, ConnectorInitOptions, IdentityTokenInfo } from "../../base";
+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>;
-    getIdentityToken(): Promise<IdentityTokenInfo>;
+    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/injected-evm-connector/injectedEvmConnector.d.ts

@@ -1,5 +1,5 @@
 import { type EIP6963ProviderDetail } from "mipd";
-import { BaseConnectorLoginParams, BaseConnectorSettings, ChainNamespaceType, CONNECTOR_CATEGORY_TYPE, CONNECTOR_STATUS_TYPE, ConnectorFn, ConnectorInitOptions, ConnectorNamespaceType, CustomChainConfig, IProvider, UserInfo } from "../../base";
+import { BaseConnectorLoginParams, BaseConnectorSettings, ChainNamespaceType, Connection, CONNECTOR_CATEGORY_TYPE, CONNECTOR_STATUS_TYPE, ConnectorFn, ConnectorInitOptions, ConnectorNamespaceType, CustomChainConfig, IProvider, UserInfo } from "../../base";
 import { BaseEvmConnector } from "../base-evm-connector";
 declare class InjectedEvmConnector extends BaseEvmConnector<void> {
     readonly connectorNamespace: ConnectorNamespaceType;
@@ -17,7 +17,7 @@ declare class InjectedEvmConnector extends BaseEvmConnector<void> {
     get provider(): IProvider | null;
     set provider(_: IProvider | null);
     init(options: ConnectorInitOptions): Promise<void>;
-    connect({ chainId, getIdentityToken }: BaseConnectorLoginParams): Promise<IProvider | null>;
+    connect({ chainId, getAuthTokenInfo }: BaseConnectorLoginParams): Promise<Connection | null>;
     disconnect(options?: {
         cleanup: boolean;
     }): Promise<void>;

package/dist/lib.cjs/types/connectors/injected-solana-connector/walletStandardConnector.d.ts

@@ -1,5 +1,8 @@
-import { Wallet } from "@wallet-standard/base";
-import { BaseConnectorLoginParams, BaseConnectorSettings, ChainNamespaceType, CONNECTOR_CATEGORY_TYPE, CONNECTOR_STATUS_TYPE, ConnectorFn, ConnectorInitOptions, ConnectorNamespaceType, IProvider, UserInfo } from "../../base";
+import { type SolanaSignAndSendTransactionFeature, type SolanaSignMessageFeature, type SolanaSignTransactionFeature } from "@solana/wallet-standard-features";
+import { type Wallet, type WalletWithFeatures } from "@wallet-standard/base";
+import { type StandardConnectFeature, type StandardDisconnectFeature, type StandardEventsFeature } from "@wallet-standard/features";
+type WalletStandard = WalletWithFeatures<StandardConnectFeature & StandardDisconnectFeature & StandardEventsFeature & SolanaSignAndSendTransactionFeature & SolanaSignMessageFeature & SolanaSignTransactionFeature>;
+import { BaseConnectorLoginParams, BaseConnectorSettings, ChainNamespaceType, Connection, CONNECTOR_CATEGORY_TYPE, CONNECTOR_STATUS_TYPE, ConnectorFn, ConnectorInitOptions, ConnectorNamespaceType, UserInfo } from "../../base";
 import { BaseSolanaConnector } from "../base-solana-connector";
 export declare class WalletStandardConnector extends BaseSolanaConnector<void> {
     readonly name: string;
@@ -9,23 +12,23 @@ export declare class WalletStandardConnector extends BaseSolanaConnector<void> {
     readonly isInjected = true;
     status: CONNECTOR_STATUS_TYPE;
     private wallet;
-    private injectedProvider;
     constructor(options: BaseConnectorSettings & {
         name: string;
         wallet: Wallet;
     });
-    get provider(): IProvider;
+    get solanaWallet(): WalletStandard | null;
     get isWalletConnected(): boolean;
     init(options: ConnectorInitOptions): Promise<void>;
-    connect({ chainId, getIdentityToken }: BaseConnectorLoginParams): Promise<IProvider>;
+    connect({ chainId, getAuthTokenInfo }: BaseConnectorLoginParams): Promise<Connection | null>;
     disconnect(options?: {
         cleanup: boolean;
     }): Promise<void>;
     getUserInfo(): Promise<Partial<UserInfo>>;
-    switchChain(params: {
+    switchChain(_params: {
         chainId: string;
-    }, init?: boolean): Promise<void>;
+    }, _init?: boolean): Promise<void>;
     enableMFA(): Promise<void>;
     manageMFA(): Promise<void>;
 }
 export declare const walletStandardConnector: (wallet: Wallet) => ConnectorFn;
+export {};

package/dist/lib.cjs/types/connectors/metamask-connector/metamaskConnector.d.ts

@@ -1,6 +1,38 @@
-import { type MetaMaskSDKOptions } from "@metamask/sdk";
 import { type BaseConnectorSettings, type ConnectorFn } from "../../base";
+/**
+ * Configuration options for the MetaMask connector using \@metamask/connect-evm
+ */
+export interface MetaMaskConnectorSettings {
+    /** Dapp identification and branding settings */
+    dapp?: {
+        name?: string;
+        url?: string;
+        iconUrl?: string;
+    };
+    /** Enable debug logging for the MetaMask SDK */
+    debug?: boolean;
+    /** UI settings for the MetaMask connector */
+    ui?: {
+        preferExtension?: boolean;
+        showInstallModal?: boolean;
+        headless?: boolean;
+    };
+}
 export interface MetaMaskConnectorOptions extends BaseConnectorSettings {
-    connectorSettings?: Partial<MetaMaskSDKOptions>;
+    connectorSettings?: MetaMaskConnectorSettings;
 }
-export declare const metaMaskConnector: (params?: Partial<MetaMaskSDKOptions>) => ConnectorFn;
+/**
+ * Factory function to create a MetaMask connector
+ *
+ * @param params - Configuration options for the MetaMask SDK
+ * @returns A connector function that creates a MetaMaskConnector instance
+ *
+ * @example
+ * ```typescript
+ * const connector = metaMaskConnector({
+ *   dapp: { name: 'My DApp', url: 'https://mydapp.com' },
+ *   debug: true,
+ * });
+ * ```
+ */
+export declare const metaMaskConnector: (params?: MetaMaskConnectorSettings) => ConnectorFn;