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

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

@@ -0,0 +1,24 @@
+import { WhiteLabelData } from "@web3auth/auth";
+import { NFT_CHECKOUT_BUILD_ENV_TYPE } from "./enums";
+export declare class NFTCheckoutEmbed {
+    clientId: string;
+    isInitialized: boolean;
+    private modalZIndex;
+    private buildEnv;
+    private readonly embedNonce;
+    constructor({ modalZIndex, clientId }: {
+        modalZIndex?: number;
+        clientId: string;
+    });
+    init(params?: {
+        buildEnv?: NFT_CHECKOUT_BUILD_ENV_TYPE;
+        whiteLabel?: WhiteLabelData;
+    }): Promise<void>;
+    show({ receiverAddress, contractId }: {
+        receiverAddress?: string;
+        contractId: string;
+    }): void;
+    hide(): void;
+    cleanup(): void;
+    private getIframe;
+}

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

@@ -0,0 +1,14 @@
+export declare const NFT_CHECKOUT_BUILD_ENV: {
+    readonly PRODUCTION: "production";
+    readonly STAGING: "staging";
+    readonly DEVELOPMENT: "development";
+    readonly TESTING: "testing";
+};
+export type NFT_CHECKOUT_BUILD_ENV_TYPE = (typeof NFT_CHECKOUT_BUILD_ENV)[keyof typeof NFT_CHECKOUT_BUILD_ENV];
+export declare const NFT_CHECKOUT_URLS: Record<NFT_CHECKOUT_BUILD_ENV_TYPE, string>;
+export declare const NFT_CHECKOUT_EMBED_MESSAGE_TYPES: {
+    readonly INIT: "init";
+    readonly SETUP_COMPLETE: "setup_complete";
+    readonly SHOW_NFT_CHECKOUT: "show_nft_checkout";
+    readonly HIDE_NFT_CHECKOUT: "hide_nft_checkout";
+};

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

@@ -0,0 +1,2 @@
+export * from "./embed";
+export * from "./plugin";

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

@@ -0,0 +1,23 @@
+import { SafeEventEmitter, type WhiteLabelData } from "@web3auth/auth";
+import { IPlugin, IWeb3AuthCore, PLUGIN_STATUS_TYPE } from "../../base";
+export declare class NFTCheckoutPlugin extends SafeEventEmitter implements IPlugin {
+    name: "nft-checkout";
+    status: PLUGIN_STATUS_TYPE;
+    SUPPORTED_ADAPTERS: string[];
+    pluginNamespace: "eip155";
+    private web3auth;
+    private nftCheckoutEmbedInstance;
+    private isInitialized;
+    private receiverAddress;
+    constructor(params: {
+        modalZIndex?: number;
+        clientId: string;
+    });
+    initWithWeb3Auth(web3auth: IWeb3AuthCore, whiteLabel?: WhiteLabelData): Promise<void>;
+    connect(): Promise<void>;
+    show({ contractId }: {
+        contractId: string;
+    }): Promise<void>;
+    disconnect(): Promise<void>;
+    cleanup(): Promise<void>;
+}

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

@@ -0,0 +1,3 @@
+import { THEME_MODE_TYPE } from "@web3auth/auth";
+export declare const htmlToElement: <T extends Element>(html: string) => T;
+export declare const getTheme: (theme: THEME_MODE_TYPE) => string;

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

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

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

@@ -0,0 +1,51 @@
+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">;
+};
+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 {
+    name: "wallet-services";
+    status: PLUGIN_STATUS_TYPE;
+    readonly SUPPORTED_ADAPTERS: 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>;
+    initWithProvider(): Promise<void>;
+    connect({ sessionId, sessionNamespace }: PluginConnectParams): 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;
+}

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

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

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

