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

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

@@ -1,3 +1,4 @@
+import { type Hex } from "@toruslabs/metadata-helpers";
 /**
  * Extracts a name for the site from the DOM
  */
@@ -14,3 +15,4 @@ export declare function parseToken<T>(token: string): {
     };
     payload: T;
 };
+export declare const generateNonce: () => Hex;

package/dist/lib.cjs/types/connectors/wallet-connect-v2-connector/WalletConnectV2Provider.d.ts

@@ -27,7 +27,6 @@ export declare class WalletConnectV2Provider extends BaseProvider<BaseProviderCo
     protected lookupNetwork(_: ISignClient, chainId: string): Promise<string>;
     private setupEngine;
     private setupEthEngine;
-    private setupSolEngine;
     private getEthChainSwitchMiddleware;
     private connectedTopic;
     private checkIfAccountAllowed;

package/dist/lib.cjs/types/connectors/wallet-connect-v2-connector/walletConnectV2Utils.d.ts

@@ -1,17 +1,13 @@
 import type { ISignClient } from "@walletconnect/types";
 import { AddEthereumChainConfig } from "../../base";
 import type { IEthProviderHandlers } from "../../providers/ethereum-provider";
-import type { ISolanaProviderHandlers } from "../../providers/solana-provider";
 export declare function sendJrpcRequest<T, U>(signClient: ISignClient, chainId: string, method: string, params: U): Promise<T>;
 export declare function getAccounts(signClient: ISignClient): Promise<string[]>;
+export declare function getSolanaAccounts(signClient: ISignClient): Promise<string[]>;
 export declare function getEthProviderHandlers({ connector, chainId }: {
     connector: ISignClient;
     chainId: number;
 }): IEthProviderHandlers;
