@web3auth/no-modal 10.0.0-alpha.0 → 10.0.0-alpha.1

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

@@ -0,0 +1,7 @@
+import { BaseConnector, ConnectorInitOptions, UserAuthInfo } from "../../base";
+export declare abstract class BaseSolanaConnector<T> extends BaseConnector<T> {
+    init(_?: ConnectorInitOptions): Promise<void>;
+    authenticateUser(): Promise<UserAuthInfo>;
+    disconnectSession(): Promise<void>;
+    disconnect(): Promise<void>;
+}

package/dist/types/connectors/base-solana-connector/index.d.ts

@@ -0,0 +1 @@
+export * from "./baseSolanaConnector";

package/dist/types/connectors/coinbase-connector/coinbaseConnector.d.ts

@@ -0,0 +1,7 @@
+import { AppMetadata, Preference } from "@coinbase/wallet-sdk";
+import { BaseConnectorSettings, ConnectorFn } from "../../base";
+export type CoinbaseWalletSDKOptions = Partial<AppMetadata & Preference>;
+export interface CoinbaseConnectorOptions extends BaseConnectorSettings {
+    connectorSettings?: CoinbaseWalletSDKOptions;
+}
+export declare const coinbaseConnector: (params?: CoinbaseWalletSDKOptions) => ConnectorFn;

package/dist/types/connectors/coinbase-connector/index.d.ts

@@ -0,0 +1 @@
+export * from "./coinbaseConnector";

package/dist/types/connectors/index.d.ts

@@ -0,0 +1,7 @@
+export * from "./auth-connector";
+export * from "./base-evm-connector";
+export * from "./base-solana-connector";
+export * from "./coinbase-connector";
+export * from "./injected-evm-connector";
+export * from "./injected-solana-connector";
+export * from "./wallet-connect-v2-connector";

package/dist/types/connectors/injected-evm-connector/index.d.ts

@@ -0,0 +1,2 @@
+export { injectedEvmConnector } from "./injectedEvmConnector";
+export { createStore as createMipd } from "mipd";

package/dist/types/connectors/injected-evm-connector/injectedEvmConnector.d.ts

@@ -0,0 +1,34 @@
+import { type EIP6963ProviderDetail } from "mipd";
+import { BaseConnectorSettings, ChainNamespaceType, 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;
+    readonly currentChainNamespace: ChainNamespaceType;
+    readonly type: CONNECTOR_CATEGORY_TYPE;
+    readonly name: string;
+    readonly isInjected = true;
+    status: CONNECTOR_STATUS_TYPE;
+    private injectedProvider;
+    constructor(options: BaseConnectorSettings & {
+        name: string;
+        provider: IProvider;
+    });
+    get provider(): IProvider | null;
+    set provider(_: IProvider | null);
+    init(options: ConnectorInitOptions): Promise<void>;
+    connect({ chainId }: {
+        chainId: string;
+    }): Promise<IProvider | null>;
+    disconnect(options?: {
+        cleanup: boolean;
+    }): Promise<void>;
+    getUserInfo(): Promise<Partial<UserInfo>>;
+    addChain(chainConfig: CustomChainConfig, _init?: boolean): Promise<void>;
+    switchChain(params: {
+        chainId: string;
+    }, init?: boolean): Promise<void>;
+    enableMFA(): Promise<void>;
+    manageMFA(): Promise<void>;
+}
+export declare const injectedEvmConnector: (providerDetail: EIP6963ProviderDetail) => ConnectorFn;
+export { InjectedEvmConnector };

package/dist/types/connectors/injected-solana-connector/index.d.ts

@@ -0,0 +1,5 @@
+import { getWallets, type WalletsEventNames } from "@wallet-standard/app";
+import { type Wallet } from "@wallet-standard/base";
+import { walletStandardConnector } from "./walletStandardConnector";
+declare const hasSolanaWalletStandardFeatures: (wallet: Wallet) => boolean;
+export { getWallets as createSolanaMipd, hasSolanaWalletStandardFeatures, type WalletsEventNames, walletStandardConnector };

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