@@ -0,0 +1,46 @@
+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 {
+    smartAccountInit: ISmartAccount;
+    bundlerConfig: BundlerConfig;
+    paymasterConfig?: PaymasterConfig;
+}
+export interface AccountAbstractionProviderState extends BaseProviderState {
+    eoaProvider?: IProvider;
+}
+export declare class AccountAbstractionProvider extends BaseProvider<AccountAbstractionProviderConfig, AccountAbstractionProviderState, IProvider> {
+    readonly PROVIDER_CHAIN_NAMESPACE: "eip155";
+    private _smartAccount;
+    private _publicClient;
+    private _bundlerClient;
+    private _paymasterClient;
+    constructor({ config, state }: {
+        config: AccountAbstractionProviderConfig;
+        state?: AccountAbstractionProviderState;
+    });
+    get smartAccount(): SmartAccount | null;
+    get bundlerClient(): BundlerClient | null;
+    get paymasterClient(): PaymasterClient | null;
+    get publicClient(): Client | null;
+    static getProviderInstance: (params: {
+        eoaProvider: IProvider;
+        smartAccountInit: ISmartAccount;
+        chainConfig: CustomChainConfig;
+        bundlerConfig: BundlerConfig;
+        paymasterConfig?: PaymasterConfig;
+    }) => Promise<AccountAbstractionProvider>;
+    enable(): Promise<string[]>;
+    setupProvider(eoaProvider: IProvider): Promise<void>;
+    updateAccount(_params: {
+        privateKey: string;
+    }): Promise<void>;
+    switchChain(_params: {
+        chainId: string;
+    }): Promise<void>;
+    protected lookupNetwork(): Promise<string>;
+    private setupChainSwitchMiddleware;
+}

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

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

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

@@ -0,0 +1,14 @@
+import { ToBiconomySmartAccountParameters } from "permissionless/accounts";
+import { Client } from "viem";
+import { SmartAccount } from "viem/account-abstraction";
+import { IProvider } from "../../../../base";
+import { BiconomySmartAccountConfig, ISmartAccount } from "./types";
+export declare class BiconomySmartAccount implements ISmartAccount {
+    readonly name: string;
+    options: BiconomySmartAccountConfig;
+    constructor(options?: BiconomySmartAccountConfig);
+    getSmartAccount(params: {
+        owner: IProvider;
+        client: Client;
+    } & Pick<ToBiconomySmartAccountParameters, "index" | "nonceKey" | "address">): Promise<SmartAccount>;
+}

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

@@ -0,0 +1,13 @@
+import { Client } from "viem";
+import { SmartAccount } from "viem/account-abstraction";
+import { IProvider } from "../../../../base";
+import { ISmartAccount, KernelSmartAccountConfig, KernelSmartAccountParameters } from "./types";
+export declare class KernelSmartAccount implements ISmartAccount {
+    readonly name: string;
+    options: KernelSmartAccountConfig;
+    constructor(options?: KernelSmartAccountConfig);
+    getSmartAccount(params: {
+        owner: IProvider;
+        client: Client;
+    } & Pick<KernelSmartAccountParameters, "address" | "nonceKey" | "index">): Promise<SmartAccount>;
+}

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

@@ -0,0 +1,14 @@
+import { ToLightSmartAccountParameters } from "permissionless/accounts";
+import { Client } from "viem";
+import { SmartAccount } from "viem/account-abstraction";
+import { IProvider } from "../../../../base";
+import { ISmartAccount, LightSmartAccountConfig } from "./types";
+export declare class LightSmartAccount implements ISmartAccount {
+    readonly name: string;
+    options: LightSmartAccountConfig;
+    constructor(options?: LightSmartAccountConfig);
+    getSmartAccount(params: {
+        owner: IProvider;
+        client: Client;
+    } & Pick<ToLightSmartAccountParameters, "address" | "index" | "nonceKey">): Promise<SmartAccount>;
+}

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

