@privy-io/react-auth
Version:
React client for the Privy Auth API
925 lines (920 loc) • 171 kB
text/typescript
import * as react from 'react';
import react__default, { MouseEvent } from 'react';
import { l as WalletClientType, d as UserRecoveryMethod, m as PrivyFarcasterSignerInitResponse, n as MfaSubmitArgs, E as EthereumRpcRequestType, o as SolanaRpcRequestType, p as EthereumRpcResponseType, q as SolanaRpcResponseType, r as PrivyClientConfig, s as EIP1193Provider, u as EntropyIdVerifier$1, v as RequestArguments, w as WalletTimeoutError, x as WalletConnector, B as BaseConnectedEthereumWallet, y as ConnectedWalletMetadata, z as ConnectorType, A as WalletListEntry, D as ExternalWalletsConfig, G as BaseConnectedWallet, k as SolanaWalletConnector, U as User, H as ConnectWalletModalOptions, I as LoginModalOptions, g as CreateWalletOptions, W as Wallet, J as SetWalletRecoveryOptions, i as SignMessageModalUIOptions, K as SignTypedDataParams, M as MfaMethod, N as UnsignedTransactionRequest, h as SendTransactionModalUIOptions, Q as FundWalletConfig, T as ConnectedWallet, O as OAuthTokens, V as CrossAppProviderDetails, X as OAuthProviderType, Y as MoonpaySignRequest, Z as MoonpaySignResponse, _ as SmartWalletConfig, a as LoginMethod, $ as SiweWalletMetadata, a0 as TelegramAuthResult, a1 as TelegramWebAppData, a2 as OAuthUserInfo, a3 as OAuthFlowState, a4 as LoginWithCode, a5 as OtpFlowState, a6 as PasskeyFlowState, a7 as SiweFlowState, a8 as UnsignedTransactionRequestWithChainId, a9 as BaseConnectedWalletType, C as ConnectedSolanaWallet, aa as TelegramAuthFlowState } from './types-B92M8x5e.js';
export { at as Apple, aE as AppleOAuthWithMetadata, aM as ContractUIOptions, aw as CrossAppAccount, aH as CrossAppAccountWithMetadata, aq as Discord, aA as DiscordOAuthWithMetadata, aJ as Email, al as EmailWithMetadata, aQ as Farcaster, aF as FarcasterWithMetadata, ar as Github, aB as GithubOAuthWithMetadata, ao as Google, ay as GoogleOAuthWithMetadata, ax as LinkedAccountType, b as LinkedAccountWithMetadata, as as LinkedIn, aD as LinkedInOAuthWithMetadata, aS as LoginMethodOrderOption, ac as MessageTypes, ae as MoonpayConfig, af as MoonpayCurrencyCode, aO as MoonpayFundingConfig, ag as MoonpayPaymentMethod, aN as NativeFundingConfig, ak as NonEmptyArray, aR as Passkey, aI as PasskeyWithMetadata, aK as Phone, am as PhoneWithMetadata, aP as PriceDisplayOptions, P as PrivyErrorCode, ah as Quantity, ad as SmartWallet, f as SolanaCluster, j as SolanaFundingConfig, S as SolanaTransactionReceipt, e as SupportedSolanaTransaction, av as Telegram, aG as TelegramWithMetadata, au as Tiktok, aC as TiktokOAuthWithMetadata, ai as TransactionLog, aj as TransactionReceipt, aL as TransactionUIOptions, ap as Twitter, az as TwitterOAuthWithMetadata, ab as TypedMessage, an as WalletWithMetadata } from './types-B92M8x5e.js';
import * as react_jsx_runtime from 'react/jsx-runtime';
import { TurnstileProps } from '@marsidev/react-turnstile';
import EventEmitter from 'eventemitter3';
import { Store, EIP6963ProviderDetail } from 'mipd';
import { Chain, RpcConfig } from '@privy-io/js-sdk-core';
export { DEFAULT_SUPPORTED_CHAINS as SUPPORTED_CHAINS, addPrivyRpcToChain, addRpcUrlOverrideToChain } from '@privy-io/js-sdk-core';
import { PasskeyAuthenticateInputType, CustomMetadataType, SmartWalletType, PrivyCoinbaseOnRampInitInput, PrivyCoinbaseOnRampInitResponse, PrivyCoinbaseOnRampStatusResponse, PrivyTransactionScanningInputType, PrivyTransactionScanningResponseType } from '@privy-io/public-api';
import * as viem__types_actions_siwe_verifySiweMessage from 'viem/_types/actions/siwe/verifySiweMessage';
import * as viem from 'viem';
import { Address, HttpTransport } from 'viem';
import * as _simplewebauthn_types from '@simplewebauthn/types';
import { PublicKeyCredentialRequestOptionsJSON } from '@simplewebauthn/types';
import { Cluster } from '@solana/web3.js';
import { FetchOptions } from 'ofetch';
import { P as PrivyEvents } from './useSolanaWallets-BSNPWBSM.js';
export { C as CallbackError, U as UseSolanaWalletsInterface, u as useSolanaWallets } from './useSolanaWallets-BSNPWBSM.js';
import '@solana/wallet-adapter-base';
import '@metamask/eth-sig-util';
type MobileWalletConfig = {
client: WalletClientType;
name: string;
isInstalled: boolean;
installLink: string;
chainTypes: Array<'ethereum' | 'solana'>;
getMobileRedirect: (args: {
useUniversalLink: boolean;
isSolana: boolean;
connectOnly: boolean;
}) => string | undefined;
};
type BaseProxyRequest = {
accessToken: string;
} & Partial<MfaSubmitArgs>;
type EntropyIdVerifier = 'ethereum-address-verifier' | 'solana-address-verifier' | 'p256';
type BaseWalletsRequestData = BaseProxyRequest & {
chainType: 'ethereum' | 'solana' | 'bitcoin-taproot' | 'bitcoin-segwit' | 'p256';
};
type CreateSignerRequestDataType = BaseProxyRequest & {
/** Optional: the user-specified recovery password, replaces recoveryPin */
recoveryPassword?: string;
/** Optional: the recovery method to be used for the created wallet */
recoveryMethod?: UserRecoveryMethod;
/** Optional: in the case of cloud recovery, the access token to be used to communicated with the cloud provider (eg Google) */
recoveryAccessToken?: string;
/** Optional: override the recoverySecret, only for use when we need to store recovery secrets in cloud storage outside of the iframe (eg native) */
recoverySecretOverride?: string;
/** Optional: override the iCloudRecordName, only for use when we need to store recovery secrets in cloud storage outside of the iframe (eg native) */
iCloudRecordNameOverride?: string;
};
type CreateSignerResponseDataType = {
publicKey: string;
};
type WalletsCreateRequestDataType = BaseWalletsRequestData & {
/** Optional: the user-specified recovery password, replaces recoveryPin */
recoveryPassword?: string;
/** Optional: the recovery method to be used for the created wallet */
recoveryMethod?: UserRecoveryMethod;
/** Optional: in the case of cloud recovery, the access token to be used to communicated with the cloud provider (eg Google) */
recoveryAccessToken?: string;
/** Optional: override the recoverySecret, only for use when we need to store recovery secrets in cloud storage outside of the iframe (eg native) */
recoverySecretOverride?: string;
/** Optional: override the iCloudRecordName, only for use when we need to store recovery secrets in cloud storage outside of the iframe (eg native) */
iCloudRecordNameOverride?: string;
};
type WalletsCreateResponseDataType = {
address: string;
};
type WalletsAddRequestDataType = BaseWalletsRequestData & {
/**
* Key with which to look up the existing entropy
*/
entropyId: string;
/**
* Source of the `entropyId` property. This field determines how the entropyId will
* be used. Possible values include:
* - ethereum-address-verifier: the entropyId is the address of the Ethereum wallet derived
* at index 0 for this entropy
* - solana-address-verifier: the entropyId is a the address of the Solana wallet derived
* at index 0 for this entropy
*
* When this field is a wallet address, we can verify reconstitution was successful by
* deriving the specified wallet and comparing the address to the `entropyId`
*/
entropyIdVerifier: EntropyIdVerifier;
/**
* The HD node index at which to create a wallet. Must be >= 1 AND equal to the next
* index in the sequence, since the primary wallet is created at index 0.
*/
hdWalletIndex: number;
};
type WalletsAddResponseDataType = {
address: string;
};
type WalletsSetRecoveryBaseRequestDataType = BaseWalletsRequestData & {
/**
* Key with which to look up the existing entropy
*/
entropyId: string;
/**
* Source of the `entropyId` property. This field determines how the entropyId will
* be used. Possible values include:
* - ethereum-address-verifier: the entropyId is the address of the Ethereum wallet derived
* at index 0 for this entropy
* - solana-address-verifier: the entropyId is a the address of the Solana wallet derived
* at index 0 for this entropy
*
* When this field is a wallet address, we can verify reconstitution was successful by
* deriving the specified wallet and comparing the address to the `entropyId`
*/
entropyIdVerifier: EntropyIdVerifier;
existingRecoveryMethod?: UserRecoveryMethod;
};
type WalletsSetRecoveryPasswordDataType = WalletsSetRecoveryBaseRequestDataType & {
recoveryMethod: 'user-passcode';
recoveryPassword: string;
};
type WalletsSetRecoveryGoogleDriveDataType = WalletsSetRecoveryBaseRequestDataType & {
recoveryMethod: 'google-drive';
recoveryAccessToken: string;
};
type WalletsSetRecoveryICloudDataType = WalletsSetRecoveryBaseRequestDataType & {
recoveryMethod: 'icloud';
recoveryAccessToken: string;
};
type WalletsSetRecoveryICloudNativeDataType = WalletsSetRecoveryBaseRequestDataType & {
recoveryMethod: 'icloud-native';
recoverySecretOverride: string;
iCloudRecordNameOverride: string;
};
type WalletsSetRecoveryRequestDataType = Omit<WalletsSetRecoveryPasswordDataType, 'chainType'> | Omit<WalletsSetRecoveryGoogleDriveDataType, 'chainType'> | Omit<WalletsSetRecoveryICloudDataType, 'chainType'> | Omit<WalletsSetRecoveryICloudNativeDataType, 'chainType'>;
type WalletsSetRecoveryResponseDataType = {
entropyId: string;
/**
* Source of the `entropyId` property. This field determines how the entropyId will
* be used. Possible values include:
* - ethereum-address-verifier: the entropyId is the address of the Ethereum wallet derived
* at index 0 for this entropy
* - solana-address-verifier: the entropyId is a the address of the Solana wallet derived
* at index 0 for this entropy
*
* When this field is a wallet address, we can verify reconstitution was successful by
* deriving the specified wallet and comparing the address to the `entropyId`
*/
entropyIdVerifier: EntropyIdVerifier;
recoveryMethod: WalletsSetRecoveryRequestDataType['recoveryMethod'];
};
type WalletsConnectRequestDataType = BaseProxyRequest & {
/**
* Key with which to look up the existing entropy
*/
entropyId: string;
/**
* Source of the key with which to look up the existing entropy
*/
entropyIdVerifier: EntropyIdVerifier;
};
type WalletsConnectResponseDataType = {
entropyId: string;
};
type WalletsRecoverRequestDataType = BaseProxyRequest & {
/**
* Key with which to look up the existing entropy
*/
entropyId: string;
/**
* Source of the `entropyId` property. This field determines how the entropyId will
* be used. Possible values include:
* - ethereum-address-verifier: the entropyId is the address of the Ethereum wallet derived
* at index 0 for this entropy
* - solana-address-verifier: the entropyId is a the address of the Solana wallet derived
* at index 0 for this entropy
*
* When this field is a wallet address, we can verify reconstitution was successful by
* deriving the specified wallet and comparing the address to the `entropyId`
*/
entropyIdVerifier: EntropyIdVerifier;
/** Optional: the user-specified recovery password, replaces recoveryPin */
recoveryPassword?: string;
/** Optional: the recovery encryption key */
recoveryKey?: string;
/** Optional: in the case of cloud recovery, the access token to be used to communicated with the cloud provider (eg Google) */
recoveryAccessToken?: string;
/** Optional: override the recoverySecret, only for use when we need to retrieve recovery secrets in cloud storage outside of the iframe (eg native) */
recoverySecretOverride?: string;
};
type WalletsRecoverResponseDataType = {
entropyId: string;
};
type WalletsRpcEthereumRequestDataType = {
chainType: 'ethereum';
request: EthereumRpcRequestType;
};
type WalletsRpcSolanaRequestDataType = {
chainType: 'solana';
request: SolanaRpcRequestType;
};
type WalletsRpcBitcoinRequestDataType = {
chainType: 'bitcoin-taproot' | 'bitcoin-segwit';
request: unknown;
};
type WalletsRpcP256RequestDataType = {
chainType: 'p256';
request: {
method: 'sign';
params: {
message: string;
};
};
};
type WalletsRpcRequestDataType = BaseWalletsRequestData & {
/**
* Key with which to look up the existing entropy
*/
entropyId: string;
/**
* Source of the `entropyId` property. This field determines how the entropyId will
* be used. Possible values include:
* - ethereum-address-verifier: the entropyId is the address of the Ethereum wallet derived
* at index 0 for this entropy
* - solana-address-verifier: the entropyId is a the address of the Solana wallet derived
* at index 0 for this entropy
*
* When this field is a wallet address, we can verify reconstitution was successful by
* deriving the specified wallet and comparing the address to the `entropyId`
*/
entropyIdVerifier: EntropyIdVerifier;
/**
* The HD node index of the wallet to use for this request.
*/
hdWalletIndex: number;
/** For cross-app requests, the app ID of the requester app */
requesterAppId?: string | null;
} & (WalletsRpcEthereumRequestDataType | WalletsRpcSolanaRequestDataType | WalletsRpcBitcoinRequestDataType | WalletsRpcP256RequestDataType);
type WalletsRpcEthereumResponseDataType = {
chainType: 'ethereum';
response: EthereumRpcResponseType;
};
type WalletsRpcSolanaResponseDataType = {
chainType: 'solana';
response: SolanaRpcResponseType;
};
type WalletsRpcBitcoinResponseDataType = {
chainType: 'bitcoin-taproot' | 'bitcoin-segwit';
response: unknown;
};
type WalletsRpcP256ResponseDataType = {
chainType: 'p256';
response: {
data: {
signature: string;
};
};
};
type WalletsRpcResponseDataType = {
address: string;
} & (WalletsRpcEthereumResponseDataType | WalletsRpcSolanaResponseDataType | WalletsRpcBitcoinResponseDataType | WalletsRpcP256ResponseDataType);
type BaseWalletCreateRequestDataType = {
accessToken: string;
};
type BaseWalletCreateWithUserControlledRecoveryDataType = {
recoveryPassword?: string;
recoveryMethod?: UserRecoveryMethod;
recoveryAccessToken?: string;
/**
* Will be deprecated in a future release, use `recoveryPassword` instead
* @deprecated
*/
recoveryPin?: string;
};
type EthereumWalletCreateRequestDataType = BaseWalletCreateRequestDataType & BaseWalletCreateWithUserControlledRecoveryDataType & {
/**
* If a user has an existing Solana embedded wallet when creating the Ethereum wallet, that address
* MUST be passed in this field. Our iframe will use this address to derive the Ethereum embedded wallet from the
* same entropy as the Solana wallet.
*
* If no address is passed here, our iframe assumes that the user has no existing Solana wallet and will create
* a new set of entropy for Ethereum.
*/
solanaAddress?: string;
};
type WalletCreateResponseDataType = {
address: string;
};
type SolanaWalletCreateRequestDataType = BaseWalletCreateRequestDataType & BaseWalletCreateWithUserControlledRecoveryDataType & {
/**
* If a user has an existing Ethereum embedded wallet when creating the Solana embedded wallet, that address
* MUST be passed in this field. Our iframe will use this address to derive the Solana embedded wallet from the
* same entropy as the Ethereum wallet.
*
* If no address is passed here, our iframe assumes that the user has no existing Ethereum wallet and will create
* a new set of entropy for Solana.
*/
ethereumAddress?: string;
};
type SolanaWalletCreateResponseDataType = {
publicKey: string;
};
type WalletsImportRequestDataType = BaseWalletsRequestData & {
privateKey: string;
chainType: 'ethereum' | 'solana';
};
type WalletsImportResponseDataType = {
address: string;
};
type MfaVerifyRequestDataType = {
accessToken: string;
};
type MfaVerifyResponseDataType = Record<string, never>;
type MfaInitEnrollmentRequestDataType = {
accessToken: string;
method: 'sms';
phoneNumber: string;
} | {
accessToken: string;
method: 'totp';
};
type MfaInitEnrollmentResponseDataType = {
method: string;
secret?: string;
authUrl?: string;
};
type MfaSubmitEnrollmentRequestDataType = {
accessToken: string;
method: 'sms';
code: string;
phoneNumber: string;
} | {
accessToken: string;
method: 'totp';
code: string;
} | {
accessToken: string;
method: 'passkey';
credentialIds: string[];
removeForLogin?: boolean;
};
type MfaSubmitEnrollmentResponseDataType = Record<string, never>;
type MfaUnenrollRequestDataType = {
accessToken: string;
method: 'sms' | 'totp';
};
type MfaUnenrollResponseDataType = Record<string, never>;
type MfaClearRequestDataType = {
userId: string;
};
type MfaClearResponseDataType = Record<string, never>;
type AuthUnlinkPasskeyRequestDataType = {
accessToken: string;
credentialId: string;
removeAsMfa?: boolean;
};
type AuthUnlinkPasskeyResponseDataType = Record<string, never>;
type FarcasterSignerInitRequestDataType = {
address: string;
hdWalletIndex: number | null;
accessToken: string;
mfaCode: string | PasskeyAuthenticateInputType['authenticator_response'] | null;
mfaMethod: string | null;
relyingParty: string;
};
type FarcasterSignerInitResponseDataType = PrivyFarcasterSignerInitResponse;
type FarcasterSignRequestDataType = {
address: string;
hdWalletIndex: number | null;
accessToken: string;
mfaCode: string | PasskeyAuthenticateInputType['authenticator_response'] | null;
mfaMethod: string | null;
relyingParty: string;
payload: {
hash: string;
};
fid: bigint;
};
type FarcasterSignResponseDataType = {
hash: string;
signature: string;
};
type RootWalletForDelegation = {
/** Address of the root wallet for the entropy being delegated. */
address: string;
/** Chain type of the root wallet for the entropy being delegated. */
chainType: 'ethereum' | 'solana';
/** Whether or not the root wallet for the entropy being delegated is imported. */
imported: boolean;
};
type DelegatedWallet = {
/** Address for a wallet to delegate. */
address: string;
/** Chain type for a wallet to delegate. */
chainType: 'ethereum' | 'solana';
/** HD index for the wallet to delegate. */
walletIndex: number;
};
type DelegatedActionsConsentRequestDataType = {
/** Access token for the user */
accessToken: string;
/** Root wallet to delegate, which is the wallet at HD index 0 for the entropy. */
rootWallet: RootWalletForDelegation;
/** Wallets to delegate, whose entropy is the same as `rootWallet`'s. */
delegatedWallets: DelegatedWallet[];
};
type DelegatedActionsConsentResponseDataType = {
success: boolean;
};
declare const PrivyIframeErrorTypes: readonly ["error", "invalid_request_arguments", "wallet_not_on_device", "invalid_recovery_pin", "insufficient_funds", "missing_or_invalid_mfa", "mfa_verification_max_attempts_reached", "mfa_timeout", "twilio_verification_failed"];
type PrivyIframeErrorTypesType = (typeof PrivyIframeErrorTypes)[number];
interface EmbeddedWalletProxy {
createSigner: (data: CreateSignerRequestDataType) => Promise<CreateSignerResponseDataType>;
createWallet: (data: WalletsCreateRequestDataType) => Promise<WalletsCreateResponseDataType>;
addWallet: (data: WalletsAddRequestDataType) => Promise<WalletsAddResponseDataType>;
importWallet: (data: WalletsImportRequestDataType) => Promise<WalletsImportResponseDataType>;
setRecovery: (data: WalletsSetRecoveryRequestDataType) => Promise<WalletsSetRecoveryResponseDataType>;
connect: (data: WalletsConnectRequestDataType) => Promise<WalletsConnectResponseDataType>;
recover: (data: WalletsRecoverRequestDataType) => Promise<WalletsRecoverResponseDataType>;
rpc(data: WalletsRpcRequestDataType & {
chainType: 'ethereum';
}): Promise<WalletsRpcResponseDataType & {
chainType: 'ethereum';
}>;
rpc(data: WalletsRpcRequestDataType & {
chainType: 'solana';
}): Promise<WalletsRpcResponseDataType & {
chainType: 'solana';
}>;
rpc(data: WalletsRpcRequestDataType & {
chainType: 'bitcoin-taproot';
}): Promise<WalletsRpcResponseDataType & {
chainType: 'bitcoin-taproot';
}>;
rpc(data: WalletsRpcRequestDataType & {
chainType: 'bitcoin-segwit';
}): Promise<WalletsRpcResponseDataType & {
chainType: 'bitcoin-segwit';
}>;
rpc(data: WalletsRpcRequestDataType & {
chainType: 'p256';
}): Promise<WalletsRpcResponseDataType & {
chainType: 'p256';
}>;
/** @deprecated */
create: (data: EthereumWalletCreateRequestDataType) => Promise<WalletCreateResponseDataType>;
/** @deprecated */
createSolana: (data: SolanaWalletCreateRequestDataType) => Promise<SolanaWalletCreateResponseDataType>;
createDelegatedAction: (data: DelegatedActionsConsentRequestDataType) => Promise<DelegatedActionsConsentResponseDataType>;
verifyMfa: (data: MfaVerifyRequestDataType) => Promise<MfaVerifyResponseDataType>;
initEnrollMfa: (data: MfaInitEnrollmentRequestDataType) => Promise<MfaInitEnrollmentResponseDataType>;
submitEnrollMfa: (data: MfaSubmitEnrollmentRequestDataType) => Promise<MfaSubmitEnrollmentResponseDataType>;
unenrollMfa: (data: MfaUnenrollRequestDataType) => Promise<MfaUnenrollResponseDataType>;
clearMfa: (data: MfaClearRequestDataType) => Promise<MfaClearResponseDataType>;
unlinkPasskeyAccount(data: AuthUnlinkPasskeyRequestDataType): Promise<AuthUnlinkPasskeyResponseDataType>;
initFarcasterSigner: (data: FarcasterSignerInitRequestDataType) => Promise<FarcasterSignerInitResponseDataType>;
signFarcasterMessage: (data: FarcasterSignRequestDataType) => Promise<FarcasterSignResponseDataType>;
}
declare function getCustomerAccessToken(): Promise<string | null>;
/**
* Properties to initialize the {@link PrivyProvider}.
*/
interface PrivyProviderProps {
/** Your Privy App ID, which can be retrieved from the Privy dashboard. */
appId: string;
/** Your Privy App Client ID, which can be retrieved from the Privy dashboard. */
clientId?: string;
/**
* Client configuration options.
* Values here will override their server-configuration counterparts.
*/
config?: PrivyClientConfig;
/**
* @ignore
* @class
*/
children: react__default.ReactNode;
}
/**
* Passes the Privy authentication context to your React components.
*
* This should wrap any components that will to use the Privy SDK via the {@link usePrivy} hook. As an example:
*
* ```typescript
* // At your application root (e.g. `_app.tsx` in NextJS):
* import {PrivyProvider} from '@privy-io/react-auth';
*
* <PrivyProvider appId="APP_ID_FROM_DASHBOARD" onSuccess={() => console.log('Success!')}>
* <Component {...pageProps} />
* </PrivyProvider>
* ```
*
*/
declare const PrivyProvider: ({ config, ...props }: PrivyProviderProps) => JSX.Element;
type CaptchaProps = Partial<Pick<TurnstileProps, 'onUnsupported' | 'onError' | 'onSuccess' | 'onExpire' | 'onSubmit'>> & {
delayedExecution?: boolean;
};
/**
* Used to render an invisible captcha alongside important forms
*
* Notes:
* - **Only for internal use, or use with headless SDK** _(the Privy modal handles captchas internally with this component)_
* - Only one `<Captcha />` should be rendered at a time, since it injects/removes a global script
* - the state of the captcha workflow can be accessed using `useCaptcha`
* - wrapper around [marsidev/react-turnstile](https://github.com/marsidev/react-turnstile), _accepts same [props](https://docs.page/marsidev/react-turnstile/props)_
*/
declare const Captcha: ({ delayedExecution, ...props }: CaptchaProps) => react_jsx_runtime.JSX.Element | null;
/**
* Build a viem public client for a given chainId if it is one of our
* supported chains.
*/
declare const getPublicClient: (chainId: number, chains: Chain[], rpcConfig: RpcConfig, options: {
appId: string;
}) => {
account: {
address: `0x${string}`;
type: "json-rpc";
};
batch?: viem.ClientConfig["batch"] | undefined;
cacheTime: number;
ccipRead?: viem.ClientConfig["ccipRead"] | undefined;
chain: Chain;
key: string;
name: string;
pollingInterval: number;
request: viem.EIP1193RequestFn<[{
Method: "web3_clientVersion";
Parameters?: undefined;
ReturnType: string;
}, {
Method: "web3_sha3";
Parameters: [data: viem.Hash];
ReturnType: string;
}, {
Method: "net_listening";
Parameters?: undefined;
ReturnType: boolean;
}, {
Method: "net_peerCount";
Parameters?: undefined;
ReturnType: viem.Quantity;
}, {
Method: "net_version";
Parameters?: undefined;
ReturnType: viem.Quantity;
}, {
Method: "eth_blobBaseFee";
Parameters?: undefined;
ReturnType: viem.Quantity;
}, {
Method: "eth_blockNumber";
Parameters?: undefined;
ReturnType: viem.Quantity;
}, {
Method: "eth_call";
Parameters: [transaction: viem.ExactPartial<viem.RpcTransactionRequest>] | [transaction: viem.ExactPartial<viem.RpcTransactionRequest>, block: viem.RpcBlockNumber | viem.BlockTag | viem.RpcBlockIdentifier] | [transaction: viem.ExactPartial<viem.RpcTransactionRequest>, block: viem.RpcBlockNumber | viem.BlockTag | viem.RpcBlockIdentifier, stateOverrideSet: viem.RpcStateOverride];
ReturnType: viem.Hex;
}, {
Method: "eth_createAccessList";
Parameters: [transaction: viem.ExactPartial<viem.RpcTransactionRequest>] | [transaction: viem.ExactPartial<viem.RpcTransactionRequest>, block: viem.RpcBlockNumber | viem.BlockTag | viem.RpcBlockIdentifier];
ReturnType: {
accessList: viem.AccessList;
gasUsed: viem.Quantity;
};
}, {
Method: "eth_chainId";
Parameters?: undefined;
ReturnType: viem.Quantity;
}, {
Method: "eth_coinbase";
Parameters?: undefined;
ReturnType: Address;
}, {
Method: "eth_estimateGas";
Parameters: [transaction: viem.RpcTransactionRequest] | [transaction: viem.RpcTransactionRequest, block: viem.RpcBlockNumber | viem.BlockTag] | [transaction: viem.RpcTransactionRequest, block: viem.RpcBlockNumber | viem.BlockTag, stateOverride: viem.RpcStateOverride];
ReturnType: viem.Quantity;
}, {
Method: "eth_feeHistory";
Parameters: [blockCount: viem.Quantity, newestBlock: viem.RpcBlockNumber | viem.BlockTag, rewardPercentiles: number[] | undefined];
ReturnType: viem.RpcFeeHistory;
}, {
Method: "eth_gasPrice";
Parameters?: undefined;
ReturnType: viem.Quantity;
}, {
Method: "eth_getBalance";
Parameters: [address: Address, block: viem.RpcBlockNumber | viem.BlockTag | viem.RpcBlockIdentifier];
ReturnType: viem.Quantity;
}, {
Method: "eth_getBlockByHash";
Parameters: [hash: viem.Hash, includeTransactionObjects: boolean];
ReturnType: viem.RpcBlock | null;
}, {
Method: "eth_getBlockByNumber";
Parameters: [block: viem.RpcBlockNumber | viem.BlockTag, includeTransactionObjects: boolean];
ReturnType: viem.RpcBlock | null;
}, {
Method: "eth_getBlockTransactionCountByHash";
Parameters: [hash: viem.Hash];
ReturnType: viem.Quantity;
}, {
Method: "eth_getBlockTransactionCountByNumber";
Parameters: [block: viem.RpcBlockNumber | viem.BlockTag];
ReturnType: viem.Quantity;
}, {
Method: "eth_getCode";
Parameters: [address: Address, block: viem.RpcBlockNumber | viem.BlockTag | viem.RpcBlockIdentifier];
ReturnType: viem.Hex;
}, {
Method: "eth_getFilterChanges";
Parameters: [filterId: viem.Quantity];
ReturnType: viem.RpcLog[] | viem.Hex[];
}, {
Method: "eth_getFilterLogs";
Parameters: [filterId: viem.Quantity];
ReturnType: viem.RpcLog[];
}, {
Method: "eth_getLogs";
Parameters: [{
address?: Address | Address[] | undefined;
topics?: viem.LogTopic[] | undefined;
} & ({
fromBlock?: viem.RpcBlockNumber | viem.BlockTag | undefined;
toBlock?: viem.RpcBlockNumber | viem.BlockTag | undefined;
blockHash?: undefined;
} | {
fromBlock?: undefined;
toBlock?: undefined;
blockHash?: viem.Hash | undefined;
})];
ReturnType: viem.RpcLog[];
}, {
Method: "eth_getProof";
Parameters: [address: Address, storageKeys: viem.Hash[], block: viem.RpcBlockNumber | viem.BlockTag];
ReturnType: viem.RpcProof;
}, {
Method: "eth_getStorageAt";
Parameters: [address: Address, index: viem.Quantity, block: viem.RpcBlockNumber | viem.BlockTag | viem.RpcBlockIdentifier];
ReturnType: viem.Hex;
}, {
Method: "eth_getTransactionByBlockHashAndIndex";
Parameters: [hash: viem.Hash, index: viem.Quantity];
ReturnType: viem.RpcTransaction | null;
}, {
Method: "eth_getTransactionByBlockNumberAndIndex";
Parameters: [block: viem.RpcBlockNumber | viem.BlockTag, index: viem.Quantity];
ReturnType: viem.RpcTransaction | null;
}, {
Method: "eth_getTransactionByHash";
Parameters: [hash: viem.Hash];
ReturnType: viem.RpcTransaction | null;
}, {
Method: "eth_getTransactionCount";
Parameters: [address: Address, block: viem.RpcBlockNumber | viem.BlockTag | viem.RpcBlockIdentifier];
ReturnType: viem.Quantity;
}, {
Method: "eth_getTransactionReceipt";
Parameters: [hash: viem.Hash];
ReturnType: viem.RpcTransactionReceipt | null;
}, {
Method: "eth_getUncleByBlockHashAndIndex";
Parameters: [hash: viem.Hash, index: viem.Quantity];
ReturnType: viem.RpcUncle | null;
}, {
Method: "eth_getUncleByBlockNumberAndIndex";
Parameters: [block: viem.RpcBlockNumber | viem.BlockTag, index: viem.Quantity];
ReturnType: viem.RpcUncle | null;
}, {
Method: "eth_getUncleCountByBlockHash";
Parameters: [hash: viem.Hash];
ReturnType: viem.Quantity;
}, {
Method: "eth_getUncleCountByBlockNumber";
Parameters: [block: viem.RpcBlockNumber | viem.BlockTag];
ReturnType: viem.Quantity;
}, {
Method: "eth_maxPriorityFeePerGas";
Parameters?: undefined;
ReturnType: viem.Quantity;
}, {
Method: "eth_newBlockFilter";
Parameters?: undefined;
ReturnType: viem.Quantity;
}, {
Method: "eth_newFilter";
Parameters: [filter: {
fromBlock?: viem.RpcBlockNumber | viem.BlockTag | undefined;
toBlock?: viem.RpcBlockNumber | viem.BlockTag | undefined;
address?: Address | Address[] | undefined;
topics?: viem.LogTopic[] | undefined;
}];
ReturnType: viem.Quantity;
}, {
Method: "eth_newPendingTransactionFilter";
Parameters?: undefined;
ReturnType: viem.Quantity;
}, {
Method: "eth_protocolVersion";
Parameters?: undefined;
ReturnType: string;
}, {
Method: "eth_sendRawTransaction";
Parameters: [signedTransaction: viem.Hex];
ReturnType: viem.Hash;
}, {
Method: "eth_simulateV1";
Parameters: [{
blockStateCalls: readonly {
blockOverrides?: viem.RpcBlockOverrides | undefined;
calls?: readonly viem.ExactPartial<viem.RpcTransactionRequest>[] | undefined;
stateOverrides?: viem.RpcStateOverride | undefined;
}[];
returnFullTransactions?: boolean | undefined;
traceTransfers?: boolean | undefined;
validation?: boolean | undefined;
}, viem.RpcBlockNumber | viem.BlockTag];
ReturnType: readonly (viem.RpcBlock & {
calls: readonly {
error?: {
data?: viem.Hex | undefined;
code: number;
message: string;
} | undefined;
logs?: readonly viem.RpcLog[] | undefined;
gasUsed: viem.Hex;
returnData: viem.Hex;
status: viem.Hex;
}[];
})[];
}, {
Method: "eth_uninstallFilter";
Parameters: [filterId: viem.Quantity];
ReturnType: boolean;
}, ...{
Method: string;
Parameters?: unknown | undefined;
ReturnType: unknown;
}[]]>;
transport: viem.TransportConfig<"http", viem.EIP1193RequestFn> & {
fetchOptions?: viem.HttpTransportConfig["fetchOptions"] | undefined;
url?: string | undefined;
};
type: string;
uid: string;
call: (parameters: viem.CallParameters<Chain>) => Promise<viem.CallReturnType>;
createAccessList: (parameters: viem.CreateAccessListParameters<Chain>) => Promise<viem.CreateAccessListReturnType>;
createBlockFilter: () => Promise<viem.CreateBlockFilterReturnType>;
createContractEventFilter: <const abi extends viem.Abi | readonly unknown[], eventName extends viem.ContractEventName<abi> | undefined, args extends viem.MaybeExtractEventArgsFromAbi<abi, eventName> | undefined, strict extends boolean | undefined = undefined, fromBlock extends viem.BlockNumber | viem.BlockTag | undefined = undefined, toBlock extends viem.BlockNumber | viem.BlockTag | undefined = undefined>(args: viem.CreateContractEventFilterParameters<abi, eventName, args, strict, fromBlock, toBlock>) => Promise<viem.CreateContractEventFilterReturnType<abi, eventName, args, strict, fromBlock, toBlock>>;
createEventFilter: <const abiEvent extends viem.AbiEvent | undefined = undefined, const abiEvents extends readonly viem.AbiEvent[] | readonly unknown[] | undefined = abiEvent extends viem.AbiEvent ? [abiEvent] : undefined, strict extends boolean | undefined = undefined, fromBlock extends viem.BlockNumber | viem.BlockTag | undefined = undefined, toBlock extends viem.BlockNumber | viem.BlockTag | undefined = undefined, _EventName extends string | undefined = viem.MaybeAbiEventName<abiEvent>, _Args extends viem.MaybeExtractEventArgsFromAbi<abiEvents, _EventName> | undefined = undefined>(args?: viem.CreateEventFilterParameters<abiEvent, abiEvents, strict, fromBlock, toBlock, _EventName, _Args> | undefined) => Promise<viem.CreateEventFilterReturnType<abiEvent, abiEvents, strict, fromBlock, toBlock, _EventName, _Args>>;
createPendingTransactionFilter: () => Promise<viem.CreatePendingTransactionFilterReturnType>;
estimateContractGas: <chain extends viem.Chain | undefined, const abi extends viem.Abi | readonly unknown[], functionName extends viem.ContractFunctionName<abi, "nonpayable" | "payable">, args extends viem.ContractFunctionArgs<abi, "nonpayable" | "payable", functionName>>(args: viem.EstimateContractGasParameters<abi, functionName, args, chain>) => Promise<viem.EstimateContractGasReturnType>;
estimateGas: (args: viem.EstimateGasParameters<Chain>) => Promise<viem.EstimateGasReturnType>;
getBalance: (args: viem.GetBalanceParameters) => Promise<viem.GetBalanceReturnType>;
getBlobBaseFee: () => Promise<viem.GetBlobBaseFeeReturnType>;
getBlock: <includeTransactions extends boolean = false, blockTag extends viem.BlockTag = "latest">(args?: viem.GetBlockParameters<includeTransactions, blockTag> | undefined) => Promise<viem.GetBlockReturnType<Chain, includeTransactions, blockTag>>;
getBlockNumber: (args?: viem.GetBlockNumberParameters | undefined) => Promise<viem.GetBlockNumberReturnType>;
getBlockTransactionCount: (args?: viem.GetBlockTransactionCountParameters | undefined) => Promise<viem.GetBlockTransactionCountReturnType>;
getBytecode: (args: viem.GetBytecodeParameters) => Promise<viem.GetBytecodeReturnType>;
getChainId: () => Promise<viem.GetChainIdReturnType>;
getCode: (args: viem.GetBytecodeParameters) => Promise<viem.GetBytecodeReturnType>;
getContractEvents: <const abi extends viem.Abi | readonly unknown[], eventName extends viem.ContractEventName<abi> | undefined = undefined, strict extends boolean | undefined = undefined, fromBlock extends viem.BlockNumber | viem.BlockTag | undefined = undefined, toBlock extends viem.BlockNumber | viem.BlockTag | undefined = undefined>(args: viem.GetContractEventsParameters<abi, eventName, strict, fromBlock, toBlock>) => Promise<viem.GetContractEventsReturnType<abi, eventName, strict, fromBlock, toBlock>>;
getEip712Domain: (args: viem.GetEip712DomainParameters) => Promise<viem.GetEip712DomainReturnType>;
getEnsAddress: (args: viem.GetEnsAddressParameters) => Promise<viem.GetEnsAddressReturnType>;
getEnsAvatar: (args: viem.GetEnsAvatarParameters) => Promise<viem.GetEnsAvatarReturnType>;
getEnsName: (args: viem.GetEnsNameParameters) => Promise<viem.GetEnsNameReturnType>;
getEnsResolver: (args: viem.GetEnsResolverParameters) => Promise<viem.GetEnsResolverReturnType>;
getEnsText: (args: viem.GetEnsTextParameters) => Promise<viem.GetEnsTextReturnType>;
getFeeHistory: (args: viem.GetFeeHistoryParameters) => Promise<viem.GetFeeHistoryReturnType>;
estimateFeesPerGas: <chainOverride extends viem.Chain | undefined = undefined, type extends viem.FeeValuesType = "eip1559">(args?: viem.EstimateFeesPerGasParameters<Chain, chainOverride, type> | undefined) => Promise<viem.EstimateFeesPerGasReturnType<type>>;
getFilterChanges: <filterType extends viem.FilterType, const abi extends viem.Abi | readonly unknown[] | undefined, eventName extends string | undefined, strict extends boolean | undefined = undefined, fromBlock extends viem.BlockNumber | viem.BlockTag | undefined = undefined, toBlock extends viem.BlockNumber | viem.BlockTag | undefined = undefined>(args: viem.GetFilterChangesParameters<filterType, abi, eventName, strict, fromBlock, toBlock>) => Promise<viem.GetFilterChangesReturnType<filterType, abi, eventName, strict, fromBlock, toBlock>>;
getFilterLogs: <const abi extends viem.Abi | readonly unknown[] | undefined, eventName extends string | undefined, strict extends boolean | undefined = undefined, fromBlock extends viem.BlockNumber | viem.BlockTag | undefined = undefined, toBlock extends viem.BlockNumber | viem.BlockTag | undefined = undefined>(args: viem.GetFilterLogsParameters<abi, eventName, strict, fromBlock, toBlock>) => Promise<viem.GetFilterLogsReturnType<abi, eventName, strict, fromBlock, toBlock>>;
getGasPrice: () => Promise<viem.GetGasPriceReturnType>;
getLogs: <const abiEvent extends viem.AbiEvent | undefined = undefined, const abiEvents extends readonly viem.AbiEvent[] | readonly unknown[] | undefined = abiEvent extends viem.AbiEvent ? [abiEvent] : undefined, strict extends boolean | undefined = undefined, fromBlock extends viem.BlockNumber | viem.BlockTag | undefined = undefined, toBlock extends viem.BlockNumber | viem.BlockTag | undefined = undefined>(args?: viem.GetLogsParameters<abiEvent, abiEvents, strict, fromBlock, toBlock> | undefined) => Promise<viem.GetLogsReturnType<abiEvent, abiEvents, strict, fromBlock, toBlock>>;
getProof: (args: viem.GetProofParameters) => Promise<viem.GetProofReturnType>;
estimateMaxPriorityFeePerGas: <chainOverride extends viem.Chain | undefined = undefined>(args?: {
chain?: chainOverride | null | undefined;
} | undefined) => Promise<viem.EstimateMaxPriorityFeePerGasReturnType>;
getStorageAt: (args: viem.GetStorageAtParameters) => Promise<viem.GetStorageAtReturnType>;
getTransaction: <blockTag extends viem.BlockTag = "latest">(args: viem.GetTransactionParameters<blockTag>) => Promise<viem.GetTransactionReturnType<Chain, blockTag>>;
getTransactionConfirmations: (args: viem.GetTransactionConfirmationsParameters<Chain>) => Promise<viem.GetTransactionConfirmationsReturnType>;
getTransactionCount: (args: viem.GetTransactionCountParameters) => Promise<viem.GetTransactionCountReturnType>;
getTransactionReceipt: (args: viem.GetTransactionReceiptParameters) => Promise<viem.GetTransactionReceiptReturnType<Chain>>;
multicall: <const contracts extends readonly unknown[], allowFailure extends boolean = true>(args: viem.MulticallParameters<contracts, allowFailure>) => Promise<viem.MulticallReturnType<contracts, allowFailure>>;
prepareTransactionRequest: <const request extends viem.PrepareTransactionRequestRequest<Chain, chainOverride>, chainOverride extends viem.Chain | undefined = undefined, accountOverride extends viem.Account | Address | undefined = undefined>(args: viem.PrepareTransactionRequestParameters<Chain, viem.Account | undefined, chainOverride, accountOverride, request>) => Promise<viem.PrepareTransactionRequestReturnType<Chain, viem.Account | undefined, chainOverride, accountOverride, request>>;
readContract: <const abi extends viem.Abi | readonly unknown[], functionName extends viem.ContractFunctionName<abi, "pure" | "view">, const args extends viem.ContractFunctionArgs<abi, "pure" | "view", functionName>>(args: viem.ReadContractParameters<abi, functionName, args>) => Promise<viem.ReadContractReturnType<abi, functionName, args>>;
sendRawTransaction: (args: viem.SendRawTransactionParameters) => Promise<viem.SendRawTransactionReturnType>;
simulate: <const calls extends readonly unknown[]>(args: viem.SimulateBlocksParameters<calls>) => Promise<viem.SimulateBlocksReturnType<calls>>;
simulateBlocks: <const calls extends readonly unknown[]>(args: viem.SimulateBlocksParameters<calls>) => Promise<viem.SimulateBlocksReturnType<calls>>;
simulateCalls: <const calls extends readonly unknown[]>(args: viem.SimulateCallsParameters<calls>) => Promise<viem.SimulateCallsReturnType<calls>>;
simulateContract: <const abi extends viem.Abi | readonly unknown[], functionName extends viem.ContractFunctionName<abi, "nonpayable" | "payable">, const args_1 extends viem.ContractFunctionArgs<abi, "nonpayable" | "payable", functionName>, chainOverride extends viem.Chain | undefined, accountOverride extends viem.Account | Address | undefined = undefined>(args: viem.SimulateContractParameters<abi, functionName, args_1, Chain, chainOverride, accountOverride>) => Promise<viem.SimulateContractReturnType<abi, functionName, args_1, Chain, viem.Account | undefined, chainOverride, accountOverride>>;
verifyMessage: (args: viem.VerifyMessageActionParameters) => Promise<viem.VerifyMessageActionReturnType>;
verifySiweMessage: (args: viem__types_actions_siwe_verifySiweMessage.VerifySiweMessageParameters) => Promise<viem__types_actions_siwe_verifySiweMessage.VerifySiweMessageReturnType>;
verifyTypedData: (args: viem.VerifyTypedDataActionParameters) => Promise<viem.VerifyTypedDataActionReturnType>;
uninstallFilter: (args: viem.UninstallFilterParameters) => Promise<viem.UninstallFilterReturnType>;
waitForTransactionReceipt: (args: viem.WaitForTransactionReceiptParameters<Chain>) => Promise<viem.WaitForTransactionReceiptReturnType<Chain>>;
watchBlockNumber: (args: viem.WatchBlockNumberParameters) => viem.WatchBlockNumberReturnType;
watchBlocks: <includeTransactions extends boolean = false, blockTag extends viem.BlockTag = "latest">(args: viem.WatchBlocksParameters<HttpTransport, Chain, includeTransactions, blockTag>) => viem.WatchBlocksReturnType;
watchContractEvent: <const abi extends viem.Abi | readonly unknown[], eventName extends viem.ContractEventName<abi>, strict extends boolean | undefined = undefined>(args: viem.WatchContractEventParameters<abi, eventName, strict, HttpTransport>) => viem.WatchContractEventReturnType;
watchEvent: <const abiEvent extends viem.AbiEvent | undefined = undefined, const abiEvents extends readonly viem.AbiEvent[] | readonly unknown[] | undefined = abiEvent extends viem.AbiEvent ? [abiEvent] : undefined, strict extends boolean | undefined = undefined>(args: viem.WatchEventParameters<abiEvent, abiEvents, strict, HttpTransport>) => viem.WatchEventReturnType;
watchPendingTransactions: (args: viem.WatchPendingTransactionsParameters<HttpTransport>) => viem.WatchPendingTransactionsReturnType;
extend: <const client extends {
[x: string]: unknown;
account?: undefined;
batch?: undefined;
cacheTime?: undefined;
ccipRead?: undefined;
chain?: undefined;
key?: undefined;
name?: undefined;
pollingInterval?: undefined;
request?: undefined;
transport?: undefined;
type?: undefined;
uid?: undefined;
} & viem.ExactPartial<Pick<viem.PublicActions<HttpTransport, Chain, {
address: `0x${string}`;
type: "json-rpc";
}>, "call" | "createContractEventFilter" | "createEventFilter" | "estimateContractGas" | "estimateGas" | "getBlock" | "getBlockNumber" | "getChainId" | "getContractEvents" | "getEnsText" | "getFilterChanges" | "getGasPrice" | "getLogs" | "getTransaction" | "getTransactionCount" | "getTransactionReceipt" | "prepareTransactionRequest" | "readContract" | "sendRawTransaction" | "simulateContract" | "uninstallFilter" | "watchBlockNumber" | "watchContractEvent"> & Pick<viem.WalletActions<Chain, {
address: `0x${string}`;
type: "json-rpc";
}>, "sendTransaction" | "writeContract">>>(fn: (client: viem.Client<HttpTransport, Chain, {
address: `0x${string}`;
type: "json-rpc";
}, [{
Method: "web3_clientVersion";
Parameters?: undefined;
ReturnType: string;
}, {
Method: "web3_sha3";
Parameters: [data: viem.Hash];
ReturnType: string;
}, {
Method: "net_listening";
Parameters?: undefined;
ReturnType: boolean;
}, {
Method: "net_peerCount";
Parameters?: undefined;
ReturnType: viem.Quantity;
}, {
Method: "net_version";
Parameters?: undefined;
ReturnType: viem.Quantity;
}, {
Method: "eth_blobBaseFee";
Parameters?: undefined;
ReturnType: viem.Quantity;
}, {
Method: "eth_blockNumber";
Parameters?: undefined;
ReturnType: viem.Quantity;
}, {
Method: "eth_call";
Parameters: [transaction: viem.ExactPartial<viem.RpcTransactionRequest>] | [transaction: viem.ExactPartial<viem.RpcTransactionRequest>, block: viem.RpcBlockNumber | viem.BlockTag | viem.RpcBlockIdentifier] | [transaction: viem.ExactPartial<viem.RpcTransactionRequest>, block: viem.RpcBlockNumber | viem.BlockTag | viem.RpcBlockIdentifier, stateOverrideSet: viem.RpcStateOverride];
ReturnType: viem.Hex;
}, {
Method: "eth_createAccessList";
Parameters: [transaction: viem.ExactPartial<viem.RpcTransactionRequest>] | [transaction: viem.ExactPartial<viem.RpcTransactionRequest>, block: viem.RpcBlockNumber | viem.BlockTag | viem.RpcBlockIdentifier];
ReturnType: {
accessList: viem.AccessList;
gasUsed: viem.Quantity;
};
}, {
Method: "eth_chainId";
Parameters?: undefined;
ReturnType: viem.Quantity;
}, {
Method: "eth_coinbase";
Parameters?: undefined;
ReturnType: Address;
}, {
Method: "eth_estimateGas";
Parameters: [transaction: viem.RpcTransactionRequest] | [transaction: viem.RpcTransactionRequest, block: viem.RpcBlockNumber | viem.BlockTag] | [transaction: viem.RpcTransactionRequest, block: viem.RpcBlockNumber | viem.BlockTag, stateOverride: viem.RpcStateOverride];
ReturnType: viem.Quantity;
}, {
Method: "eth_feeHistory";
Parameters: [blockCount: viem.Quantity, newestBlock: viem.RpcBlockNumber | viem.BlockTag, rewardPercentiles: number[] | undefined];
ReturnType: viem.RpcFeeHistory;
}, {
Method: "eth_gasPrice";
Parameters?: undefined;
ReturnType: viem.Quantity;
}, {
Method: "eth_getBalance";
Parameters: [address: Address, block: viem.RpcBlockNumber | viem.BlockTag | viem.RpcBlockIdentifier];
ReturnType: viem.Quantity;
}, {
Method: "eth_getBlockByHash";
Parameters: [hash: viem.Hash, includeTransactionObjects: boolean];
ReturnType: viem.RpcBlock | null;
}, {
Method: "eth_getBlockByNumber";
Parameters: [block: viem.RpcBlockNumber | viem.BlockTag, includeTransactionObjects: boolean];
ReturnType: viem.RpcBlock | null;
}, {
Method: "eth_getBlockTransactionCountByHash";
Parameters: [hash: viem.Hash];
ReturnType: viem.Quantity;
}, {
Method: "eth_getBlockTransactionCountByNumber";
Parameters: [block: viem.RpcBlockNumber | viem.BlockTag];
ReturnType: viem.Quantity;
}, {
Method: "eth_getCode";
Parameters: [address: Address, block: viem.RpcBlockNumber | viem.BlockTag | viem.RpcBlockIdentifier];
ReturnType: viem.Hex;
}, {
Method: "eth_getFilterChanges";
Parameters: [filterId: viem.Quantity];
ReturnType: viem.RpcLog[] | viem.Hex[];
}, {
Method: "eth_getFilterLogs";
Parameters: [filterId: viem.Quantity];
ReturnType: viem.RpcLog[];
}, {
Method: "eth_getLogs";
Parameters: [{
address?: Address | Address[] | undefined;
topics?: viem.LogTopic[] | undefined;
} & ({
fromBlock?