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

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

@@ -0,0 +1,30 @@
+import { CustomChainConfig } from "../../../../base";
+import { BaseProvider, BaseProviderConfig, BaseProviderState } from "../../../base-provider";
+export interface EthereumPrivKeyProviderConfig extends BaseProviderConfig {
+    chainConfig: CustomChainConfig;
+}
+export interface EthereumPrivKeyProviderState extends BaseProviderState {
+    privateKey?: string;
+}
+export declare class EthereumPrivateKeyProvider extends BaseProvider<BaseProviderConfig, EthereumPrivKeyProviderState, string> {
+    readonly PROVIDER_CHAIN_NAMESPACE: "eip155";
+    constructor({ config, state }: {
+        config: EthereumPrivKeyProviderConfig;
+        state?: EthereumPrivKeyProviderState;
+    });
+    static getProviderInstance: (params: {
+        privKey: string;
+        chainConfig: CustomChainConfig;
+    }) => Promise<EthereumPrivateKeyProvider>;
+    enable(): Promise<string[]>;
+    setupProvider(privKey: string): Promise<void>;
+    updateAccount(params: {
+        privateKey: string;
+    }): Promise<void>;
+    switchChain(params: {
+        chainId: string;
+    }): Promise<void>;
+    protected lookupNetwork(): Promise<string>;
+    private getChainSwitchMiddleware;
+    private getAccountMiddleware;
+}

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

@@ -0,0 +1,16 @@
+import { PrefixedHexString } from "@ethereumjs/util";
+export declare const LegacyGasAPIEndpoint = "https://gas-api.metaswap.codefi.network/networks/<chain_id>/gasPrices";
+export declare const EIP1559APIEndpoint = "https://gas-api.metaswap.codefi.network/networks/<chain_id>/suggestedGasFees";
+export declare const TRANSACTION_ENVELOPE_TYPES: Record<string, PrefixedHexString>;
+export declare const TRANSACTION_TYPES: {
+    SENT_ETHER: string;
+    CONTRACT_INTERACTION: string;
+    DEPLOY_CONTRACT: string;
+    STANDARD_TRANSACTION: string;
+};
+export declare const GAS_ESTIMATE_TYPES: {
+    FEE_MARKET: string;
+    LEGACY: string;
+    ETH_GASPRICE: string;
+    NONE: string;
+};

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

@@ -0,0 +1,28 @@
+import { SafeEventEmitterProvider } from "../../../../../base";
+import { TransactionParams } from "../../../rpc/interfaces";
+export declare class TransactionFormatter {
+    readonly API_SUPPORTED_CHAINIDS: Set<string>;
+    private chainConfig;
+    private getProviderEngineProxy;
+    private isEIP1559Compatible;
+    constructor({ getProviderEngineProxy }: {
+        getProviderEngineProxy: () => SafeEventEmitterProvider;
+    });
+    get providerProxy(): SafeEventEmitterProvider<import("@web3auth/auth").ProviderEvents>;
+    init(): Promise<void>;
+    formatTransaction(txParams: TransactionParams & {
+        gas?: string;
+    }): Promise<TransactionParams & {
+        gas?: string;
+    }>;
+    private fetchEthGasPriceEstimate;
+    private fetchGasEstimatesViaEthFeeHistory;
+    private getEIP1559Compatibility;
+    private fetchGasFeeEstimateData;
+    private getDefaultGasFees;
+    private estimateTxGas;
+    private analyzeGasUsage;
+    private addGasBuffer;
+    private determineTransactionCategory;
+    private getDefaultGasLimit;
+}

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

@@ -0,0 +1,4 @@
+export * from "./constants";
+export * from "./formatter";
+export * from "./interfaces";
+export * from "./utils";

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