@@ -0,0 +1,14 @@
+import { ToNexusSmartAccountParameters } from "permissionless/accounts";
+import { Client } from "viem";
+import { SmartAccount } from "viem/account-abstraction";
+import { IProvider } from "../../../../base";
+import { ISmartAccount, NexusSmartAccountConfig } from "./types";
+export declare class NexusSmartAccount implements ISmartAccount {
+    readonly name: string;
+    options: NexusSmartAccountConfig;
+    constructor(options?: NexusSmartAccountConfig);
+    getSmartAccount(params: {
+        owner: IProvider;
+        client: Client;
+    } & Pick<ToNexusSmartAccountParameters, "index" | "address">): Promise<SmartAccount>;
+}

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

@@ -0,0 +1,13 @@
+import { Client } from "viem";
+import { SmartAccount } from "viem/account-abstraction";
+import { IProvider } from "../../../../base";
+import { ISmartAccount, SafeSmartAccountConfig, SafeSmartAccountParameters } from "./types";
+export declare class SafeSmartAccount implements ISmartAccount {
+    readonly name: string;
+    options: SafeSmartAccountConfig;
+    constructor(options?: SafeSmartAccountConfig);
+    getSmartAccount(params: {
+        owner: IProvider;
+        client: Client;
+    } & Pick<SafeSmartAccountParameters, "address" | "nonceKey" | "saltNonce" | "validUntil" | "validAfter">): Promise<SmartAccount>;
+}

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

@@ -0,0 +1,13 @@
+import { Client } from "viem";
+import { SmartAccount } from "viem/account-abstraction";
+import { IProvider } from "../../../../base";
+import { ISmartAccount, SimpleSmartAccountConfig } from "./types";
+export declare class SimpleSmartAccount implements ISmartAccount {
+    readonly name: string;
+    options: SimpleSmartAccountConfig;
+    constructor(options?: SimpleSmartAccountConfig);
+    getSmartAccount(params: {
+        owner: IProvider;
+        client: Client;
+    }): Promise<SmartAccount>;
+}

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

@@ -0,0 +1,13 @@
+import { Client } from "viem";
+import { SmartAccount } from "viem/account-abstraction";
+import { IProvider } from "../../../../base";
+import { ISmartAccount, TrustSmartAccountConfig, TrustSmartAccountParameters } from "./types";
+export declare class TrustSmartAccount implements ISmartAccount {
+    readonly name: string;
+    options: TrustSmartAccountConfig;
+    constructor(options?: TrustSmartAccountConfig);
+    getSmartAccount(params: {
+        owner: IProvider;
+        client: Client;
+    } & Pick<TrustSmartAccountParameters, "address" | "nonceKey" | "index">): Promise<SmartAccount>;
+}

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

@@ -0,0 +1,9 @@
+export declare const SMART_ACCOUNT: {
+    BICONOMY: string;
+    NEXUS: string;
+    KERNEL: string;
+    LIGHT: string;
+    SAFE: string;
+    SIMPLE: string;
+    TRUST: string;
+};

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

@@ -0,0 +1,6 @@
+export * from "./BiconomySmartAccount";
+export * from "./KernelSmartAccount";
+export * from "./NexusSmartAccount";
+export * from "./SafeSmartAccount";
+export * from "./TrustSmartAccount";
+export * from "./types";

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