@@ -0,0 +1,33 @@
+import { Wallet } from "@wallet-standard/base";
+import { BaseConnectorSettings, ChainNamespaceType, CONNECTOR_CATEGORY_TYPE, CONNECTOR_STATUS_TYPE, ConnectorFn, ConnectorInitOptions, ConnectorNamespaceType, IProvider, UserInfo } from "../../base";
+import { BaseSolanaConnector } from "../base-solana-connector";
+export declare class WalletStandardConnector extends BaseSolanaConnector<void> {
+    readonly name: string;
+    readonly connectorNamespace: ConnectorNamespaceType;
+    readonly currentChainNamespace: ChainNamespaceType;
+    readonly type: CONNECTOR_CATEGORY_TYPE;
+    readonly isInjected = true;
+    status: CONNECTOR_STATUS_TYPE;
+    private wallet;
+    private injectedProvider;
+    constructor(options: BaseConnectorSettings & {
+        name: string;
+        wallet: Wallet;
+    });
+    get provider(): IProvider;
+    get isWalletConnected(): boolean;
+    init(options: ConnectorInitOptions): Promise<void>;
+    connect({ chainId }: {
+        chainId: string;
+    }): Promise<IProvider>;
+    disconnect(options?: {
+        cleanup: boolean;
+    }): Promise<void>;
+    getUserInfo(): Promise<Partial<UserInfo>>;
+    switchChain(params: {
+        chainId: string;
+    }, init?: boolean): Promise<void>;
+    enableMFA(): Promise<void>;
+    manageMFA(): Promise<void>;
+}
+export declare const walletStandardConnector: (wallet: Wallet) => ConnectorFn;

package/dist/types/{adapters/wallet-connect-v2-adapter → connectors/wallet-connect-v2-connector}/WalletConnectV2Provider.d.ts

@@ -2,7 +2,6 @@ import type { ISignClient } from "@walletconnect/types";
 import { CustomChainConfig } from "../../base";
 import { BaseProvider, BaseProviderConfig, BaseProviderState } from "../../providers/base-provider";
 export interface WalletConnectV2ProviderConfig extends BaseProviderConfig {
-    chainConfig: CustomChainConfig;
 }
 export interface WalletConnectV2ProviderState extends BaseProviderState {
     accounts: string[];
@@ -16,16 +15,16 @@ export declare class WalletConnectV2Provider extends BaseProvider<BaseProviderCo
     });
     static getProviderInstance: (params: {
         connector: ISignClient;
-        chainConfig: CustomChainConfig;
         skipLookupNetwork: boolean;
+        chain: CustomChainConfig;
+        chains: CustomChainConfig[];
     }) => Promise<WalletConnectV2Provider>;
     enable(): Promise<string[]>;
     setupProvider(connector: ISignClient): Promise<void>;
     switchChain({ chainId }: {
         chainId: string;
     }): Promise<void>;
-    addChain(chainConfig: CustomChainConfig): Promise<void>;
-    protected lookupNetwork(_: ISignClient): Promise<string>;
+    protected lookupNetwork(_: ISignClient, chainId: string): Promise<string>;
     private setupEngine;
     private setupEthEngine;
     private setupSolEngine;

package/dist/types/{adapters/wallet-connect-v2-adapter → connectors/wallet-connect-v2-connector}/config.d.ts

@@ -1,6 +1,6 @@
 import type { EngineTypes, ProposalTypes } from "@walletconnect/types";