@@ -0,0 +1,46 @@
+import { GAS_ESTIMATE_TYPES, TRANSACTION_TYPES } from "./constants";
+export type LegacyGasData = {
+    low: string;
+    medium: string;
+    high: string;
+};
+export type EIP1559GasDataItem = {
+    suggestedMaxPriorityFeePerGas: string;
+    suggestedMaxFeePerGas: string;
+    minWaitTimeEstimate: number;
+    maxWaitTimeEstimate: number;
+};
+export type EthereumGasFeeEstimates = {
+    estimatedBaseFee: string;
+    low: EIP1559GasDataItem;
+    medium: EIP1559GasDataItem;
+    high: EIP1559GasDataItem;
+};
+export type EIP1159GasData = EthereumGasFeeEstimates & {
+    networkCongestion: number;
+    latestPriorityFeeRange: string[];
+    historicalPriorityFeeRange: string[];
+    historicalBaseFeeRange: string[];
+    priorityFeeTrend: string;
+    baseFeeTrend: string;
+};
+export type FallbackGasData = {
+    gasPrice: string;
+};
+export type TxType = (typeof TRANSACTION_TYPES)[keyof typeof TRANSACTION_TYPES];
+export type GasType = (typeof GAS_ESTIMATE_TYPES)[keyof typeof GAS_ESTIMATE_TYPES];
+export type GasData = {
+    gasEstimateType: string;
+    gasFeeEstimates: LegacyGasData | EthereumGasFeeEstimates | FallbackGasData;
+};
+export interface FeeHistoryResponse {
+    baseFeePerGas: string[];
+    gasUsedRatio: string[];
+    oldestBlock: string;
+    reward: string[][];
+}
+export declare enum SignTypedDataVersion {
+    V1 = "V1",
+    V3 = "V3",
+    V4 = "V4"
+}

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

@@ -0,0 +1,12 @@
+import { BigNumber } from "bignumber.js";
+import { TypedMessageParams } from "../../../rpc/interfaces";
+import { EthereumGasFeeEstimates, LegacyGasData } from "./interfaces";
+export declare function normalizeGWEIDecimalNumbers(n: string | BigNumber): string;
+export declare function fetchEip1159GasEstimates(url: string): Promise<EthereumGasFeeEstimates>;
+/**
+ * Hit the legacy MetaSwaps gasPrices estimate api and return the low, medium
+ * high values from that API.
+ */
+export declare function fetchLegacyGasPriceEstimates(url: string): Promise<LegacyGasData>;
+export declare function validateAddress(address: string, propertyName: string): void;
+export declare function validateTypedSignMessageDataV4(messageData: TypedMessageParams, currentChainId: string): Promise<void>;

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

@@ -0,0 +1,9 @@
+import { SafeEventEmitterProvider } from "../../../../base";
+import { IEthProviderHandlers } from "../../rpc/interfaces";
+import { TransactionFormatter } from "./TransactionFormatter/formatter";
+export declare function getProviderHandlers({ txFormatter, privKey, keyExportEnabled, getProviderEngineProxy, }: {
+    txFormatter: TransactionFormatter;
+    privKey: string;
+    getProviderEngineProxy: () => SafeEventEmitterProvider | null;
+    keyExportEnabled: boolean;
+}): IEthProviderHandlers;

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

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

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

@@ -0,0 +1,5 @@
+import BN from "bn.js";
+export declare function bnLessThan(a: string | number, b: string | number): boolean;
+export declare function bnToHex(inputBn: BN): `0x${string}`;
+export declare function hexToBn(inputHex: string): BN;
+export declare function BnMultiplyByFraction(targetBN: BN, numerator: number | string, denominator: number | string): BN;

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