@@ -0,0 +1,22 @@
+import { ToBiconomySmartAccountParameters, toEcdsaKernelSmartAccount, ToLightSmartAccountParameters, ToNexusSmartAccountParameters, toSafeSmartAccount, toSimpleSmartAccount, toTrustSmartAccount } from "permissionless/accounts";
+import { Client } from "viem";
+import { SmartAccount } from "viem/account-abstraction";
+import { IBaseSmartAccount, IProvider } from "../../../../base";
+export type BiconomySmartAccountConfig = Pick<ToBiconomySmartAccountParameters, "entryPoint" | "ecdsaModuleAddress" | "factoryAddress">;
+export type KernelSmartAccountParameters = Parameters<typeof toEcdsaKernelSmartAccount>[0];
+export type KernelSmartAccountConfig = Omit<KernelSmartAccountParameters, "owners" | "client" | "address" | "nonceKey" | "index">;
+export type LightSmartAccountConfig = Omit<ToLightSmartAccountParameters, "owner" | "client" | "index" | "address" | "nonceKey">;
+export type NexusSmartAccountConfig = Omit<ToNexusSmartAccountParameters, "owners" | "client" | "index" | "address">;
+export type SafeSmartAccountParameters = Parameters<typeof toSafeSmartAccount>[0];
+export type SafeSmartAccountConfig = Omit<SafeSmartAccountParameters, "owners" | "client" | "address" | "nonceKey" | "saltNonce" | "validUntil" | "validAfter">;
+export type SimpleSmartAccountParameters = Parameters<typeof toSimpleSmartAccount>[0];
+export type SimpleSmartAccountConfig = Omit<SimpleSmartAccountParameters, "owner" | "client">;
+export type TrustSmartAccountParameters = Parameters<typeof toTrustSmartAccount>[0];
+export type TrustSmartAccountConfig = Omit<TrustSmartAccountParameters, "owner" | "client" | "address" | "nonceKey" | "index">;
+export interface ISmartAccount extends IBaseSmartAccount {
+    options: BiconomySmartAccountConfig | KernelSmartAccountConfig | NexusSmartAccountConfig | SafeSmartAccountConfig | TrustSmartAccountConfig | LightSmartAccountConfig | SimpleSmartAccountConfig;
+    getSmartAccount(params: {
+        owner: IProvider;
+        client: Client;
+    }): Promise<SmartAccount>;
+}

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

@@ -0,0 +1,17 @@
+import { createBundlerClient, createPaymasterClient } from "viem/account-abstraction";
+type Transport = Parameters<typeof createBundlerClient>[0]["transport"];
+export type BundlerConfig = Omit<Parameters<typeof createBundlerClient>[0], "account" | "client" | "transport" | "paymaster"> & ({
+    url: string;
+    transport?: Transport;
+} | {
+    url?: string;
+    transport: Transport;
+});
+export type PaymasterConfig = Omit<Parameters<typeof createPaymasterClient>[0], "transport"> & ({
+    url: string;
+    transport?: Transport;
+} | {
+    url?: string;
+    transport: Transport;
+});
+export {};

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

@@ -0,0 +1,10 @@
+import { Chain } from "viem";
+import { BundlerClient, SmartAccount } from "viem/account-abstraction";
+import { IProvider } from "../../../base";
+import { IEthProviderHandlers } from "../../ethereum-provider";
+export declare function getProviderHandlers({ bundlerClient, smartAccount, chain, eoaProvider, }: {
+    smartAccount: SmartAccount;
+    bundlerClient: BundlerClient;
+    chain: Chain;
+    eoaProvider: IProvider;
+}): IEthProviderHandlers;

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

@@ -0,0 +1,8 @@
+import { JRPCMiddleware } 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>>;
+export declare function eoaProviderAsMiddleware(provider: IProvider): JRPCMiddleware<unknown, unknown>;

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

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

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

