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

package/dist/lib.cjs/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/lib.cjs/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/lib.cjs/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 → lib.cjs/types/connectors/wallet-connect-v2-connector}/WalletConnectV2Provider.d.ts

@@ -1,9 +1,7 @@
 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 type WalletConnectV2ProviderConfig = BaseProviderConfig;
 export interface WalletConnectV2ProviderState extends BaseProviderState {
     accounts: string[];
 }
@@ -16,16 +14,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 → lib.cjs/types/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 → lib.cjs/types/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 → lib.cjs/types/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/lib.cjs/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 → lib.cjs/types/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 → lib.cjs/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/lib.cjs/types/noModal.d.ts

@@ -0,0 +1,58 @@
+import { SafeEventEmitter } from "@web3auth/auth";
+import { ChainNamespaceType, 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;
+    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>;
+    getConnector(connectorName: WALLET_CONNECTOR_TYPE, chainNamespace?: ChainNamespaceType): IConnector<unknown> | null;
+    clearCache(): void;
+    switchChain(params: {
+        chainId: string;
+    }): Promise<void>;
+    /**
+     * Connect to a specific wallet connector
+     * @param connectorName - Key of the wallet connector to use.
+     */
+    connectTo<T>(connectorName: WALLET_CONNECTOR_TYPE, loginParams?: T): Promise<IProvider | null>;
+    logout(options?: {
+        cleanup: boolean;
+    }): Promise<void>;
+    getUserInfo(): Promise<Partial<UserInfo>>;
+    enableMFA<T>(loginParams?: T): Promise<void>;
+    manageMFA<T>(loginParams?: T): Promise<void>;
+    authenticateUser(): Promise<UserAuthInfo>;
+    getPlugin(name: string): IPlugin | null;
+    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 → lib.cjs/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/lib.cjs/types/plugins/wallet-services-plugin/plugin.d.ts

@@ -0,0 +1,27 @@
+import { type BaseEmbedControllerState } from "@toruslabs/base-controllers";
+import { SafeEventEmitter, type WhiteLabelData } from "@web3auth/auth";
+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";
+declare class WalletServicesPlugin extends SafeEventEmitter implements IPlugin {
+    name: "wallet-services";
+    status: PLUGIN_STATUS_TYPE;
+    readonly SUPPORTED_CONNECTORS: string[];
+    readonly pluginNamespace: "multichain";
+    wsEmbedInstance: WsEmbed;
+    private provider;
+    private web3auth;
+    private isInitialized;
+    get proxyProvider(): SafeEventEmitterProvider | null;
+    initWithWeb3Auth(web3auth: IWeb3AuthCore, _whiteLabel?: WhiteLabelData): Promise<void>;
+    initWithProvider(): 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>;
+}
+export type WalletServicesPluginType = WalletServicesPlugin;
+export declare const walletServicesPlugin: () => PluginFn;

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

@@ -0,0 +1,48 @@
+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;
+}
+interface AccountAbstractionProviderState extends BaseProviderState {
+    eoaProvider?: IProvider;
+}
+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: AccountAbstractionProviderConfig & {
+        eoaProvider: IProvider;
+    }) => 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;
+}
+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 → lib.cjs/types}/providers/account-abstraction-provider/providers/index.d.ts

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

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

@@ -0,0 +1 @@
+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 → lib.cjs/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 → lib.cjs/types}/providers/base-provider/baseProvider.d.ts

@@ -1,39 +1,38 @@
 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 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<ProviderEvents> | null;
     private keyExportFlagSetByCode;
     constructor({ config, state }: {
         config: C;
         state?: S;
     });
-    get currentChainConfig(): CustomChainConfig;
-    get provider(): SafeEventEmitterProvider | null;
+    get currentChain(): CustomChainConfig;
+    get provider(): SafeEventEmitterProvider<ProviderEvents> | null;
     get chainId(): string;
-    set provider(_: SafeEventEmitterProvider | null);
+    set provider(_: SafeEventEmitterProvider<ProviderEvents> | 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;
+    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 → lib.cjs/types}/providers/base-provider/commonPrivateKeyProvider.d.ts

@@ -1,8 +1,6 @@
 import { CustomChainConfig, IBaseProvider, SafeEventEmitterProvider } from "../../base";
 import { BaseProvider, BaseProviderConfig, BaseProviderState } from "./baseProvider";
-export interface CommonPrivKeyProviderConfig extends BaseProviderConfig {
-    chainConfig: CustomChainConfig;
-}
+export type CommonPrivKeyProviderConfig = BaseProviderConfig;
 export interface CommonPrivKeyProviderState extends BaseProviderState {
     privateKey?: string;
 }
@@ -16,11 +14,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 → lib.cjs/types}/providers/base-provider/interfaces.d.ts

@@ -1,3 +1,5 @@
 import { BaseControllerEvents } from "@toruslabs/base-controllers";
 import { ProviderEvents } from "../../base";
-export type BaseProviderEvents<S> = ProviderEvents & BaseControllerEvents<S>;
+export type BaseProviderEvents<S> = ProviderEvents & BaseControllerEvents<S> & {
+    newListener: (event: string, listener: (...args: unknown[]) => void) => void;
+};

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