@@ -0,0 +1,5 @@
+import { JRPCMiddleware } from "@web3auth/auth";
+import { IEthAccountHandlers, 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>;

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

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

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

@@ -0,0 +1,65 @@
+import type { JRPCRequest } from "@web3auth/auth";
+import type { TransactionLike, TypedDataDomain, TypedDataField } from "ethers";
+export interface IEthAccountHandlers {
+    updatePrivatekey: (params: {
+        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>;
+}
+export type TransactionParams<A = string> = TransactionLike<A> & {
+    input?: string;
+};
+export interface MessageParams<T> {
+    from: string;
+    data: T;
+}
+export interface BaseRequestParams {
+    /**
+     * Unique id for each request
+     */
+    id?: string;
+    /**
+     * Address to send this transaction from.
+     */
+    from: string;
+    /**
+     * Domain requested from
+     */
+    origin?: string;
+}
+export type SignTypedDataMessageV4 = {
+    types: Record<string, TypedDataField[]>;
+    domain: TypedDataDomain;
+    message: Record<string, unknown>;
+};
+export interface TypedMessageParams extends BaseRequestParams {
+    data: string | SignTypedDataMessageV4;
+}
+export interface WalletMiddlewareOptions {
+    getAccounts: (req: JRPCRequest<unknown>) => Promise<string[]>;
+    getPublicKey: (req: JRPCRequest<unknown>) => Promise<string>;
+    getPrivateKey: (req: JRPCRequest<unknown>) => Promise<string>;
+    processEthSignMessage?: (msgParams: MessageParams<string>, req: JRPCRequest<unknown>) => Promise<string>;
+    processPersonalMessage?: (msgParams: MessageParams<string>, req: JRPCRequest<unknown>) => Promise<string>;
+    processTransaction?: (txParams: TransactionParams, req: JRPCRequest<unknown>) => Promise<string>;
+    processSignTransaction?: (txParams: TransactionParams, req: JRPCRequest<unknown>) => Promise<string>;
+    processTypedMessageV4?: (msgParams: TypedMessageParams, req: JRPCRequest<unknown>) => Promise<string>;
+}
+export type IEthProviderHandlers = WalletMiddlewareOptions;

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

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

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

@@ -0,0 +1,3 @@
+import { JRPCMiddleware } from "@web3auth/auth";
+import type { WalletMiddlewareOptions } from "./interfaces";
+export declare function createWalletMiddleware({ getAccounts, getPrivateKey, getPublicKey, processEthSignMessage, processPersonalMessage, processTransaction, processSignTransaction, processTypedMessageV4, }: WalletMiddlewareOptions): JRPCMiddleware<string, unknown>;

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

@@ -0,0 +1,6 @@
+export * from "./account-abstraction-provider";
+export * from "./base-provider";
+export * from "./ethereum-mpc-provider";
+export * from "./ethereum-provider";
+export * from "./solana-provider";
+export * from "./xrpl-provider";

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

@@ -0,0 +1,4 @@
+export * from "./interface";
+export * from "./providers";
+export * from "./rpc";
+export * from "./solanaWallet";

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

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

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

@@ -0,0 +1,2 @@
+export * from "./injectedProviders";
+export * from "./privateKeyProvider";

package/dist/types/providers/solana-provider/providers/injectedProviders/base/baseInjectedProvider.d.ts

@@ -0,0 +1,16 @@
+import { JRPCMiddleware } from "@web3auth/auth";
+import { BaseProvider, BaseProviderConfig, BaseProviderState } from "../../../../base-provider";
+import { ISolanaProviderHandlers } from "../../../rpc";
+export declare abstract class BaseInjectedProvider<P> extends BaseProvider<BaseProviderConfig, BaseProviderState, P> {
+    constructor({ config, state }: {
+        config: BaseProviderConfig;
+        state?: BaseProviderState;
+    });
+    switchChain(_: {
+        chainId: string;
+    }): Promise<void>;
+    setupProvider(injectedProvider: P): Promise<void>;
+    protected lookupNetwork(): Promise<string>;
+    protected getInjectedProviderProxy(_: P): JRPCMiddleware<unknown, unknown>;
+    protected abstract getProviderHandlers(injectedProvider: P): ISolanaProviderHandlers;
+}

package/dist/types/providers/solana-provider/providers/injectedProviders/base/providerHandlers.d.ts

@@ -0,0 +1,3 @@
+import { IBaseWalletProvider } from "../../../interface";
+import { ISolanaProviderHandlers } from "../../../rpc";
+export declare const getBaseProviderHandlers: (injectedProvider: IBaseWalletProvider) => ISolanaProviderHandlers;

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

@@ -0,0 +1,3 @@
+export * from "./interface";
+export * from "./torus/torusInjectedProvider";
+export * from "./walletStandardProvider";

package/dist/types/providers/solana-provider/providers/injectedProviders/injectedProviderProxy.d.ts

@@ -0,0 +1,3 @@
+import { JRPCMiddleware } from "@web3auth/auth";
+import { InjectedProvider } from "./interface";
+export declare function createInjectedProviderProxyMiddleware(provider: InjectedProvider): JRPCMiddleware<unknown, unknown>;

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

@@ -0,0 +1,5 @@
+import type { SafeEventEmitter } from "@web3auth/auth";
+import { RequestArguments } from "../../../../base";
+export interface InjectedProvider extends SafeEventEmitter {
+    request<T, U>(args: RequestArguments<T>): Promise<U>;
+}

package/dist/types/providers/solana-provider/providers/injectedProviders/torus/providerHandlers.d.ts

@@ -0,0 +1,3 @@
+import { ITorusWalletProvider } from "../../../interface";
+import { ISolanaProviderHandlers } from "../../../rpc";
+export declare const getTorusHandlers: (injectedProvider: ITorusWalletProvider) => ISolanaProviderHandlers;

package/dist/types/providers/solana-provider/providers/injectedProviders/torus/torusInjectedProvider.d.ts

@@ -0,0 +1,18 @@
+import { CustomChainConfig } from "../../../../../base";
+import { BaseProvider, BaseProviderConfig, BaseProviderState } from "../../../../base-provider";
+import { ITorusWalletProvider } from "../../../interface";
+export declare class TorusInjectedProvider extends BaseProvider<BaseProviderConfig, BaseProviderState, ITorusWalletProvider> {
+    readonly PROVIDER_CHAIN_NAMESPACE = "solana";
+    constructor({ config, state }: {
+        config: BaseProviderConfig;
+        state?: BaseProviderState;
+    });
+    switchChain(params: {
+        chainId: string;
+    }): Promise<void>;
+    addChain(chainConfig: CustomChainConfig): Promise<void>;
+    setupProvider(injectedProvider: ITorusWalletProvider): Promise<void>;
+    protected lookupNetwork(): Promise<string>;
+    private setupEngine;
+    private handleInjectedProviderUpdate;
+}

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

@@ -0,0 +1,6 @@
+import { IWalletStandardProviderHandler } from "../../interface";
+import { ISolanaProviderHandlers } from "../../rpc";
+import { BaseInjectedProvider } from "./base/baseInjectedProvider";
+export declare class WalletStandardProvider extends BaseInjectedProvider<IWalletStandardProviderHandler> {
+    protected getProviderHandlers(injectedProvider: IWalletStandardProviderHandler): ISolanaProviderHandlers;
+}

package/dist/types/providers/solana-provider/providers/privateKeyProvider/index.d.ts

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

package/dist/types/providers/solana-provider/providers/privateKeyProvider/solanaPrivateKeyProvider.d.ts

@@ -0,0 +1,31 @@
+import { CustomChainConfig } from "../../../../base";
+import { BaseProvider, BaseProviderConfig, BaseProviderState } from "../../../base-provider";
+export interface SolanaPrivKeyProviderConfig extends BaseProviderConfig {
+    chainConfig: CustomChainConfig;
+}
+export interface SolanaPrivKeyProviderState extends BaseProviderState {
+    privateKey?: string;
+}
+export declare class SolanaPrivateKeyProvider extends BaseProvider<BaseProviderConfig, SolanaPrivKeyProviderState, string> {
+    readonly PROVIDER_CHAIN_NAMESPACE: "solana";
+    constructor({ config, state }: {
+        config: SolanaPrivKeyProviderConfig;
+        state?: BaseProviderState;
+    });
+    static getProviderInstance: (params: {
+        privKey: string;
+        chainConfig: CustomChainConfig;
+    }) => Promise<SolanaPrivateKeyProvider>;
+    enable(): Promise<string[]>;
+    getEd25519Key(privateKey: string): string;
+    setupProvider(privKey: string): Promise<void>;
+    updateAccount(params: {
+        privateKey: string;
+    }): Promise<void>;
+    switchChain(params: {
+        chainId: string;
+    }): Promise<void>;
+    protected lookupNetwork(): Promise<string>;
+    private getChainSwitchMiddleware;
+    private getAccountMiddleware;
+}

package/dist/types/providers/solana-provider/providers/privateKeyProvider/solanaPrivateKeyUtils.d.ts

@@ -0,0 +1,7 @@
+import { SafeEventEmitterProvider } from "../../../../base";
+import { ISolanaProviderHandlers } from "../../rpc";
+export declare function getProviderHandlers({ privKey, keyExportEnabled, getProviderEngineProxy, }: {
+    privKey: string;
+    keyExportEnabled: boolean;
+    getProviderEngineProxy: () => SafeEventEmitterProvider | null;
+}): Promise<ISolanaProviderHandlers>;

package/dist/types/providers/solana-provider/rpc/JrpcClient.d.ts

@@ -0,0 +1,9 @@
+import { Block, JRPCMiddleware } from "@web3auth/auth";
+import { CustomChainConfig } from "../../../base";
+export declare function createSolanaChainIdMiddleware(chainId: string): JRPCMiddleware<unknown, string>;
+export declare function createSolanaProviderConfigMiddleware(providerConfig: CustomChainConfig): JRPCMiddleware<unknown, CustomChainConfig>;
+export declare function createConfigMiddleware(providerConfig: CustomChainConfig): JRPCMiddleware<unknown, unknown>;
+export declare function createSolanaJsonRpcClient(providerConfig: CustomChainConfig): {
+    networkMiddleware: JRPCMiddleware<unknown, unknown>;
+    fetchMiddleware: JRPCMiddleware<string[], Block>;
+};

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

@@ -0,0 +1,3 @@
+export * from "./interfaces";
+export * from "./JrpcClient";
+export * from "./solanaRpcMiddlewares";

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

@@ -0,0 +1,42 @@
+import { JRPCRequest } from "@web3auth/auth";
+import { TransactionOrVersionedTransaction } from "../interface";
+export interface AddSolanaChainParameter {
+    chainId: string;
+    chainName: string;
+    nativeCurrency: {
+        name: string;
+        symbol: string;
+        decimals: 18;
+    };
+    rpcUrls: string[];
+    blockExplorerUrls?: string[];
+    iconUrls?: string[];
+}
+export interface ISolanaChainSwitchHandlers {
+    addNewChainConfig: (req: JRPCRequest<AddSolanaChainParameter>) => Promise<void>;
+    switchSolanaChain: (req: JRPCRequest<{
+        chainId: string;
+    }>) => Promise<void>;
+}
+export interface ISolanaProviderHandlers {
+    requestAccounts: (req: JRPCRequest<unknown>) => Promise<string[]>;
+    getAccounts: (req: JRPCRequest<unknown>) => Promise<string[]>;
+    getPublicKey: (req: JRPCRequest<unknown>) => Promise<string>;
+    getPrivateKey: (req: JRPCRequest<unknown>) => Promise<string>;
+    signTransaction: (req: JRPCRequest<{
+        message: TransactionOrVersionedTransaction;
+    }>) => Promise<TransactionOrVersionedTransaction>;
+    signAllTransactions: (req: JRPCRequest<{
+        message: TransactionOrVersionedTransaction[];
+    }>) => Promise<TransactionOrVersionedTransaction[]>;
+    signAndSendTransaction: (req: JRPCRequest<{
+        message: TransactionOrVersionedTransaction;
+    }>) => Promise<{
+        signature: string;
+    }>;
+    getSecretKey: (req: JRPCRequest<unknown>) => Promise<string>;
+    signMessage: (req: JRPCRequest<{
+        message: Uint8Array;
+        display?: string;
+    }>) => Promise<Uint8Array>;
+}

package/dist/types/providers/solana-provider/rpc/solanaRpcMiddlewares.d.ts

@@ -0,0 +1,20 @@
+import { JRPCMiddleware, JRPCRequest } from "@web3auth/auth";
+import { ISolanaChainSwitchHandlers, ISolanaProviderHandlers } from "./interfaces";
+export declare function createGetAccountsMiddleware({ getAccounts, }: {
+    getAccounts: ISolanaProviderHandlers["getAccounts"];
+}): JRPCMiddleware<unknown, unknown>;
+export declare function createGetPublicKeyMiddleware({ getPublicKey, }: {
+    getPublicKey: ISolanaProviderHandlers["getPublicKey"];
+}): JRPCMiddleware<unknown, unknown>;
+export declare function createRequestAccountsMiddleware({ requestAccounts, }: {
+    requestAccounts: ISolanaProviderHandlers["requestAccounts"];
+}): JRPCMiddleware<unknown, unknown>;
+export declare function createGenericJRPCMiddleware<T, U>(targetMethod: string, handler: (req: JRPCRequest<T>) => Promise<U>): JRPCMiddleware<T, U>;
+export declare function createSolanaMiddleware(providerHandlers: ISolanaProviderHandlers): JRPCMiddleware<unknown, unknown>;
+export declare function createSolanaChainSwitchMiddleware({ addNewChainConfig, switchSolanaChain, }: ISolanaChainSwitchHandlers): JRPCMiddleware<unknown, unknown>;
+export interface ISolanaAccountHandlers {
+    updatePrivatekey: (req: JRPCRequest<{
+        privateKey: string;
+    }>) => Promise<void>;
+}
+export declare function createSolanaAccountMiddleware({ updatePrivatekey }: ISolanaAccountHandlers): JRPCMiddleware<unknown, unknown>;

package/dist/types/providers/solana-provider/solanaWallet.d.ts

@@ -0,0 +1,14 @@
+import { IProvider, RequestArguments } from "../../base";
+import { ISolanaWallet, TransactionOrVersionedTransaction } from "./interface";
+export declare class SolanaWallet implements ISolanaWallet {
+    provider: IProvider;
+    constructor(provider: IProvider);
+    requestAccounts(): Promise<string[]>;
+    signAndSendTransaction<T extends TransactionOrVersionedTransaction>(transaction: T): Promise<{
+        signature: string;
+    }>;
+    signTransaction<T extends TransactionOrVersionedTransaction>(transaction: T): Promise<T>;
+    signAllTransactions<T extends TransactionOrVersionedTransaction>(transactions: T[]): Promise<T[]>;
+    signMessage(data: Uint8Array): Promise<Uint8Array>;
+    request<T, U>(args: RequestArguments<T>): Promise<U>;
+}

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

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

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

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

package/dist/types/providers/xrpl-provider/providers/privateKeyProviders/constants.d.ts

@@ -0,0 +1,5 @@
+export declare const XRPLNetwork: {
+    Mainnet: string;
+    Testnet: string;
+    Devnet: string;
+};

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

@@ -0,0 +1,3 @@
+export * from "./interface";
+export * from "./xrplPrivateKeyProvider";
+export * from "./xrplWalletUtils";

package/dist/types/providers/xrpl-provider/providers/privateKeyProviders/interface.d.ts

@@ -0,0 +1,2 @@
+import { XRPLNetwork } from "./constants";
+export type XRPLNetworkType = (typeof XRPLNetwork)[keyof typeof XRPLNetwork];

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

@@ -0,0 +1,26 @@
+import { CustomChainConfig } from "../../../../base";
+import { BaseProvider, BaseProviderConfig, BaseProviderState } from "../../../base-provider";
+export interface XrplPrivKeyProviderConfig extends BaseProviderConfig {
+    chainConfig: CustomChainConfig & Pick<CustomChainConfig, "wsTarget">;
+}
+export interface XrplPrivKeyProviderState extends BaseProviderState {
+    privateKey?: string;
+}
+export declare class XrplPrivateKeyProvider extends BaseProvider<BaseProviderConfig, XrplPrivKeyProviderState, string> {
+    readonly PROVIDER_CHAIN_NAMESPACE: "xrpl";
+    constructor({ config, state }: {
+        config: XrplPrivKeyProviderConfig;
+        state?: XrplPrivKeyProviderState;
+    });
+    static getProviderInstance: (params: {
+        privKey: string;
+        chainConfig: CustomChainConfig;
+    }) => Promise<XrplPrivateKeyProvider>;
+    enable(): Promise<string[]>;
+    setupProvider(privKey: string): Promise<void>;
+    switchChain(params: {
+        chainId: string;
+    }): Promise<void>;
+    protected lookupNetwork(): Promise<void>;
+    private getChainSwitchMiddleware;
+}

package/dist/types/providers/xrpl-provider/providers/privateKeyProviders/xrplWalletUtils.d.ts

@@ -0,0 +1,7 @@
+import { CustomChainConfig } from "../../../../base";
+import { IXrplProviderHandlers } from "../../rpc/xrplRpcMiddlewares";
+export declare function getProviderHandlers({ privKey: web3authKey, chainConfig, keyExportEnabled, }: {
+    privKey: string;
+    chainConfig: CustomChainConfig;
+    keyExportEnabled: boolean;
+}): Promise<IXrplProviderHandlers>;

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

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