-export declare function getSolProviderHandlers({ connector, chainId }: {
-    connector: ISignClient;
-    chainId: string;
-}): ISolanaProviderHandlers;
 export declare function switchChain({ connector, chainId, newChainId, }: {
     connector: ISignClient;
     chainId: number;

package/dist/lib.cjs/types/connectors/wallet-connect-v2-connector/wcSolanaWallet.d.ts

@@ -0,0 +1,26 @@
+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 { ISignClient } from "@walletconnect/types";
+import { type CustomChainConfig } from "../../base";
+type WCSolanaFeatures = StandardConnectFeature & StandardDisconnectFeature & StandardEventsFeature & SolanaSignAndSendTransactionFeature & SolanaSignMessageFeature & SolanaSignTransactionFeature;
+/**
+ * WCSolanaWallet implements the Wallet Standard interface by routing directly to
+ * a WalletConnect SignClient — no intermediate JRPC engine needed.
+ */
+export declare class WCSolanaWallet implements Wallet {
+    readonly version: WalletVersion;
+    readonly name = "WalletConnect";
+    readonly icon: WalletIcon;
+    readonly chains: IdentifierArray;
+    readonly features: WCSolanaFeatures;
+    private _accounts;
+    private readonly _listeners;
+    private constructor();
+    get accounts(): readonly WalletAccount[];
+    /**
+     * Creates a WCSolanaWallet by reading accounts from the active WC session.
+     */
+    static create(connector: ISignClient, chainConfig: CustomChainConfig): Promise<WCSolanaWallet | null>;
+}
+export {};

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,34 +1,53 @@
 import { SafeEventEmitter } from "@web3auth/auth";
-import { Analytics, type ChainNamespaceType, type CONNECTOR_STATUS_TYPE, type CustomChainConfig, type IConnector, type IdentityTokenInfo, 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;
+    loginMode: LoginModeType;
     protected aaProvider: AccountAbstractionProvider | null;
     protected connectors: IConnector<unknown>[];
     protected commonJRPCProvider: CommonJRPCProvider | null;
     protected analytics: Analytics;
     protected plugins: Record<string, IPlugin>;
+    protected consentRequired: boolean;
+    protected projectConfig: ProjectConfig | null;
     private storage;
+    private connectionReconnected;
+    /** Connected wallet state keyed by linked account id; the primary session uses a reserved key. */
+    private connectedWalletConnectorMap;
+    private activeWalletConnectorKey;
     private state;
-    private loginMode;
-    constructor(options: IWeb3AuthCoreOptions, initialState?: IWeb3AuthState);
+    constructor(options: IWeb3AuthCoreOptions, initialState?: Partial<IWeb3AuthState>);
     get currentChain(): CustomChainConfig | undefined;
     get connected(): boolean;
-    get provider(): IProvider | null;
-    get connectedConnectorName(): WALLET_CONNECTOR_TYPE | null;
+    get connection(): Connection | 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;
     }): Promise<void>;
     getConnector(connectorName: WALLET_CONNECTOR_TYPE, chainNamespace?: ChainNamespaceType): IConnector<unknown> | null;
-    clearCache(): void;
+    clearCache(): Promise<void>;
     cleanup(): Promise<void>;
     switchChain(params: {
         chainId: string;
@@ -37,21 +56,26 @@ export declare class Web3AuthNoModal extends SafeEventEmitter<Web3AuthNoModalEve
      * Connect to a specific wallet connector
      * @param connectorName - Key of the wallet connector to use.
      */
-    connectTo<T extends WALLET_CONNECTOR_TYPE>(connectorName: T, loginParams?: LoginParamMap[T], loginMode?: LoginModeType): Promise<IProvider | null>;
+    connectTo<T extends WALLET_CONNECTOR_TYPE>(connectorName: T, loginParams?: LoginParamMap[T], loginMode?: LoginModeType): Promise<Connection | null>;
     logout(options?: {
         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>;
-    getIdentityToken(): Promise<IdentityTokenInfo>;
+    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;
     protected initUIConfig(projectConfig: ProjectConfig): void;
     protected initSessionTimeConfig(projectConfig: ProjectConfig): void;
-    protected initCachedConnectorAndChainId(): void;
+    protected initCachedConnectorAndChainId(): Promise<void>;
     protected initWalletServicesConfig(projectConfig: ProjectConfig): void;
     protected getInitializationTrackData(): {};
     protected setupCommonJRPCProvider(): Promise<void>;
@@ -70,10 +94,89 @@ export declare class Web3AuthNoModal extends SafeEventEmitter<Web3AuthNoModalEve
      * @throws WalletInitializationError If no chain is found for the connector's namespace
      */
     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/plugins/wallet-services-plugin/plugin.d.ts

@@ -1,7 +1,7 @@
 import { type BaseEmbedControllerState } from "@toruslabs/base-controllers";
 import { SafeEventEmitter, type WhiteLabelData } from "@web3auth/auth";
 import WsEmbed from "@web3auth/ws-embed";
-import { type Analytics, IPlugin, IWeb3AuthCore, PLUGIN_STATUS_TYPE, PluginFn, SafeEventEmitterProvider, WALLET_CONNECTOR_TYPE } from "../../base";
+import { type Analytics, IPlugin, IWeb3AuthCore, PLUGIN_STATUS_TYPE, PluginFn, WALLET_CONNECTOR_TYPE } from "../../base";
 export { BUTTON_POSITION, type BUTTON_POSITION_TYPE, CONFIRMATION_STRATEGY, type CONFIRMATION_STRATEGY_TYPE } from "@web3auth/ws-embed";
 declare class WalletServicesPlugin extends SafeEventEmitter implements IPlugin {
     name: "wallet-services";
@@ -9,13 +9,10 @@ declare class WalletServicesPlugin extends SafeEventEmitter implements IPlugin {
     readonly SUPPORTED_CONNECTORS: WALLET_CONNECTOR_TYPE[];
     readonly pluginNamespace: "multichain";
     wsEmbedInstance: WsEmbed;
-    private provider;
     private web3auth;
     private isInitialized;
     private analytics?;
-    get proxyProvider(): SafeEventEmitterProvider | null;
     initWithWeb3Auth(web3auth: IWeb3AuthCore, _whiteLabel?: WhiteLabelData, analytics?: Analytics): Promise<void>;
-    initWithProvider(): Promise<void>;
     connect(): Promise<void>;
     showWalletConnectScanner(showWalletConnectParams?: BaseEmbedControllerState["showWalletConnect"]): Promise<void>;
     showFunding(showFundingParams?: BaseEmbedControllerState["showFunding"]): Promise<void>;

package/dist/lib.cjs/types/providers/account-abstraction-provider/rpc/ethRpcMiddlewares.d.ts

@@ -1,11 +1,11 @@
-import { JRPCMiddleware } from "@web3auth/auth";
+import { type MiddlewareConstraint } from "@web3auth/auth";
 import { IProvider } from "../../../base";
 import { IEthProviderHandlers } from "../../ethereum-provider";
 export declare function createAaMiddleware({ eoaProvider, handlers, }: {
     eoaProvider: IProvider;
     handlers: IEthProviderHandlers;
-}): Promise<JRPCMiddleware<unknown, unknown>>;
+}): Promise<MiddlewareConstraint>;
 export declare function createEoaMiddleware({ aaProvider }: {
     aaProvider: IProvider;
-}): Promise<JRPCMiddleware<unknown, unknown>>;
-export declare function providerAsMiddleware(provider: IProvider): JRPCMiddleware<unknown, unknown>;
+}): Promise<MiddlewareConstraint>;
+export declare function providerAsMiddleware(provider: IProvider): MiddlewareConstraint;

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/providers/base-provider/jrpcClient.d.ts

@@ -1,8 +1,5 @@
-import { Block, JRPCMiddleware } from "@web3auth/auth";
+import { type MiddlewareConstraint } from "@web3auth/auth";
 import type { CustomChainConfig } from "../../base";
-export declare function createChainIdMiddleware(chainId: string): JRPCMiddleware<unknown, string>;
-export declare function createProviderConfigMiddleware(providerConfig: CustomChainConfig): JRPCMiddleware<unknown, CustomChainConfig>;
 export declare function createJsonRpcClient(providerConfig: CustomChainConfig): {
-    networkMiddleware: JRPCMiddleware<unknown, unknown>;
-    fetchMiddleware: JRPCMiddleware<string[], Block>;
+    networkMiddleware: MiddlewareConstraint;
 };

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

@@ -1,4 +1,3 @@
-export declare const createRandomId: () => number;
 export declare enum EIP1193_EVENTS {
     ACCOUNTS_CHANGED = "accountsChanged",
     CHAIN_CHANGED = "chainChanged",

package/dist/lib.cjs/types/providers/ethereum-provider/index.d.ts

@@ -1,2 +1 @@
-export * from "./providers";
 export * from "./rpc";

package/dist/lib.cjs/types/providers/ethereum-provider/rpc/ethRpcMiddlewares.d.ts

@@ -1,4 +1,4 @@
-import { JRPCMiddleware } from "@web3auth/auth";
-import { IEthChainSwitchHandlers, IEthProviderHandlers } from "./interfaces";
-export declare function createEthMiddleware(providerHandlers: IEthProviderHandlers): JRPCMiddleware<unknown, unknown>;
-export declare function createEthChainSwitchMiddleware({ switchChain, addChain }: IEthChainSwitchHandlers): JRPCMiddleware<unknown, unknown>;
+import { type MiddlewareConstraint } from "@web3auth/auth";
+import type { IEthChainSwitchHandlers, IEthProviderHandlers } from "./interfaces";
+export declare function createEthMiddleware(providerHandlers: IEthProviderHandlers): MiddlewareConstraint;
+export declare function createEthChainSwitchMiddleware({ switchChain, addChain }: IEthChainSwitchHandlers): MiddlewareConstraint;

package/dist/lib.cjs/types/providers/ethereum-provider/rpc/index.d.ts

@@ -1,4 +1,4 @@
 export * from "./ethRpcMiddlewares";
 export * from "./interfaces";
 export * from "./jrpcClient";
-export * from "./walletMidddleware";
+export * from "./walletMiddleware";

package/dist/lib.cjs/types/providers/ethereum-provider/rpc/jrpcClient.d.ts

@@ -1,8 +1,5 @@
-import { Block, JRPCMiddleware } from "@web3auth/auth";
+import { type MiddlewareConstraint } from "@web3auth/auth";
 import type { CustomChainConfig } from "../../../base";
-export declare function createEthChainIdMiddleware(chainId: string): JRPCMiddleware<unknown, string>;
-export declare function createEthProviderConfigMiddleware(providerConfig: CustomChainConfig): JRPCMiddleware<unknown, CustomChainConfig>;
 export declare function createEthJsonRpcClient(providerConfig: CustomChainConfig): {
-    networkMiddleware: JRPCMiddleware<unknown, unknown>;
-    fetchMiddleware: JRPCMiddleware<string[], Block>;
+    networkMiddleware: MiddlewareConstraint;
 };

package/dist/lib.cjs/types/providers/ethereum-provider/rpc/walletMiddleware.d.ts

@@ -0,0 +1,3 @@
+import { type JRPCRequest } from "@web3auth/auth";
+import type { WalletMiddlewareOptions } from "./interfaces";
+export declare function createWalletMiddlewareV2({ getAccounts, getPrivateKey, getPublicKey, processEthSignMessage, processPersonalMessage, processTransaction, processSignTransaction, processTypedMessageV4, processGetCapabilities, processSendCalls, processGetCallsStatus, processShowCallsStatus, }: WalletMiddlewareOptions): import("@web3auth/auth").JRPCMiddlewareV2<JRPCRequest<unknown>, import("@web3auth/auth").Json, import("@web3auth/auth").ContextConstraint>;

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

@@ -1,4 +1,3 @@
 export * from "./account-abstraction-provider";
 export * from "./base-provider";
 export * from "./ethereum-provider";
-export * from "./solana-provider";

package/dist/lib.cjs/types/providers/xrpl-provider/providers/privateKeyProviders/xrplPrivateKeyProvider.d.ts

@@ -21,5 +21,4 @@ export declare class XrplPrivateKeyProvider extends BaseProvider<BaseProviderCon
         chainId: string;
     }): Promise<void>;
     protected lookupNetwork(_privKey: string, chainId: string): Promise<void>;
-    private getChainSwitchMiddleware;
 }

package/dist/lib.cjs/types/providers/xrpl-provider/rpc/JrpcClient.d.ts

@@ -1,9 +1,5 @@
-import { Block, JRPCMiddleware } from "@web3auth/auth";
-import { CustomChainConfig } from "../../../base";
-export declare function createXrplChainIdMiddleware(chainId: string): JRPCMiddleware<unknown, string>;
-export declare function createXrplProviderConfigMiddleware(providerConfig: CustomChainConfig): JRPCMiddleware<unknown, CustomChainConfig>;
-export declare function createConfigMiddleware(providerConfig: CustomChainConfig): JRPCMiddleware<unknown, unknown>;
+import { type MiddlewareConstraint } from "@web3auth/auth";
+import type { CustomChainConfig } from "../../../base";
 export declare function createXrplJsonRpcClient(providerConfig: CustomChainConfig): {
-    networkMiddleware: JRPCMiddleware<unknown, unknown>;
-    fetchMiddleware: JRPCMiddleware<string[], Block>;
+    networkMiddleware: MiddlewareConstraint;
 };

package/dist/lib.cjs/types/providers/xrpl-provider/rpc/xrplRpcMiddlewares.d.ts

@@ -1,4 +1,4 @@
-import { JRPCMiddleware, JRPCRequest } from "@web3auth/auth";
+import { type JRPCRequest, type MiddlewareConstraint } from "@web3auth/auth";
 import type { SubmitResponse, Transaction } from "xrpl";
 export declare const RPC_METHODS: {
     GET_ACCOUNTS: string;
@@ -36,14 +36,7 @@ export interface IXrplProviderHandlers {
         signature: string;
     }>;
 }
-export declare function createGetAccountsMiddleware({ getAccounts, }: {
-    getAccounts: IXrplProviderHandlers["getAccounts"];
-}): JRPCMiddleware<unknown, unknown>;
-export declare function createGenericJRPCMiddleware<T, U>(targetMethod: string, handler: (req: JRPCRequest<T>) => Promise<U>): JRPCMiddleware<T, unknown>;
-export declare function createXRPLMiddleware(providerHandlers: IXrplProviderHandlers): JRPCMiddleware<unknown, unknown>;
-export interface IXrplChainSwitchHandlers {
-    switchChain: (req: JRPCRequest<{
-        chainId: string;
-    }>) => Promise<void>;
-}
-export declare function creatXrplChainSwitchMiddleware({ switchChain }: IXrplChainSwitchHandlers): JRPCMiddleware<unknown, unknown>;
+export declare function createXRPLMiddleware(providerHandlers: IXrplProviderHandlers): MiddlewareConstraint;
+export declare function creatXrplChainSwitchMiddleware(switchChain: (parrams: {
+    chainId: string;
+}) => Promise<void>): MiddlewareConstraint;

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

@@ -0,0 +1,4 @@
+export { useWalletServicesContextValue } from "./useWalletServicesContextValue";
+export { useWeb3AuthInnerContextValue } from "./useWeb3AuthInnerContextValue";
+export { WalletServicesContext } from "./WalletServicesInnerContext";
+export { Web3AuthInnerContext } from "./Web3AuthInnerContext";

package/dist/lib.cjs/types/react/context/useWalletServicesContextValue.d.ts

@@ -0,0 +1,12 @@
+type IWeb3AuthContextForWalletServices = {
+    getPlugin: (name: string) => unknown;
+    isInitialized: boolean;
+    isConnected: boolean;
+};
+export type IWalletServicesContextValue<TWalletServicesPlugin> = {
+    plugin: TWalletServicesPlugin | null;
+    ready: boolean;
+    connecting: boolean;
+};
+export declare function useWalletServicesContextValue<TWalletServicesPlugin>(web3AuthContext: IWeb3AuthContextForWalletServices): IWalletServicesContextValue<TWalletServicesPlugin>;
+export {};

package/dist/lib.cjs/types/react/context/useWeb3AuthInnerContextValue.d.ts

@@ -0,0 +1,26 @@
+import { type ChainNamespaceType, type Connection, type CONNECTOR_STATUS_TYPE, IWeb3Auth, type IWeb3AuthState } from "../../base";
+export type IWeb3AuthInnerContextValue<TWeb3Auth extends IWeb3Auth> = {
+    web3Auth: TWeb3Auth;
+    isConnected: boolean;
+    isInitialized: boolean;
+    connection: Connection | null;
+    status: CONNECTOR_STATUS_TYPE | null;
+    isInitializing: boolean;
+    initError: Error | null;
+    isMFAEnabled: boolean;
+    chainId: string | null;
+    chainNamespace: ChainNamespaceType | null;
+    getPlugin: TWeb3Auth["getPlugin"];
+    setIsMFAEnabled: (isMFAEnabled: boolean) => void;
+    isAuthorized: boolean;
+};
+type UseWeb3AuthInnerContextValueOptions<TWeb3Auth extends IWeb3Auth, TWeb3AuthOptions> = {
+    Web3AuthConstructor: new (options: TWeb3AuthOptions, initialState?: Partial<IWeb3AuthState>) => TWeb3Auth;
+    web3AuthOptions: TWeb3AuthOptions;
+    initialState?: Partial<IWeb3AuthState>;
+    notReadyUsesCurrentStatus?: boolean;
+    cleanupOnUnmount?: boolean;
+    initEffectDependency?: unknown;
+};
+export declare function useWeb3AuthInnerContextValue<TWeb3Auth extends IWeb3Auth, TWeb3AuthOptions>({ Web3AuthConstructor, web3AuthOptions, initialState, notReadyUsesCurrentStatus, cleanupOnUnmount, initEffectDependency, }: UseWeb3AuthInnerContextValueOptions<TWeb3Auth, TWeb3AuthOptions>): IWeb3AuthInnerContextValue<TWeb3Auth>;
+export {};

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

@@ -1,13 +1,14 @@
+export * from "./useAuthTokenInfo";
 export * from "./useChain";
 export * from "./useCheckout";
 export * from "./useEnableMFA";
 export * from "./useFunding";
-export * from "./useIdentityToken";
 export * from "./useManageMFA";
 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/{useIdentityToken.d.ts → useAuthTokenInfo.d.ts}

@@ -1,13 +1,13 @@
 import { Web3AuthError } from "../../base";
-export interface IUseIdentityToken {
+export interface IUseAuthTokenInfo {
     loading: boolean;
     error: Web3AuthError | null;
     token: string | null;
-    getIdentityToken: () => Promise<string | null>;
+    getAuthTokenInfo: () => Promise<string | null>;
 }
-export declare const useIdentityToken: () => {
+export declare const useAuthTokenInfo: () => {
     loading: boolean;
     error: Web3AuthError;
     token: string;
-    getIdentityToken: () => Promise<string>;
+    getAuthTokenInfo: () => Promise<string>;
 };

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/react/hooks/useWeb3Auth.d.ts

@@ -1,3 +1,2 @@
 import { IWeb3AuthInnerContext } from "../interfaces";
-export type IUseWeb3Auth = Omit<IWeb3AuthInnerContext, "isMFAEnabled" | "setIsMFAEnabled" | "chainId" | "chainNamespace">;
-export declare const useWeb3Auth: () => IUseWeb3Auth;
+export declare const useWeb3Auth: () => IWeb3AuthInnerContext;

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

@@ -1,9 +1,9 @@
-import { IProvider, LoginParamMap, WALLET_CONNECTOR_TYPE, Web3AuthError } from "../../base";
+import { Connection, LoginParamMap, WALLET_CONNECTOR_TYPE, Web3AuthError } from "../../base";
 export interface IUseWeb3AuthConnect {
     isConnected: boolean;
     loading: boolean;
     error: Web3AuthError | null;
     connectorName: WALLET_CONNECTOR_TYPE | null;
-    connect<T extends WALLET_CONNECTOR_TYPE>(connector: T, params?: LoginParamMap[T]): Promise<IProvider | null>;
+    connect<T extends WALLET_CONNECTOR_TYPE>(connector: T, params?: LoginParamMap[T]): Promise<Connection | null>;
 }
 export declare const useWeb3AuthConnect: () => IUseWeb3AuthConnect;

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

@@ -1,3 +1,4 @@
+export * from "./context";
 export * from "./hooks";
 export * from "./interfaces";
 export * from "./Web3AuthProvider";

package/dist/lib.cjs/types/react/solana/hooks/useSignAndSendTransaction.d.ts

@@ -1,9 +1,14 @@
+import type { Transaction } from "@solana/kit";
 import { Web3AuthError } from "../../../base";
-import { TransactionOrVersionedTransaction } from "../../../providers/solana-provider";
 export type IUseSignAndSendTransaction = {
     loading: boolean;
     error: Web3AuthError | null;
     data: string | null;
-    signAndSendTransaction: (transaction: TransactionOrVersionedTransaction) => Promise<string>;
+    /**
+     * Signs and sends a transaction to the network
+     * @param transaction - Compiled transaction from \@solana/kit
+     * @returns The signature of the transaction encoded in base58
+     */
+    signAndSendTransaction: (transaction: Transaction) => Promise<string>;
 };
 export declare const useSignAndSendTransaction: () => IUseSignAndSendTransaction;

package/dist/lib.cjs/types/react/solana/hooks/useSignTransaction.d.ts

@@ -1,14 +1,19 @@
+import type { Transaction } from "@solana/kit";
 import { Web3AuthError } from "../../../base";
-import { TransactionOrVersionedTransaction } from "../../../providers/solana-provider";
 export type IUseSignTransaction = {
     loading: boolean;
     error: Web3AuthError | null;
     data: string | null;
-    signTransaction: (transaction: TransactionOrVersionedTransaction) => Promise<string>;
+    /**
+     * Signs a transaction and returns the signature
+     * @param transaction - Compiled transaction from \@solana/kit
+     * @returns The signature of the transaction encoded in base58
+     */
+    signTransaction: (transaction: Transaction) => Promise<string>;
 };
 export declare const useSignTransaction: () => {
     loading: boolean;
     error: Web3AuthError;
     data: string;
-    signTransaction: (transaction: TransactionOrVersionedTransaction) => Promise<string>;
+    signTransaction: (transaction: Transaction) => Promise<string>;
 };

package/dist/lib.cjs/types/react/solana/hooks/useSolanaWallet.d.ts

@@ -1,8 +1,21 @@
-import { Connection } from "@solana/web3.js";
-import { SolanaWallet } from "../../../providers/solana-provider";
+import { type Rpc, type SolanaRpcApi } from "@solana/kit";
+import type { Wallet } from "@wallet-standard/base";
 export type IUseSolanaWallet = {
     accounts: string[] | null;
-    solanaWallet: SolanaWallet | null;
-    connection: Connection | null;
+    solanaWallet: Wallet | null;
+    /**
+     * Solana RPC client for making RPC calls.
+     * @example
+     * ```typescript
+     * const { value: balance } = await rpc.getBalance(address("...")).send();
+     * const { value: latestBlockhash } = await rpc.getLatestBlockhash().send();
+     * ```
+     */
+    rpc: Rpc<SolanaRpcApi> | null;
+    /**
+     * Returns the Solana ed25519 private key. Only works with the Auth connector.
+     * @throws Error if connected via a non-Auth connector or if the provider is unavailable.
+     */
+    getPrivateKey: () => Promise<string>;
 };
 export declare const useSolanaWallet: () => IUseSolanaWallet;

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

@@ -1 +1,2 @@
 export * from "./hooks";
+export * from "./provider";