@@ -0,0 +1,9 @@
+export declare const createRandomId: () => number;
+export declare enum EIP1193_EVENTS {
+    ACCOUNTS_CHANGED = "accountsChanged",
+    CHAIN_CHANGED = "chainChanged",
+    CONNECT = "connect",
+    DISCONNECT = "disconnect",
+    MESSAGE = "message"
+}
+export { getED25519Key } from "@web3auth/auth";

package/dist/{types → lib.cjs/types}/providers/ethereum-mpc-provider/providers/signingProviders/EthereumSigningProvider.d.ts

@@ -1,8 +1,14 @@
 import { CustomChainConfig } from "../../../../base";
 import { BaseProvider, BaseProviderConfig, BaseProviderState } from "../../../base-provider";
-export interface EthereumSigningProviderConfig extends BaseProviderConfig {
-    chainConfig: CustomChainConfig;
+interface ProviderParams {
+    sign: (msgHash: Buffer, rawMsg?: Buffer) => Promise<{
+        v: number;
+        r: Buffer;
+        s: Buffer;
+    }>;
+    getPublic: () => Promise<Buffer>;
 }
+export type EthereumSigningProviderConfig = BaseProviderConfig;
 export interface EthereumSigningProviderState extends BaseProviderState {
     signMethods?: {
         sign: (msgHash: Buffer, rawMsg?: Buffer) => Promise<{
@@ -35,17 +41,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 +66,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/lib.cjs/types/providers/ethereum-provider/providers/privateKeyProviders/index.d.ts

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

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

@@ -0,0 +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 }: IEthChainSwitchHandlers): JRPCMiddleware<unknown, unknown>;

package/dist/{types → lib.cjs/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>;

package/dist/lib.cjs/types/providers/solana-provider/interface.d.ts

@@ -0,0 +1,22 @@
+import type { Transaction, VersionedTransaction } from "@solana/web3.js";
+import { RequestArguments } from "../../base";
+export type TransactionOrVersionedTransaction = Transaction | VersionedTransaction;
+export interface ISolanaWallet {
+    publicKey?: {
+        toBytes(): Uint8Array;
+    };
+    signAndSendTransaction<T extends TransactionOrVersionedTransaction>(transaction: T): Promise<string>;
+    signTransaction?<T extends TransactionOrVersionedTransaction>(transaction: T): Promise<string>;
+    signAllTransactions?<T extends TransactionOrVersionedTransaction>(transactions: T[]): Promise<string[]>;
+    signMessage(message: string, pubKey: string): Promise<string>;
+    request<T, U>(args: RequestArguments<T>): Promise<U>;
+}
+export interface IBaseWalletProvider {
+    publicKey?: {
+        toBytes(): Uint8Array;
+    };
+    signMessage?(message: string, pubKey: string, display?: "hex" | "utf8"): Promise<string>;
+    signTransaction?(transaction: string): Promise<string>;
+    signAllTransactions?(transactions: string[]): Promise<string[]>;
+    signAndSendTransaction?(transaction: string): Promise<string>;
+}

package/dist/{types → lib.cjs/types}/providers/solana-provider/providers/injectedProviders/base/baseInjectedProvider.d.ts

@@ -9,8 +9,8 @@ export declare abstract class BaseInjectedProvider<P> extends BaseProvider<BaseP
     switchChain(_: {
         chainId: string;
     }): Promise<void>;
-    setupProvider(injectedProvider: P): Promise<void>;
-    protected lookupNetwork(): Promise<string>;
+    setupProvider(injectedProvider: P, chainId: string): Promise<void>;
+    protected lookupNetwork(_injectedProvider: P, chainId: string): Promise<string>;
     protected getInjectedProviderProxy(_: P): JRPCMiddleware<unknown, unknown>;
     protected abstract getProviderHandlers(injectedProvider: P): ISolanaProviderHandlers;
 }

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

@@ -0,0 +1,2 @@
+export * from "./utils";
+export * from "./walletStandardProvider";

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

@@ -0,0 +1,3 @@
+import { IdentifierString } from "@wallet-standard/base";
+import { CustomChainConfig } from "../../../../base";
+export declare const getSolanaChainByChainConfig: (chainConfig: CustomChainConfig) => IdentifierString;

package/dist/lib.cjs/types/providers/solana-provider/providers/injectedProviders/walletStandardProvider.d.ts

@@ -0,0 +1,9 @@
+import { type SolanaSignAndSendTransactionFeature, type SolanaSignMessageFeature, type SolanaSignTransactionFeature } from "@solana/wallet-standard-features";
+import { type WalletWithFeatures } from "@wallet-standard/base";
+import { type StandardConnectFeature, type StandardDisconnectFeature, type StandardEventsFeature } from "@wallet-standard/features";
+import { type ISolanaProviderHandlers } from "../../rpc";
+import { BaseInjectedProvider } from "./base/baseInjectedProvider";
+export type WalletStandard = WalletWithFeatures<StandardConnectFeature & StandardEventsFeature & StandardDisconnectFeature & SolanaSignAndSendTransactionFeature & SolanaSignMessageFeature & SolanaSignTransactionFeature>;
+export declare class WalletStandardProvider extends BaseInjectedProvider<WalletStandard> {
+    protected getProviderHandlers(wallet: WalletStandard): ISolanaProviderHandlers;
+}