-import { ChainNamespaceType } from "../../base";
-import { IAdapterSettings } from "./interface";
+import { CustomChainConfig } from "../../base";
+import { IConnectorSettings } from "./interface";
 export declare enum DEFAULT_EIP155_METHODS {
     ETH_SEND_TRANSACTION = "eth_sendTransaction",
     ETH_SIGN_TRANSACTION = "eth_signTransaction",
@@ -29,7 +29,7 @@ export declare const getNamespacesFromChains: (chains: string[]) => string[];
 export declare const getSupportedMethodsByNamespace: (namespace: string) => DEFAULT_EIP155_METHODS[] | DEFAULT_SOLANA_METHODS[];
 export declare const getSupportedEventsByNamespace: (namespace: string) => DEFAULT_EIP_155_EVENTS[] | DEFAULT_SOLANA_EVENTS[];
 export declare const getRequiredNamespaces: (chains: string[]) => ProposalTypes.RequiredNamespaces;
-export declare const getWalletConnectV2Settings: (namespace: ChainNamespaceType, chainIds: string[], projectID: string) => Promise<{
-    adapterSettings: IAdapterSettings;
+export declare const getWalletConnectV2Settings: (chains: CustomChainConfig[], projectID: string) => Promise<{
+    connectorSettings: IConnectorSettings;
     loginSettings: EngineTypes.ConnectParams;
 }>;

package/dist/types/{adapters/wallet-connect-v2-adapter → connectors/wallet-connect-v2-connector}/index.d.ts

@@ -1,4 +1,4 @@
 export * from "./config";
 export * from "./interface";
-export * from "./walletConnectV2adapter";
+export * from "./walletConnectV2Connector";
 export * from "./WalletConnectV2Provider";

package/dist/types/{adapters/wallet-connect-v2-adapter → connectors/wallet-connect-v2-connector}/interface.d.ts

@@ -1,5 +1,5 @@
 import type { EngineTypes, SignClientTypes } from "@walletconnect/types";
-import { BaseAdapterSettings } from "../../base";
+import { BaseConnectorSettings } from "../../base";
 export interface OpenOptions {
     uri: string;
     chains?: string[];
@@ -8,11 +8,11 @@ export interface IQRCodeModal {
     openModal: (options?: OpenOptions) => Promise<void>;
     closeModal: () => void;
 }
-export interface IAdapterSettings {
+export interface IConnectorSettings {
     walletConnectInitOptions?: SignClientTypes.Options;
     qrcodeModal?: IQRCodeModal;
 }
-export interface WalletConnectV2AdapterOptions extends BaseAdapterSettings {
-    adapterSettings?: IAdapterSettings;
+export interface WalletConnectV2ConnectorOptions extends BaseConnectorSettings {
+    connectorSettings?: IConnectorSettings;
     loginSettings?: EngineTypes.ConnectParams;
 }

package/dist/types/connectors/wallet-connect-v2-connector/walletConnectV2Connector.d.ts

@@ -0,0 +1,3 @@
+import { ConnectorFn } from "../../base";
+import { IConnectorSettings } from "./interface";
+export declare const walletConnectV2Connector: (params?: IConnectorSettings) => ConnectorFn;

package/dist/types/{adapters/wallet-connect-v2-adapter → connectors/wallet-connect-v2-connector}/walletConnectV2Utils.d.ts

@@ -1,5 +1,5 @@
 import type { ISignClient } from "@walletconnect/types";
-import type { AddEthereumChainParameter, IEthProviderHandlers } from "../../providers/ethereum-provider";
+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[]>;
@@ -16,8 +16,3 @@ export declare function switchChain({ connector, chainId, newChainId, }: {
     chainId: number;
     newChainId: string;
 }): Promise<void>;
-export declare function addChain({ connector, chainId, chainConfig, }: {
-    connector: ISignClient;
-    chainId: number;
-    chainConfig: AddEthereumChainParameter;
-}): Promise<void>;

package/dist/types/index.d.ts

@@ -1,5 +1,5 @@
-export * from "./adapters";
 export * from "./base";
+export * from "./connectors";
 export * from "./noModal";
 export * from "./plugins";
 export * from "./providers";

package/dist/types/noModal.d.ts

@@ -1,32 +1,33 @@
 import { SafeEventEmitter } from "@web3auth/auth";
-import { ADAPTER_STATUS_TYPE, CustomChainConfig, IAdapter, IPlugin, IProvider, IWeb3Auth, IWeb3AuthCoreOptions, UserAuthInfo, UserInfo, WALLET_ADAPTER_TYPE, Web3AuthNoModalEvents } from "./base";
-import { CommonJRPCProvider } from "./providers";
+import { CONNECTOR_STATUS_TYPE, CustomChainConfig, IConnector, IPlugin, IProvider, IWeb3Auth, IWeb3AuthCoreOptions, PROJECT_CONFIG_RESPONSE, UserAuthInfo, UserInfo, WALLET_CONNECTOR_TYPE, Web3AuthNoModalEvents } from "./base";
+import { CommonJRPCProvider } from "./providers/base-provider";
 export declare class Web3AuthNoModal extends SafeEventEmitter<Web3AuthNoModalEvents> implements IWeb3Auth {
     readonly coreOptions: IWeb3AuthCoreOptions;
-    connectedAdapterName: WALLET_ADAPTER_TYPE | null;
-    status: ADAPTER_STATUS_TYPE;
-    cachedAdapter: string | null;
-    walletAdapters: Record<string, IAdapter<unknown>>;
+    connectedConnectorName: WALLET_CONNECTOR_TYPE | null;
+    status: CONNECTOR_STATUS_TYPE;
+    cachedConnector: string | null;
+    protected currentChainId: string;
+    protected connectors: IConnector<unknown>[];
     protected commonJRPCProvider: CommonJRPCProvider | null;
     private plugins;
     private storage;
     constructor(options: IWeb3AuthCoreOptions);
+    get currentChain(): CustomChainConfig;
     get connected(): boolean;
     get provider(): IProvider | null;
+    get connectedConnector(): IConnector<unknown> | null;
     set provider(_: IProvider | null);
     init(): Promise<void>;
-    getAdapter(adapterName: WALLET_ADAPTER_TYPE): IAdapter<unknown> | null;
-    configureAdapter(adapter: IAdapter<unknown>): Web3AuthNoModal;
+    getConnector(connectorName: WALLET_CONNECTOR_TYPE): IConnector<unknown> | null;
     clearCache(): void;
-    addChain(chainConfig: CustomChainConfig): Promise<void>;
     switchChain(params: {
         chainId: string;
     }): Promise<void>;
     /**
-     * Connect to a specific wallet adapter
-     * @param walletName - Key of the walletAdapter to use.
+     * Connect to a specific wallet connector
+     * @param connectorName - Key of the wallet connector to use.
      */
-    connectTo<T>(walletName: WALLET_ADAPTER_TYPE, loginParams?: T): Promise<IProvider | null>;
+    connectTo<T>(connectorName: WALLET_CONNECTOR_TYPE, loginParams?: T): Promise<IProvider | null>;
     logout(options?: {
         cleanup: boolean;
     }): Promise<void>;
@@ -34,10 +35,24 @@ export declare class Web3AuthNoModal extends SafeEventEmitter<Web3AuthNoModalEve
     enableMFA<T>(loginParams?: T): Promise<void>;
     manageMFA<T>(loginParams?: T): Promise<void>;
     authenticateUser(): Promise<UserAuthInfo>;
-    addPlugin(plugin: IPlugin): IWeb3Auth;
     getPlugin(name: string): IPlugin | null;
-    protected subscribeToAdapterEvents(walletAdapter: IAdapter<unknown>): void;
+    protected initCachedConnectorAndChainId(): void;
+    protected setupCommonJRPCProvider(): Promise<void>;
+    protected setupConnector(connector: IConnector<unknown>): Promise<void>;
+    protected loadConnectors({ projectConfig }: {
+        projectConfig: PROJECT_CONFIG_RESPONSE;
+    }): Promise<void>;
+    protected initPlugins(): Promise<void>;
+    protected setConnectors(connectors: IConnector<unknown>[]): void;
+    protected subscribeToConnectorEvents(connector: IConnector<unknown>): void;
     protected checkInitRequirements(): void;
+    /**
+     * Gets the initial chain configuration for a connector
+     * @throws WalletInitializationError If no chain is found for the connector's namespace
+     */
+    protected getInitialChainIdForConnector(connector: IConnector<unknown>): CustomChainConfig;
     private cacheWallet;
+    private setCurrentChain;
+    private cacheCurrentChain;
     private connectToPlugins;
 }

package/dist/types/plugins/nft-checkout-plugin/plugin.d.ts

@@ -1,18 +1,19 @@
 import { SafeEventEmitter, type WhiteLabelData } from "@web3auth/auth";
-import { IPlugin, IWeb3AuthCore, PLUGIN_STATUS_TYPE } from "../../base";
-export declare class NFTCheckoutPlugin extends SafeEventEmitter implements IPlugin {
+import { IPlugin, IWeb3AuthCore, PLUGIN_STATUS_TYPE, PluginFn } from "../../base";
+export interface NFTCheckoutPluginParams {
+    modalZIndex?: number;
+    clientId: string;
+}
+declare class NFTCheckoutPlugin extends SafeEventEmitter implements IPlugin {
     name: "nft-checkout";
     status: PLUGIN_STATUS_TYPE;
-    SUPPORTED_ADAPTERS: string[];
+    SUPPORTED_CONNECTORS: string[];
     pluginNamespace: "eip155";
     private web3auth;
     private nftCheckoutEmbedInstance;
     private isInitialized;
     private receiverAddress;
-    constructor(params: {
-        modalZIndex?: number;
-        clientId: string;
-    });
+    constructor(params: NFTCheckoutPluginParams);
     initWithWeb3Auth(web3auth: IWeb3AuthCore, whiteLabel?: WhiteLabelData): Promise<void>;
     connect(): Promise<void>;
     show({ contractId }: {
@@ -21,3 +22,6 @@ export declare class NFTCheckoutPlugin extends SafeEventEmitter implements IPlug
     disconnect(): Promise<void>;
     cleanup(): Promise<void>;
 }
+export type NFTCheckoutPluginType = NFTCheckoutPlugin;
+export declare const nftCheckoutPlugin: (params: NFTCheckoutPluginParams) => PluginFn;
+export {};

package/dist/types/plugins/wallet-services-plugin/plugin.d.ts

@@ -1,51 +1,27 @@
 import { type BaseEmbedControllerState } from "@toruslabs/base-controllers";
 import { SafeEventEmitter, type WhiteLabelData } from "@web3auth/auth";
-import WsEmbed, { CtorArgs, WsEmbedParams } from "@web3auth/ws-embed";
-import { IPlugin, IWeb3AuthCore, PLUGIN_STATUS_TYPE, PluginConnectParams, SafeEventEmitterProvider } from "../../base";
-type WsPluginEmbedParams = Omit<WsEmbedParams, "buildEnv" | "enableLogging" | "chainConfig" | "confirmationStrategy"> & {
-    /**
-     * Determines how to show confirmation screens
-     * @defaultValue default
-     *
-     * default & auto-approve
-     * - use auto-approve as default
-     * - if wallet connect request use modal
-     *
-     * modal
-     * - use modal always
-     */
-    confirmationStrategy?: Exclude<WsEmbedParams["confirmationStrategy"], "popup">;
-};
+import WsEmbed from "@web3auth/ws-embed";
+import { IPlugin, IWeb3AuthCore, PLUGIN_STATUS_TYPE, PluginFn, SafeEventEmitterProvider } from "../../base";
 export { BUTTON_POSITION, type BUTTON_POSITION_TYPE, CONFIRMATION_STRATEGY, type CONFIRMATION_STRATEGY_TYPE } from "@web3auth/ws-embed";
-export declare class WalletServicesPlugin extends SafeEventEmitter implements IPlugin {
+declare class WalletServicesPlugin extends SafeEventEmitter implements IPlugin {
     name: "wallet-services";
     status: PLUGIN_STATUS_TYPE;
-    readonly SUPPORTED_ADAPTERS: string[];
+    readonly SUPPORTED_CONNECTORS: string[];
     readonly pluginNamespace: "multichain";
     wsEmbedInstance: WsEmbed;
     private provider;
     private web3auth;
     private isInitialized;
-    private walletInitOptions;
-    constructor(options?: {
-        wsEmbedOpts?: Partial<CtorArgs>;
-        walletInitOptions?: WsPluginEmbedParams;
-    });
     get proxyProvider(): SafeEventEmitterProvider | null;
-    initWithWeb3Auth(web3auth: IWeb3AuthCore, whiteLabel?: WhiteLabelData): Promise<void>;
+    initWithWeb3Auth(web3auth: IWeb3AuthCore, _whiteLabel?: WhiteLabelData): Promise<void>;
     initWithProvider(): Promise<void>;
-    connect({ sessionId, sessionNamespace }: PluginConnectParams): Promise<void>;
+    connect(): Promise<void>;
     showWalletConnectScanner(showWalletConnectParams?: BaseEmbedControllerState["showWalletConnect"]): Promise<void>;
     showCheckout(showCheckoutParams?: BaseEmbedControllerState["showCheckout"]): Promise<void>;
     showWalletUi(showWalletUiParams?: BaseEmbedControllerState["showWalletUi"]): Promise<void>;
     showSwap(showSwapParams?: BaseEmbedControllerState["showSwap"]): Promise<void>;
     cleanup(): Promise<void>;
     disconnect(): Promise<void>;
-    private subscribeToWalletEvents;
-    private subscribeToProviderEvents;
-    private subscribeToWeb3AuthEvents;
-    private sessionConfig;
-    private walletServicesSessionConfig;
-    private setSelectedAddress;
-    private setChainID;
 }
+export type WalletServicesPluginType = WalletServicesPlugin;
+export declare const walletServicesPlugin: () => PluginFn;

package/dist/types/providers/account-abstraction-provider/providers/AccountAbstractionProvider.d.ts

@@ -1,18 +1,17 @@
-import { Client } from "viem";
-import { BundlerClient, PaymasterClient, SmartAccount } from "viem/account-abstraction";
-import { CustomChainConfig, IProvider } from "../../../base";
-import { BaseProvider, BaseProviderConfig, BaseProviderState } from "../../base-provider";
-import { ISmartAccount } from "./smartAccounts";
-import { BundlerConfig, PaymasterConfig } from "./types";
-export interface AccountAbstractionProviderConfig extends BaseProviderConfig {
+import { type AccountAbstractionConfig, type BundlerConfig, type ISmartAccount, type PaymasterConfig, SMART_ACCOUNT } from "@toruslabs/ethereum-controllers";
+import { type Client } from "viem";
+import { type BundlerClient, type PaymasterClient, type SmartAccount } from "viem/account-abstraction";
+import { type CustomChainConfig, type IProvider } from "../../../base";
+import { BaseProvider, type BaseProviderConfig, type BaseProviderState } from "../../base-provider";
+interface AccountAbstractionProviderConfig extends BaseProviderConfig {
     smartAccountInit: ISmartAccount;
     bundlerConfig: BundlerConfig;
     paymasterConfig?: PaymasterConfig;
 }
-export interface AccountAbstractionProviderState extends BaseProviderState {
+interface AccountAbstractionProviderState extends BaseProviderState {
     eoaProvider?: IProvider;
 }
-export declare class AccountAbstractionProvider extends BaseProvider<AccountAbstractionProviderConfig, AccountAbstractionProviderState, IProvider> {
+declare class AccountAbstractionProvider extends BaseProvider<AccountAbstractionProviderConfig, AccountAbstractionProviderState, IProvider> {
     readonly PROVIDER_CHAIN_NAMESPACE: "eip155";
     private _smartAccount;
     private _publicClient;
@@ -26,12 +25,8 @@ export declare class AccountAbstractionProvider extends BaseProvider<AccountAbst
     get bundlerClient(): BundlerClient | null;
     get paymasterClient(): PaymasterClient | null;
     get publicClient(): Client | null;
-    static getProviderInstance: (params: {
+    static getProviderInstance: (params: AccountAbstractionProviderConfig & {
         eoaProvider: IProvider;
-        smartAccountInit: ISmartAccount;
-        chainConfig: CustomChainConfig;
-        bundlerConfig: BundlerConfig;
-        paymasterConfig?: PaymasterConfig;
     }) => Promise<AccountAbstractionProvider>;
     enable(): Promise<string[]>;
     setupProvider(eoaProvider: IProvider): Promise<void>;
@@ -44,3 +39,10 @@ export declare class AccountAbstractionProvider extends BaseProvider<AccountAbst
     protected lookupNetwork(): Promise<string>;
     private setupChainSwitchMiddleware;
 }
+export declare const accountAbstractionProvider: ({ accountAbstractionConfig, chain, chains, provider, }: {
+    accountAbstractionConfig: AccountAbstractionConfig;
+    chain: CustomChainConfig;
+    chains: CustomChainConfig[];
+    provider: IProvider;
+}) => Promise<AccountAbstractionProvider>;
+export { type AccountAbstractionConfig, type BundlerConfig, type PaymasterConfig, SMART_ACCOUNT };

package/dist/types/providers/account-abstraction-provider/providers/index.d.ts

@@ -1,3 +1,2 @@
 export * from "./AccountAbstractionProvider";
 export * from "./smartAccounts";
-export * from "./types";

package/dist/types/providers/account-abstraction-provider/providers/smartAccounts/index.d.ts

@@ -1,6 +1 @@
-export * from "./BiconomySmartAccount";
-export * from "./KernelSmartAccount";
-export * from "./NexusSmartAccount";
-export * from "./SafeSmartAccount";
-export * from "./TrustSmartAccount";
-export * from "./types";
+export { BiconomySmartAccount, type BiconomySmartAccountConfig, type ISmartAccount, KernelSmartAccount, type KernelSmartAccountConfig, NexusSmartAccount, type NexusSmartAccountConfig, SafeSmartAccount, type SafeSmartAccountConfig, TrustSmartAccount, type TrustSmartAccountConfig, } from "@toruslabs/ethereum-controllers";

package/dist/types/providers/base-provider/CommonJRPCProvider.d.ts

@@ -8,13 +8,13 @@ export declare class CommonJRPCProvider extends BaseProvider<CommonJRPCProviderC
         state?: CommonJRPCProviderState;
     });
     static getProviderInstance: (params: {
-        chainConfig: CustomChainConfig;
+        chain: CustomChainConfig;
+        chains: CustomChainConfig[];
     }) => Promise<CommonJRPCProvider>;
-    setupProvider(): Promise<void>;
+    setupProvider(chainId: string): Promise<void>;
     switchChain(params: {
         chainId: string;
     }): Promise<void>;
-    updateProviderEngineProxy(provider: SafeEventEmitterProvider): void;
     protected getProviderEngineProxy(): SafeEventEmitterProvider | null;
     protected lookupNetwork(): Promise<string | void>;
 }

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

@@ -1,39 +1,42 @@
 import { BaseConfig, BaseController, BaseState } from "@toruslabs/base-controllers";
-import { JRPCRequest, JRPCResponse, SendCallBack } from "@web3auth/auth";
+import { JRPCRequest, JRPCResponse, ProviderEvents, SendCallBack } from "@web3auth/auth";
 import { CustomChainConfig, IBaseProvider, Maybe, RequestArguments, SafeEventEmitterProvider } from "../../base";
 import { BaseProviderEvents } from "./interfaces";
 export interface BaseProviderState extends BaseState {
     chainId: string;
 }
 export interface BaseProviderConfig extends BaseConfig {
-    chainConfig: CustomChainConfig;
-    networks?: Record<string, CustomChainConfig>;
+    chain: CustomChainConfig;
+    chains: CustomChainConfig[];
     skipLookupNetwork?: boolean;
     keyExportEnabled?: boolean;
 }
+export interface CommonProviderEvents extends ProviderEvents {
+    chainChanged: (chainId: string) => void;
+}
 export declare abstract class BaseProvider<C extends BaseProviderConfig, S extends BaseProviderState, P> extends BaseController<C, S, BaseProviderEvents<S>> implements IBaseProvider<P> {
-    _providerEngineProxy: SafeEventEmitterProvider | null;
+    _providerEngineProxy: SafeEventEmitterProvider<CommonProviderEvents> | null;
     private keyExportFlagSetByCode;
     constructor({ config, state }: {
         config: C;
         state?: S;
     });
-    get currentChainConfig(): CustomChainConfig;
-    get provider(): SafeEventEmitterProvider | null;
+    get currentChain(): CustomChainConfig;
+    get provider(): SafeEventEmitterProvider<CommonProviderEvents> | null;
     get chainId(): string;
-    set provider(_: SafeEventEmitterProvider | null);
+    set provider(_: SafeEventEmitterProvider<CommonProviderEvents> | null);
     request<T, R>(args: RequestArguments<T>): Promise<Maybe<R>>;
     sendAsync<T, U>(req: JRPCRequest<T>, callback: SendCallBack<JRPCResponse<U>>): void;
     sendAsync<T, U>(req: JRPCRequest<T>): Promise<JRPCResponse<U>>;
     send<T, U>(req: JRPCRequest<T>, callback: SendCallBack<JRPCResponse<U>>): void;
-    addChain(chainConfig: CustomChainConfig): void;
-    getChainConfig(chainId: string): CustomChainConfig | null;
     updateProviderEngineProxy(provider: SafeEventEmitterProvider): void;
     setKeyExportFlag(flag: boolean): void;
     protected getProviderEngineProxy(): SafeEventEmitterProvider | null;
-    abstract setupProvider(provider: P): Promise<void>;
+    protected getChain(chainId: string): CustomChainConfig;
+    private handleChainChangedProvider;
+    abstract setupProvider(provider: P, chainId: string): Promise<void>;
     abstract switchChain(params: {
         chainId: string;
     }): Promise<void>;
-    protected abstract lookupNetwork(provider?: P): Promise<string | void>;
+    protected abstract lookupNetwork(provider?: P, chainId?: string): Promise<string | void>;
 }

package/dist/types/providers/base-provider/commonPrivateKeyProvider.d.ts

@@ -1,7 +1,6 @@
 import { CustomChainConfig, IBaseProvider, SafeEventEmitterProvider } from "../../base";
 import { BaseProvider, BaseProviderConfig, BaseProviderState } from "./baseProvider";
 export interface CommonPrivKeyProviderConfig extends BaseProviderConfig {
-    chainConfig: CustomChainConfig;
 }
 export interface CommonPrivKeyProviderState extends BaseProviderState {
     privateKey?: string;
@@ -16,11 +15,10 @@ export declare class CommonPrivateKeyProvider extends BaseProvider<BaseProviderC
     set provider(_: SafeEventEmitterProvider | null);
     static getProviderInstance: (params: {
         privKey: string;
-        chainConfig: CustomChainConfig;
+        chain: CustomChainConfig;
+        chains: CustomChainConfig[];
     }) => Promise<CommonPrivateKeyProvider>;
-    addChain(_: CustomChainConfig): void;
     setupProvider(privKey: string): Promise<void>;
-    updateProviderEngineProxy(provider: SafeEventEmitterProvider): void;
     switchChain(_: {
         chainId: string;
     }): Promise<void>;

package/dist/types/providers/ethereum-mpc-provider/providers/signingProviders/EthereumSigningProvider.d.ts

@@ -1,7 +1,14 @@
 import { CustomChainConfig } from "../../../../base";
 import { BaseProvider, BaseProviderConfig, BaseProviderState } from "../../../base-provider";
+interface ProviderParams {
+    sign: (msgHash: Buffer, rawMsg?: Buffer) => Promise<{
+        v: number;
+        r: Buffer;
+        s: Buffer;
+    }>;
+    getPublic: () => Promise<Buffer>;
+}
 export interface EthereumSigningProviderConfig extends BaseProviderConfig {
-    chainConfig: CustomChainConfig;
 }
 export interface EthereumSigningProviderState extends BaseProviderState {
     signMethods?: {
@@ -35,17 +42,18 @@ export declare class EthereumSigningProvider extends BaseProvider<BaseProviderCo
             }>;
             getPublic: () => Promise<Buffer>;
         };
-        chainConfig: CustomChainConfig;
+        chain: CustomChainConfig;
+        chains: CustomChainConfig[];
     }) => Promise<EthereumSigningProvider>;
     enable(): Promise<string[]>;
-    setupProvider({ sign, getPublic, }: {
+    setupProvider(params: {
         sign: (msgHash: Buffer, rawMsg?: Buffer) => Promise<{
             v: number;
             r: Buffer;
             s: Buffer;
         }>;
         getPublic: () => Promise<Buffer>;
-    }): Promise<void>;
+    }, chainId: string): Promise<void>;
     updateAccount(params: {
         signMethods: {
             sign: (msgHash: Buffer, rawMsg?: Buffer) => Promise<{
@@ -59,7 +67,8 @@ export declare class EthereumSigningProvider extends BaseProvider<BaseProviderCo
     switchChain(params: {
         chainId: string;
     }): Promise<void>;
-    protected lookupNetwork(): Promise<string>;
+    protected lookupNetwork(_: ProviderParams, chainId: string): Promise<string>;
     private getChainSwitchMiddleware;
     private getAccountMiddleware;
 }
+export {};

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

@@ -1,2 +1 @@
-export * from "./EthereumPrivateKeyProvider";
 export * from "./TransactionFormatter";

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

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

package/dist/types/providers/ethereum-provider/rpc/interfaces.d.ts

@@ -5,20 +5,7 @@ export interface IEthAccountHandlers {
         privateKey: string;
     }) => Promise<void>;
 }
-export interface AddEthereumChainParameter {
-    chainId: string;
-    chainName: string;
-    nativeCurrency: {
-        name: string;
-        symbol: string;
-        decimals: 18;
-    };
-    rpcUrls: string[];
-    blockExplorerUrls?: string[];
-    iconUrls?: string[];
-}
 export interface IEthChainSwitchHandlers {
-    addChain: (params: AddEthereumChainParameter) => Promise<void>;
     switchChain: (params: {
         chainId: string;
     }) => Promise<void>;