@@ -0,0 +1,20 @@
+import { CustomChainConfig, SafeEventEmitterProvider } from "../../base";
+import { BaseProvider, BaseProviderConfig, BaseProviderState } from "./baseProvider";
+export type CommonJRPCProviderConfig = BaseProviderConfig;
+export type CommonJRPCProviderState = BaseProviderState;
+export declare class CommonJRPCProvider extends BaseProvider<CommonJRPCProviderConfig, CommonJRPCProviderState, never> {
+    constructor({ config, state }: {
+        config: CommonJRPCProviderConfig;
+        state?: CommonJRPCProviderState;
+    });
+    static getProviderInstance: (params: {
+        chainConfig: CustomChainConfig;
+    }) => Promise<CommonJRPCProvider>;
+    setupProvider(): 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

@@ -0,0 +1,39 @@
+import { BaseConfig, BaseController, BaseState } from "@toruslabs/base-controllers";
+import { JRPCRequest, JRPCResponse, 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>;
+    skipLookupNetwork?: boolean;
+    keyExportEnabled?: boolean;
+}
+export declare abstract class BaseProvider<C extends BaseProviderConfig, S extends BaseProviderState, P> extends BaseController<C, S, BaseProviderEvents<S>> implements IBaseProvider<P> {
+    _providerEngineProxy: SafeEventEmitterProvider | null;
+    private keyExportFlagSetByCode;
+    constructor({ config, state }: {
+        config: C;
+        state?: S;
+    });
+    get currentChainConfig(): CustomChainConfig;
+    get provider(): SafeEventEmitterProvider | null;
+    get chainId(): string;
+    set provider(_: SafeEventEmitterProvider | 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>;
+    abstract switchChain(params: {
+        chainId: string;
+    }): Promise<void>;
+    protected abstract lookupNetwork(provider?: P): Promise<string | void>;
+}

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

@@ -0,0 +1,31 @@
+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;
+}
+export declare class CommonPrivateKeyProvider extends BaseProvider<BaseProviderConfig, CommonPrivKeyProviderState, string> implements IBaseProvider<string> {
+    _providerEngineProxy: SafeEventEmitterProvider | null;
+    constructor({ config, state }: {
+        config: CommonPrivKeyProviderConfig;
+        state?: CommonPrivKeyProviderState;
+    });
+    get provider(): SafeEventEmitterProvider | null;
+    set provider(_: SafeEventEmitterProvider | null);
+    static getProviderInstance: (params: {
+        privKey: string;
+        chainConfig: CustomChainConfig;
+    }) => Promise<CommonPrivateKeyProvider>;
+    addChain(_: CustomChainConfig): void;
+    setupProvider(privKey: string): Promise<void>;
+    updateProviderEngineProxy(provider: SafeEventEmitterProvider): void;
+    switchChain(_: {
+        chainId: string;
+    }): Promise<void>;
+    protected getProviderEngineProxy(): SafeEventEmitterProvider | null;
+    protected lookupNetwork(): Promise<string>;
+    private getPrivKeyMiddleware;
+    private createPrivKeyMiddleware;
+}

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

@@ -0,0 +1,5 @@
+export * from "./baseProvider";
+export * from "./CommonJRPCProvider";
+export * from "./commonPrivateKeyProvider";
+export * from "./interfaces";
+export * from "./utils";

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

@@ -0,0 +1,3 @@
+import { BaseControllerEvents } from "@toruslabs/base-controllers";
+import { ProviderEvents } from "../../base";
+export type BaseProviderEvents<S> = ProviderEvents & BaseControllerEvents<S>;

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

@@ -0,0 +1,8 @@
+import { Block, JRPCMiddleware } 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>;
+};

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

@@ -0,0 +1,2 @@
+export declare const createRandomId: () => number;
+export { getED25519Key } from "@web3auth/auth";

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

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

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

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

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

@@ -0,0 +1,65 @@
+import { CustomChainConfig } from "../../../../base";
+import { BaseProvider, BaseProviderConfig, BaseProviderState } from "../../../base-provider";
+export interface EthereumSigningProviderConfig extends BaseProviderConfig {
+    chainConfig: CustomChainConfig;
+}
+export interface EthereumSigningProviderState extends BaseProviderState {
+    signMethods?: {
+        sign: (msgHash: Buffer, rawMsg?: Buffer) => Promise<{
+            v: number;
+            r: Buffer;
+            s: Buffer;
+        }>;
+        getPublic: () => Promise<Buffer>;
+    };
+}
+export declare class EthereumSigningProvider extends BaseProvider<BaseProviderConfig, EthereumSigningProviderState, {
+    sign: (msgHash: Buffer, rawMsg?: Buffer) => Promise<{
+        v: number;
+        r: Buffer;
+        s: Buffer;
+    }>;
+    getPublic: () => Promise<Buffer>;
+}> {
+    readonly PROVIDER_CHAIN_NAMESPACE: "eip155";
+    constructor({ config, state }: {
+        config: EthereumSigningProviderConfig;
+        state?: EthereumSigningProviderState;
+    });
+    static getProviderInstance: (params: {
+        signMethods: {
+            sign: (msgHash: Buffer, rawMsg?: Buffer) => Promise<{
+                v: number;
+                r: Buffer;
+                s: Buffer;
+            }>;
+            getPublic: () => Promise<Buffer>;
+        };
+        chainConfig: CustomChainConfig;
+    }) => Promise<EthereumSigningProvider>;
+    enable(): Promise<string[]>;
+    setupProvider({ sign, getPublic, }: {
+        sign: (msgHash: Buffer, rawMsg?: Buffer) => Promise<{
+            v: number;
+            r: Buffer;
+            s: Buffer;
+        }>;
+        getPublic: () => Promise<Buffer>;
+    }): Promise<void>;
+    updateAccount(params: {
+        signMethods: {
+            sign: (msgHash: Buffer, rawMsg?: Buffer) => Promise<{
+                v: number;
+                r: Buffer;
+                s: Buffer;
+            }>;
+            getPublic: () => Promise<Buffer>;
+        };
+    }): Promise<void>;
+    switchChain(params: {
+        chainId: string;
+    }): Promise<void>;
+    protected lookupNetwork(): Promise<string>;
+    private getChainSwitchMiddleware;
+    private getAccountMiddleware;
+}

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

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

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

@@ -0,0 +1,12 @@
+import { SafeEventEmitterProvider } from "@web3auth/auth";
+import { IEthProviderHandlers, TransactionFormatter } from "../../../ethereum-provider";
+export declare function getProviderHandlers({ txFormatter, sign, getPublic, getProviderEngineProxy, }: {
+    txFormatter: TransactionFormatter;
+    sign: (msgHash: Buffer, rawMsg?: Buffer) => Promise<{
+        v: number;
+        r: Buffer;
+        s: Buffer;
+    }>;
+    getPublic: () => Promise<Buffer>;
+    getProviderEngineProxy: () => SafeEventEmitterProvider | null;
+}): IEthProviderHandlers;

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

@@ -0,0 +1,3 @@
+import { JRPCMiddleware } from "@web3auth/auth";
+import { IAccountHandlers } from "./interfaces";
+export declare function createEthAccountMiddleware({ updatePrivatekey }: IAccountHandlers): JRPCMiddleware<unknown, unknown>;

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

@@ -0,0 +1,15 @@
+export interface IAccountHandlers {
+    updatePrivatekey?: (params: {
+        privateKey: string;
+    }) => Promise<void>;
+    updateSignMethods?: (params: {
+        signMethods: {
+            sign: (msgHash: Buffer, rawMsg?: Buffer) => Promise<{
+                v: number;
+                r: Buffer;
+                s: Buffer;
+            }>;
+            getPublic: () => Promise<Buffer>;
+        };
+    }) => Promise<void>;
+}

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

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

package/dist/types/providers/ethereum-provider/providers/converter.d.ts

@@ -0,0 +1,15 @@
+import { BigNumber } from "bignumber.js";
+type DenominationType = "WEI" | "GWEI" | "ETH";
+type NumericBaseType = "hex" | "dec";
+type ConverterInput = {
+    value: string | BigNumber;
+    fromNumericBase: NumericBaseType;
+    fromDenomination?: DenominationType;
+    toNumericBase?: NumericBaseType;
+    toDenomination?: DenominationType;
+    numberOfDecimals?: number;
+};
+declare const conversionUtil: (value: string | BigNumber, { fromNumericBase, toNumericBase, fromDenomination, toDenomination, numberOfDecimals }: Partial<ConverterInput>) => BigNumber | string;
+declare function decGWEIToHexWEI(decGWEI: string | BigNumber): string;
+declare function hexWEIToDecGWEI(decGWEI: string | BigNumber): string | BigNumber;
+export { conversionUtil, decGWEIToHexWEI, hexWEIToDecGWEI };

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

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