Function getRemoveOwnableValidatorOwnerAction

Parameters

• __namedParameters: {
      account: Account;
      client: {
          account: undefined;
          batch?: {
              multicall?: boolean | {
                  batchSize?: number;
                  wait?: number;
              };
          };
          cacheTime: number;
          call: ((parameters) => Promise<CallReturnType>);
          ccipRead?: false | {
              request?: ((parameters) => Promise<`0x${string}`>);
          };
          chain: undefined | Chain;
          createBlockFilter: (() => Promise<{
              id: `0x${string}`;
              request: EIP1193RequestFn<readonly [{
                  Method: "eth_getFilterChanges";
                  Parameters: [filterId: `0x${string}`];
                  ReturnType: `0x${(...)}`[] | RpcLog[];
              }, {
                  Method: "eth_getFilterLogs";
                  Parameters: [filterId: `0x${string}`];
                  ReturnType: RpcLog[];
              }, {
                  Method: "eth_uninstallFilter";
                  Parameters: [filterId: `0x${string}`];
                  ReturnType: boolean;
              }]>;
              type: "block";
          }>);
          createContractEventFilter: (<const abi, eventName, args, strict, fromBlock, toBlock>(args) => Promise<CreateContractEventFilterReturnType<abi, eventName, args, strict, fromBlock, toBlock>>);
          createEventFilter: (<const abiEvent, const abiEvents, strict, fromBlock, toBlock, _EventName, _Args>(args?) => Promise<{
              [K in string | number | symbol]: Filter<"event", abiEvents, _EventName, _Args, strict, fromBlock, toBlock>[K]
          }>);
          createPendingTransactionFilter: (() => Promise<{
              id: `0x${string}`;
              request: EIP1193RequestFn<readonly [{
                  Method: "eth_getFilterChanges";
                  Parameters: [filterId: `0x${string}`];
                  ReturnType: `0x${(...)}`[] | RpcLog[];
              }, {
                  Method: "eth_getFilterLogs";
                  Parameters: [filterId: `0x${string}`];
                  ReturnType: RpcLog[];
              }, {
                  Method: "eth_uninstallFilter";
                  Parameters: [filterId: `0x${string}`];
                  ReturnType: boolean;
              }]>;
              type: "transaction";
          }>);
          estimateContractGas: (<chain, const abi, functionName, args>(args) => Promise<bigint>);
          estimateFeesPerGas: (<chainOverride, type>(args?) => Promise<EstimateFeesPerGasReturnType<type>>);
          estimateGas: ((args) => Promise<bigint>);
          estimateMaxPriorityFeePerGas: (<chainOverride>(args?) => Promise<bigint>);
          extend: (<const client>(fn) => Client<Transport, undefined | Chain, undefined, PublicRpcSchema, {
              [K in string | number | symbol]: client[K]
          } & PublicActions<Transport, undefined | Chain>>);
          getBalance: ((args) => Promise<bigint>);
          getBlobBaseFee: (() => Promise<bigint>);
          getBlock: (<includeTransactions, blockTag>(args?) => Promise<{
              baseFeePerGas: null | bigint;
              blobGasUsed: bigint;
              difficulty: bigint;
              excessBlobGas: bigint;
              extraData: `0x${string}`;
              gasLimit: bigint;
              gasUsed: bigint;
              hash: blockTag extends "pending"
                  ? null
                  : `0x${string}`;
              logsBloom: blockTag extends "pending"
                  ? null
                  : `0x${string}`;
              miner: `0x${string}`;
              mixHash: `0x${string}`;
              nonce: blockTag extends "pending"
                  ? null
                  : `0x${string}`;
              number: blockTag extends "pending"
                  ? null
                  : bigint;
              parentHash: `0x${string}`;
              receiptsRoot: `0x${string}`;
              sealFields: `0x${string}`[];
              sha3Uncles: `0x${string}`;
              size: bigint;
              stateRoot: `0x${string}`;
              timestamp: bigint;
              totalDifficulty: null | bigint;
              transactions: includeTransactions extends true
                  ? ({
                      accessList?: undefined;
                      authorizationList?: undefined;
                      blobVersionedHashes?: undefined;
                      blockHash: ((...) extends (...)
                              ? (...)
                              : (...)) extends true
                          ? null
                          : `0x${(...)}`;
                      blockNumber: ((...) extends (...)
                              ? (...)
                              : (...)) extends true
                          ? null
                          : bigint;
                      chainId?: number;
                      from: `0x${string}`;
                      gas: bigint;
                      gasPrice: bigint;
                      hash: `0x${string}`;
                      input: `0x${string}`;
                      maxFeePerBlobGas?: undefined;
                      maxFeePerGas?: undefined;
                      maxPriorityFeePerGas?: undefined;
                      nonce: number;
                      r: `0x${string}`;
                      s: `0x${string}`;
                      to: null | `0x${(...)}`;
                      transactionIndex: ((...) extends (...)
                              ? (...)
                              : (...)) extends true
                          ? null
                          : number;
                      type: "legacy";
                      typeHex: null | `0x${(...)}`;
                      v: bigint;
                      value: bigint;
                      yParity?: undefined;
                  } | {
                      accessList: AccessList;
                      authorizationList?: undefined;
                      blobVersionedHashes?: undefined;
                      blockHash: ((...) extends (...)
                              ? (...)
                              : (...)) extends true
                          ? null
                          : `0x${(...)}`;
                      blockNumber: ((...) extends (...)
                              ? (...)
                              : (...)) extends true
                          ? null
                          : bigint;
                      chainId: number;
                      from: `0x${string}`;
                      gas: bigint;
                      gasPrice: bigint;
                      hash: `0x${string}`;
                      input: `0x${string}`;
                      maxFeePerBlobGas?: undefined;
                      maxFeePerGas?: undefined;
                      maxPriorityFeePerGas?: undefined;
                      nonce: number;
                      r: `0x${string}`;
                      s: `0x${string}`;
                      to: null | `0x${(...)}`;
                      transactionIndex: ((...) extends (...)
                              ? (...)
                              : (...)) extends true
                          ? null
                          : number;
                      type: "eip2930";
                      typeHex: null | `0x${(...)}`;
                      v: bigint;
                      value: bigint;
                      yParity: number;
                  } | {
                      accessList: AccessList;
                      authorizationList?: undefined;
                      blobVersionedHashes?: undefined;
                      blockHash: ((...) extends (...)
                              ? (...)
                              : (...)) extends true
                          ? null
                          : `0x${(...)}`;
                      blockNumber: ((...) extends (...)
                              ? (...)
                              : (...)) extends true
                          ? null
                          : bigint;
                      chainId: number;
                      from: `0x${string}`;
                      gas: bigint;
                      gasPrice?: undefined;
                      hash: `0x${string}`;
                      input: `0x${string}`;
                      maxFeePerBlobGas?: undefined;
                      maxFeePerGas: bigint;
                      maxPriorityFeePerGas: bigint;
                      nonce: number;
                      r: `0x${string}`;
                      s: `0x${string}`;
                      to: null | `0x${(...)}`;
                      transactionIndex: ((...) extends (...)
                              ? (...)
                              : (...)) extends true
                          ? null
                          : number;
                      type: "eip1559";
                      typeHex: null | `0x${(...)}`;
                      v: bigint;
                      value: bigint;
                      yParity: number;
                  } | {
                      accessList: AccessList;
                      authorizationList?: undefined;
                      blobVersionedHashes: readonly `0x${(...)}`[];
                      blockHash: ((...) extends (...)
                              ? (...)
                              : (...)) extends true
                          ? null
                          : `0x${(...)}`;
                      blockNumber: ((...) extends (...)
                              ? (...)
                              : (...)) extends true
                          ? null
                          : bigint;
                      chainId: number;
                      from: `0x${string}`;
                      gas: bigint;
                      gasPrice?: undefined;
                      hash: `0x${string}`;
                      input: `0x${string}`;
                      maxFeePerBlobGas: bigint;
                      maxFeePerGas: bigint;
                      maxPriorityFeePerGas: bigint;
                      nonce: number;
                      r: `0x${string}`;
                      s: `0x${string}`;
                      to: null | `0x${(...)}`;
                      transactionIndex: ((...) extends (...)
                              ? (...)
                              : (...)) extends true
                          ? null
                          : number;
                      type: "eip4844";
                      typeHex: null | `0x${(...)}`;
                      v: bigint;
                      value: bigint;
                      yParity: number;
                  } | {
                      accessList: AccessList;
                      authorizationList: SignedAuthorizationList;
                      blobVersionedHashes?: undefined;
                      blockHash: ((...) extends (...)
                              ? (...)
                              : (...)) extends true
                          ? null
                          : `0x${(...)}`;
                      blockNumber: ((...) extends (...)
                              ? (...)
                              : (...)) extends true
                          ? null
                          : bigint;
                      chainId: number;
                      from: `0x${string}`;
                      gas: bigint;
                      gasPrice?: undefined;
                      hash: `0x${string}`;
                      input: `0x${string}`;
                      maxFeePerBlobGas?: undefined;
                      maxFeePerGas: bigint;
                      maxPriorityFeePerGas: bigint;
                      nonce: number;
                      r: `0x${string}`;
                      s: `0x${string}`;
                      to: null | `0x${(...)}`;
                      transactionIndex: ((...) extends (...)
                              ? (...)
                              : (...)) extends true
                          ? null
                          : number;
                      type: "eip7702";
                      typeHex: null | `0x${(...)}`;
                      v: bigint;
                      value: bigint;
                      yParity: number;
                  })[]
                  : `0x${string}`[];
              transactionsRoot: `0x${string}`;
              uncles: `0x${string}`[];
              withdrawals?: Withdrawal[];
              withdrawalsRoot?: `0x${string}`;
          }>);
          getBlockNumber: ((args?) => Promise<bigint>);
          getBlockTransactionCount: ((args?) => Promise<number>);
          getBytecode: ((args) => Promise<GetCodeReturnType>);
          getChainId: (() => Promise<number>);
          getCode: ((args) => Promise<GetCodeReturnType>);
          getContractEvents: (<const abi, eventName, strict, fromBlock, toBlock>(args) => Promise<GetContractEventsReturnType<abi, eventName, strict, fromBlock, toBlock>>);
          getEip712Domain: ((args) => Promise<GetEip712DomainReturnType>);
          getEnsAddress: ((args) => Promise<GetEnsAddressReturnType>);
          getEnsAvatar: ((args) => Promise<GetEnsAvatarReturnType>);
          getEnsName: ((args) => Promise<GetEnsNameReturnType>);
          getEnsResolver: ((args) => Promise<`0x${string}`>);
          getEnsText: ((args) => Promise<GetEnsTextReturnType>);
          getFeeHistory: ((args) => Promise<GetFeeHistoryReturnType>);
          getFilterChanges: (<filterType, const abi, eventName, strict, fromBlock, toBlock>(args) => Promise<GetFilterChangesReturnType<filterType, abi, eventName, strict, fromBlock, toBlock>>);
          getFilterLogs: (<const abi, eventName, strict, fromBlock, toBlock>(args) => Promise<GetFilterLogsReturnType<abi, eventName, strict, fromBlock, toBlock>>);
          getGasPrice: (() => Promise<bigint>);
          getLogs: (<const abiEvent, const abiEvents, strict, fromBlock, toBlock>(args?) => Promise<GetLogsReturnType<abiEvent, abiEvents, strict, fromBlock, toBlock>>);
          getProof: ((args) => Promise<GetProofReturnType>);
          getStorageAt: ((args) => Promise<GetStorageAtReturnType>);
          getTransaction: (<blockTag>(args) => Promise<{
              accessList?: undefined;
              authorizationList?: undefined;
              blobVersionedHashes?: undefined;
              blockHash: (blockTag extends "pending"
                      ? true
                      : false) extends true
                  ? null
                  : `0x${string}`;
              blockNumber: (blockTag extends "pending"
                      ? true
                      : false) extends true
                  ? null
                  : bigint;
              chainId?: number;
              from: `0x${string}`;
              gas: bigint;
              gasPrice: bigint;
              hash: `0x${string}`;
              input: `0x${string}`;
              maxFeePerBlobGas?: undefined;
              maxFeePerGas?: undefined;
              maxPriorityFeePerGas?: undefined;
              nonce: number;
              r: `0x${string}`;
              s: `0x${string}`;
              to: null | `0x${string}`;
              transactionIndex: (blockTag extends "pending"
                      ? true
                      : false) extends true
                  ? null
                  : number;
              type: "legacy";
              typeHex: null | `0x${string}`;
              v: bigint;
              value: bigint;
              yParity?: undefined;
          } | {
              accessList: AccessList;
              authorizationList?: undefined;
              blobVersionedHashes?: undefined;
              blockHash: (blockTag extends "pending"
                      ? true
                      : false) extends true
                  ? null
                  : `0x${string}`;
              blockNumber: (blockTag extends "pending"
                      ? true
                      : false) extends true
                  ? null
                  : bigint;
              chainId: number;
              from: `0x${string}`;
              gas: bigint;
              gasPrice: bigint;
              hash: `0x${string}`;
              input: `0x${string}`;
              maxFeePerBlobGas?: undefined;
              maxFeePerGas?: undefined;
              maxPriorityFeePerGas?: undefined;
              nonce: number;
              r: `0x${string}`;
              s: `0x${string}`;
              to: null | `0x${string}`;
              transactionIndex: (blockTag extends "pending"
                      ? true
                      : false) extends true
                  ? null
                  : number;
              type: "eip2930";
              typeHex: null | `0x${string}`;
              v: bigint;
              value: bigint;
              yParity: number;
          } | {
              accessList: AccessList;
              authorizationList?: undefined;
              blobVersionedHashes?: undefined;
              blockHash: (blockTag extends "pending"
                      ? true
                      : false) extends true
                  ? null
                  : `0x${string}`;
              blockNumber: (blockTag extends "pending"
                      ? true
                      : false) extends true
                  ? null
                  : bigint;
              chainId: number;
              from: `0x${string}`;
              gas: bigint;
              gasPrice?: undefined;
              hash: `0x${string}`;
              input: `0x${string}`;
              maxFeePerBlobGas?: undefined;
              maxFeePerGas: bigint;
              maxPriorityFeePerGas: bigint;
              nonce: number;
              r: `0x${string}`;
              s: `0x${string}`;
              to: null | `0x${string}`;
              transactionIndex: (blockTag extends "pending"
                      ? true
                      : false) extends true
                  ? null
                  : number;
              type: "eip1559";
              typeHex: null | `0x${string}`;
              v: bigint;
              value: bigint;
              yParity: number;
          } | {
              accessList: AccessList;
              authorizationList?: undefined;
              blobVersionedHashes: readonly `0x${string}`[];
              blockHash: (blockTag extends "pending"
                      ? true
                      : false) extends true
                  ? null
                  : `0x${string}`;
              blockNumber: (blockTag extends "pending"
                      ? true
                      : false) extends true
                  ? null
                  : bigint;
              chainId: number;
              from: `0x${string}`;
              gas: bigint;
              gasPrice?: undefined;
              hash: `0x${string}`;
              input: `0x${string}`;
              maxFeePerBlobGas: bigint;
              maxFeePerGas: bigint;
              maxPriorityFeePerGas: bigint;
              nonce: number;
              r: `0x${string}`;
              s: `0x${string}`;
              to: null | `0x${string}`;
              transactionIndex: (blockTag extends "pending"
                      ? true
                      : false) extends true
                  ? null
                  : number;
              type: "eip4844";
              typeHex: null | `0x${string}`;
              v: bigint;
              value: bigint;
              yParity: number;
          } | {
              accessList: AccessList;
              authorizationList: SignedAuthorizationList;
              blobVersionedHashes?: undefined;
              blockHash: (blockTag extends "pending"
                      ? true
                      : false) extends true
                  ? null
                  : `0x${string}`;
              blockNumber: (blockTag extends "pending"
                      ? true
                      : false) extends true
                  ? null
                  : bigint;
              chainId: number;
              from: `0x${string}`;
              gas: bigint;
              gasPrice?: undefined;
              hash: `0x${string}`;
              input: `0x${string}`;
              maxFeePerBlobGas?: undefined;
              maxFeePerGas: bigint;
              maxPriorityFeePerGas: bigint;
              nonce: number;
              r: `0x${string}`;
              s: `0x${string}`;
              to: null | `0x${string}`;
              transactionIndex: (blockTag extends "pending"
                      ? true
                      : false) extends true
                  ? null
                  : number;
              type: "eip7702";
              typeHex: null | `0x${string}`;
              v: bigint;
              value: bigint;
              yParity: number;
          }>);
          getTransactionConfirmations: ((args) => Promise<bigint>);
          getTransactionCount: ((args) => Promise<number>);
          getTransactionReceipt: ((args) => Promise<TransactionReceipt>);
          key: string;
          multicall: (<const contracts, allowFailure>(args) => Promise<MulticallReturnType<contracts, allowFailure>>);
          name: string;
          pollingInterval: number;
          prepareTransactionRequest: (<const request, chainOverride, accountOverride>(args) => Promise<{
              [K in string | number | symbol]: (UnionRequiredBy<Extract<(...) & (...) & (...), (...) extends (...)
                  ? (...)
                  : (...)> & {
                  chainId?: (...) | (...);
              }, ParameterTypeToParameters<(...)[(...)] extends readonly (...)[]
                  ? (...)[(...)]
                  : (...) | (...) | (...) | (...) | (...) | (...)>> & (unknown extends request["kzg"]
                  ? {}
                  : Pick<request, "kzg">))[K]
          }>);
          readContract: (<const abi, functionName, args>(args) => Promise<ReadContractReturnType<abi, functionName, args>>);
          request: EIP1193RequestFn<PublicRpcSchema>;
          sendRawTransaction: ((args) => Promise<`0x${string}`>);
          simulateContract: (<const abi, functionName, args, chainOverride, accountOverride>(args) => Promise<SimulateContractReturnType<abi, functionName, args, undefined | Chain, undefined | Account, chainOverride, accountOverride>>);
          transport: TransportConfig<string, EIP1193RequestFn> & Record<string, any>;
          type: string;
          uid: string;
          uninstallFilter: ((args) => Promise<boolean>);
          verifyMessage: ((args) => Promise<boolean>);
          verifySiweMessage: ((args) => Promise<boolean>);
          verifyTypedData: ((args) => Promise<boolean>);
          waitForTransactionReceipt: ((args) => Promise<TransactionReceipt>);
          watchBlockNumber: ((args) => WatchBlockNumberReturnType);
          watchBlocks: (<includeTransactions, blockTag>(args) => WatchBlocksReturnType);
          watchContractEvent: (<const abi, eventName, strict>(args) => WatchContractEventReturnType);
          watchEvent: (<const abiEvent, const abiEvents, strict>(args) => WatchEventReturnType);
          watchPendingTransactions: ((args) => WatchPendingTransactionsReturnType);
      };
      owner: `0x${string}`;
  }

  • account: Account

  • client: {
        account: undefined;
        batch?: {
            multicall?: boolean | {
                batchSize?: number;
                wait?: number;
            };
        };
        cacheTime: number;
        call: ((parameters) => Promise<CallReturnType>);
        ccipRead?: false | {
            request?: ((parameters) => Promise<`0x${string}`>);
        };
        chain: undefined | Chain;
        createBlockFilter: (() => Promise<{
            id: `0x${string}`;
            request: EIP1193RequestFn<readonly [{
                Method: "eth_getFilterChanges";
                Parameters: [filterId: `0x${string}`];
                ReturnType: `0x${(...)}`[] | RpcLog[];
            }, {
                Method: "eth_getFilterLogs";
                Parameters: [filterId: `0x${string}`];
                ReturnType: RpcLog[];
            }, {
                Method: "eth_uninstallFilter";
                Parameters: [filterId: `0x${string}`];
                ReturnType: boolean;
            }]>;
            type: "block";
        }>);
        createContractEventFilter: (<const abi, eventName, args, strict, fromBlock, toBlock>(args) => Promise<CreateContractEventFilterReturnType<abi, eventName, args, strict, fromBlock, toBlock>>);
        createEventFilter: (<const abiEvent, const abiEvents, strict, fromBlock, toBlock, _EventName, _Args>(args?) => Promise<{
            [K in string | number | symbol]: Filter<"event", abiEvents, _EventName, _Args, strict, fromBlock, toBlock>[K]
        }>);
        createPendingTransactionFilter: (() => Promise<{
            id: `0x${string}`;
            request: EIP1193RequestFn<readonly [{
                Method: "eth_getFilterChanges";
                Parameters: [filterId: `0x${string}`];
                ReturnType: `0x${(...)}`[] | RpcLog[];
            }, {
                Method: "eth_getFilterLogs";
                Parameters: [filterId: `0x${string}`];
                ReturnType: RpcLog[];
            }, {
                Method: "eth_uninstallFilter";
                Parameters: [filterId: `0x${string}`];
                ReturnType: boolean;
            }]>;
            type: "transaction";
        }>);
        estimateContractGas: (<chain, const abi, functionName, args>(args) => Promise<bigint>);
        estimateFeesPerGas: (<chainOverride, type>(args?) => Promise<EstimateFeesPerGasReturnType<type>>);
        estimateGas: ((args) => Promise<bigint>);
        estimateMaxPriorityFeePerGas: (<chainOverride>(args?) => Promise<bigint>);
        extend: (<const client>(fn) => Client<Transport, undefined | Chain, undefined, PublicRpcSchema, {
            [K in string | number | symbol]: client[K]
        } & PublicActions<Transport, undefined | Chain>>);
        getBalance: ((args) => Promise<bigint>);
        getBlobBaseFee: (() => Promise<bigint>);
        getBlock: (<includeTransactions, blockTag>(args?) => Promise<{
            baseFeePerGas: null | bigint;
            blobGasUsed: bigint;
            difficulty: bigint;
            excessBlobGas: bigint;
            extraData: `0x${string}`;
            gasLimit: bigint;
            gasUsed: bigint;
            hash: blockTag extends "pending"
                ? null
                : `0x${string}`;
            logsBloom: blockTag extends "pending"
                ? null
                : `0x${string}`;
            miner: `0x${string}`;
            mixHash: `0x${string}`;
            nonce: blockTag extends "pending"
                ? null
                : `0x${string}`;
            number: blockTag extends "pending"
                ? null
                : bigint;
            parentHash: `0x${string}`;
            receiptsRoot: `0x${string}`;
            sealFields: `0x${string}`[];
            sha3Uncles: `0x${string}`;
            size: bigint;
            stateRoot: `0x${string}`;
            timestamp: bigint;
            totalDifficulty: null | bigint;
            transactions: includeTransactions extends true
                ? ({
                    accessList?: undefined;
                    authorizationList?: undefined;
                    blobVersionedHashes?: undefined;
                    blockHash: ((...) extends (...)
                            ? (...)
                            : (...)) extends true
                        ? null
                        : `0x${(...)}`;
                    blockNumber: ((...) extends (...)
                            ? (...)
                            : (...)) extends true
                        ? null
                        : bigint;
                    chainId?: number;
                    from: `0x${string}`;
                    gas: bigint;
                    gasPrice: bigint;
                    hash: `0x${string}`;
                    input: `0x${string}`;
                    maxFeePerBlobGas?: undefined;
                    maxFeePerGas?: undefined;
                    maxPriorityFeePerGas?: undefined;
                    nonce: number;
                    r: `0x${string}`;
                    s: `0x${string}`;
                    to: null | `0x${(...)}`;
                    transactionIndex: ((...) extends (...)
                            ? (...)
                            : (...)) extends true
                        ? null
                        : number;
                    type: "legacy";
                    typeHex: null | `0x${(...)}`;
                    v: bigint;
                    value: bigint;
                    yParity?: undefined;
                } | {
                    accessList: AccessList;
                    authorizationList?: undefined;
                    blobVersionedHashes?: undefined;
                    blockHash: ((...) extends (...)
                            ? (...)
                            : (...)) extends true
                        ? null
                        : `0x${(...)}`;
                    blockNumber: ((...) extends (...)
                            ? (...)
                            : (...)) extends true
                        ? null
                        : bigint;
                    chainId: number;
                    from: `0x${string}`;
                    gas: bigint;
                    gasPrice: bigint;
                    hash: `0x${string}`;
                    input: `0x${string}`;
                    maxFeePerBlobGas?: undefined;
                    maxFeePerGas?: undefined;
                    maxPriorityFeePerGas?: undefined;
                    nonce: number;
                    r: `0x${string}`;
                    s: `0x${string}`;
                    to: null | `0x${(...)}`;
                    transactionIndex: ((...) extends (...)
                            ? (...)
                            : (...)) extends true
                        ? null
                        : number;
                    type: "eip2930";
                    typeHex: null | `0x${(...)}`;
                    v: bigint;
                    value: bigint;
                    yParity: number;
                } | {
                    accessList: AccessList;
                    authorizationList?: undefined;
                    blobVersionedHashes?: undefined;
                    blockHash: ((...) extends (...)
                            ? (...)
                            : (...)) extends true
                        ? null
                        : `0x${(...)}`;
                    blockNumber: ((...) extends (...)
                            ? (...)
                            : (...)) extends true
                        ? null
                        : bigint;
                    chainId: number;
                    from: `0x${string}`;
                    gas: bigint;
                    gasPrice?: undefined;
                    hash: `0x${string}`;
                    input: `0x${string}`;
                    maxFeePerBlobGas?: undefined;
                    maxFeePerGas: bigint;
                    maxPriorityFeePerGas: bigint;
                    nonce: number;
                    r: `0x${string}`;
                    s: `0x${string}`;
                    to: null | `0x${(...)}`;
                    transactionIndex: ((...) extends (...)
                            ? (...)
                            : (...)) extends true
                        ? null
                        : number;
                    type: "eip1559";
                    typeHex: null | `0x${(...)}`;
                    v: bigint;
                    value: bigint;
                    yParity: number;
                } | {
                    accessList: AccessList;
                    authorizationList?: undefined;
                    blobVersionedHashes: readonly `0x${(...)}`[];
                    blockHash: ((...) extends (...)
                            ? (...)
                            : (...)) extends true
                        ? null
                        : `0x${(...)}`;
                    blockNumber: ((...) extends (...)
                            ? (...)
                            : (...)) extends true
                        ? null
                        : bigint;
                    chainId: number;
                    from: `0x${string}`;
                    gas: bigint;
                    gasPrice?: undefined;
                    hash: `0x${string}`;
                    input: `0x${string}`;
                    maxFeePerBlobGas: bigint;
                    maxFeePerGas: bigint;
                    maxPriorityFeePerGas: bigint;
                    nonce: number;
                    r: `0x${string}`;
                    s: `0x${string}`;
                    to: null | `0x${(...)}`;
                    transactionIndex: ((...) extends (...)
                            ? (...)
                            : (...)) extends true
                        ? null
                        : number;
                    type: "eip4844";
                    typeHex: null | `0x${(...)}`;
                    v: bigint;
                    value: bigint;
                    yParity: number;
                } | {
                    accessList: AccessList;
                    authorizationList: SignedAuthorizationList;
                    blobVersionedHashes?: undefined;
                    blockHash: ((...) extends (...)
                            ? (...)
                            : (...)) extends true
                        ? null
                        : `0x${(...)}`;
                    blockNumber: ((...) extends (...)
                            ? (...)
                            : (...)) extends true
                        ? null
                        : bigint;
                    chainId: number;
                    from: `0x${string}`;
                    gas: bigint;
                    gasPrice?: undefined;
                    hash: `0x${string}`;
                    input: `0x${string}`;
                    maxFeePerBlobGas?: undefined;
                    maxFeePerGas: bigint;
                    maxPriorityFeePerGas: bigint;
                    nonce: number;
                    r: `0x${string}`;
                    s: `0x${string}`;
                    to: null | `0x${(...)}`;
                    transactionIndex: ((...) extends (...)
                            ? (...)
                            : (...)) extends true
                        ? null
                        : number;
                    type: "eip7702";
                    typeHex: null | `0x${(...)}`;
                    v: bigint;
                    value: bigint;
                    yParity: number;
                })[]
                : `0x${string}`[];
            transactionsRoot: `0x${string}`;
            uncles: `0x${string}`[];
            withdrawals?: Withdrawal[];
            withdrawalsRoot?: `0x${string}`;
        }>);
        getBlockNumber: ((args?) => Promise<bigint>);
        getBlockTransactionCount: ((args?) => Promise<number>);
        getBytecode: ((args) => Promise<GetCodeReturnType>);
        getChainId: (() => Promise<number>);
        getCode: ((args) => Promise<GetCodeReturnType>);
        getContractEvents: (<const abi, eventName, strict, fromBlock, toBlock>(args) => Promise<GetContractEventsReturnType<abi, eventName, strict, fromBlock, toBlock>>);
        getEip712Domain: ((args) => Promise<GetEip712DomainReturnType>);
        getEnsAddress: ((args) => Promise<GetEnsAddressReturnType>);
        getEnsAvatar: ((args) => Promise<GetEnsAvatarReturnType>);
        getEnsName: ((args) => Promise<GetEnsNameReturnType>);
        getEnsResolver: ((args) => Promise<`0x${string}`>);
        getEnsText: ((args) => Promise<GetEnsTextReturnType>);
        getFeeHistory: ((args) => Promise<GetFeeHistoryReturnType>);
        getFilterChanges: (<filterType, const abi, eventName, strict, fromBlock, toBlock>(args) => Promise<GetFilterChangesReturnType<filterType, abi, eventName, strict, fromBlock, toBlock>>);
        getFilterLogs: (<const abi, eventName, strict, fromBlock, toBlock>(args) => Promise<GetFilterLogsReturnType<abi, eventName, strict, fromBlock, toBlock>>);
        getGasPrice: (() => Promise<bigint>);
        getLogs: (<const abiEvent, const abiEvents, strict, fromBlock, toBlock>(args?) => Promise<GetLogsReturnType<abiEvent, abiEvents, strict, fromBlock, toBlock>>);
        getProof: ((args) => Promise<GetProofReturnType>);
        getStorageAt: ((args) => Promise<GetStorageAtReturnType>);
        getTransaction: (<blockTag>(args) => Promise<{
            accessList?: undefined;
            authorizationList?: undefined;
            blobVersionedHashes?: undefined;
            blockHash: (blockTag extends "pending"
                    ? true
                    : false) extends true
                ? null
                : `0x${string}`;
            blockNumber: (blockTag extends "pending"
                    ? true
                    : false) extends true
                ? null
                : bigint;
            chainId?: number;
            from: `0x${string}`;
            gas: bigint;
            gasPrice: bigint;
            hash: `0x${string}`;
            input: `0x${string}`;
            maxFeePerBlobGas?: undefined;
            maxFeePerGas?: undefined;
            maxPriorityFeePerGas?: undefined;
            nonce: number;
            r: `0x${string}`;
            s: `0x${string}`;
            to: null | `0x${string}`;
            transactionIndex: (blockTag extends "pending"
                    ? true
                    : false) extends true
                ? null
                : number;
            type: "legacy";
            typeHex: null | `0x${string}`;
            v: bigint;
            value: bigint;
            yParity?: undefined;
        } | {
            accessList: AccessList;
            authorizationList?: undefined;
            blobVersionedHashes?: undefined;
            blockHash: (blockTag extends "pending"
                    ? true
                    : false) extends true
                ? null
                : `0x${string}`;
            blockNumber: (blockTag extends "pending"
                    ? true
                    : false) extends true
                ? null
                : bigint;
            chainId: number;
            from: `0x${string}`;
            gas: bigint;
            gasPrice: bigint;
            hash: `0x${string}`;
            input: `0x${string}`;
            maxFeePerBlobGas?: undefined;
            maxFeePerGas?: undefined;
            maxPriorityFeePerGas?: undefined;
            nonce: number;
            r: `0x${string}`;
            s: `0x${string}`;
            to: null | `0x${string}`;
            transactionIndex: (blockTag extends "pending"
                    ? true
                    : false) extends true
                ? null
                : number;
            type: "eip2930";
            typeHex: null | `0x${string}`;
            v: bigint;
            value: bigint;
            yParity: number;
        } | {
            accessList: AccessList;
            authorizationList?: undefined;
            blobVersionedHashes?: undefined;
            blockHash: (blockTag extends "pending"
                    ? true
                    : false) extends true
                ? null
                : `0x${string}`;
            blockNumber: (blockTag extends "pending"
                    ? true
                    : false) extends true
                ? null
                : bigint;
            chainId: number;
            from: `0x${string}`;
            gas: bigint;
            gasPrice?: undefined;
            hash: `0x${string}`;
            input: `0x${string}`;
            maxFeePerBlobGas?: undefined;
            maxFeePerGas: bigint;
            maxPriorityFeePerGas: bigint;
            nonce: number;
            r: `0x${string}`;
            s: `0x${string}`;
            to: null | `0x${string}`;
            transactionIndex: (blockTag extends "pending"
                    ? true
                    : false) extends true
                ? null
                : number;
            type: "eip1559";
            typeHex: null | `0x${string}`;
            v: bigint;
            value: bigint;
            yParity: number;
        } | {
            accessList: AccessList;
            authorizationList?: undefined;
            blobVersionedHashes: readonly `0x${string}`[];
            blockHash: (blockTag extends "pending"
                    ? true
                    : false) extends true
                ? null
                : `0x${string}`;
            blockNumber: (blockTag extends "pending"
                    ? true
                    : false) extends true
                ? null
                : bigint;
            chainId: number;
            from: `0x${string}`;
            gas: bigint;
            gasPrice?: undefined;
            hash: `0x${string}`;
            input: `0x${string}`;
            maxFeePerBlobGas: bigint;
            maxFeePerGas: bigint;
            maxPriorityFeePerGas: bigint;
            nonce: number;
            r: `0x${string}`;
            s: `0x${string}`;
            to: null | `0x${string}`;
            transactionIndex: (blockTag extends "pending"
                    ? true
                    : false) extends true
                ? null
                : number;
            type: "eip4844";
            typeHex: null | `0x${string}`;
            v: bigint;
            value: bigint;
            yParity: number;
        } | {
            accessList: AccessList;
            authorizationList: SignedAuthorizationList;
            blobVersionedHashes?: undefined;
            blockHash: (blockTag extends "pending"
                    ? true
                    : false) extends true
                ? null
                : `0x${string}`;
            blockNumber: (blockTag extends "pending"
                    ? true
                    : false) extends true
                ? null
                : bigint;
            chainId: number;
            from: `0x${string}`;
            gas: bigint;
            gasPrice?: undefined;
            hash: `0x${string}`;
            input: `0x${string}`;
            maxFeePerBlobGas?: undefined;
            maxFeePerGas: bigint;
            maxPriorityFeePerGas: bigint;
            nonce: number;
            r: `0x${string}`;
            s: `0x${string}`;
            to: null | `0x${string}`;
            transactionIndex: (blockTag extends "pending"
                    ? true
                    : false) extends true
                ? null
                : number;
            type: "eip7702";
            typeHex: null | `0x${string}`;
            v: bigint;
            value: bigint;
            yParity: number;
        }>);
        getTransactionConfirmations: ((args) => Promise<bigint>);
        getTransactionCount: ((args) => Promise<number>);
        getTransactionReceipt: ((args) => Promise<TransactionReceipt>);
        key: string;
        multicall: (<const contracts, allowFailure>(args) => Promise<MulticallReturnType<contracts, allowFailure>>);
        name: string;
        pollingInterval: number;
        prepareTransactionRequest: (<const request, chainOverride, accountOverride>(args) => Promise<{
            [K in string | number | symbol]: (UnionRequiredBy<Extract<(...) & (...) & (...), (...) extends (...)
                ? (...)
                : (...)> & {
                chainId?: (...) | (...);
            }, ParameterTypeToParameters<(...)[(...)] extends readonly (...)[]
                ? (...)[(...)]
                : (...) | (...) | (...) | (...) | (...) | (...)>> & (unknown extends request["kzg"]
                ? {}
                : Pick<request, "kzg">))[K]
        }>);
        readContract: (<const abi, functionName, args>(args) => Promise<ReadContractReturnType<abi, functionName, args>>);
        request: EIP1193RequestFn<PublicRpcSchema>;
        sendRawTransaction: ((args) => Promise<`0x${string}`>);
        simulateContract: (<const abi, functionName, args, chainOverride, accountOverride>(args) => Promise<SimulateContractReturnType<abi, functionName, args, undefined | Chain, undefined | Account, chainOverride, accountOverride>>);
        transport: TransportConfig<string, EIP1193RequestFn> & Record<string, any>;
        type: string;
        uid: string;
        uninstallFilter: ((args) => Promise<boolean>);
        verifyMessage: ((args) => Promise<boolean>);
        verifySiweMessage: ((args) => Promise<boolean>);
        verifyTypedData: ((args) => Promise<boolean>);
        waitForTransactionReceipt: ((args) => Promise<TransactionReceipt>);
        watchBlockNumber: ((args) => WatchBlockNumberReturnType);
        watchBlocks: (<includeTransactions, blockTag>(args) => WatchBlocksReturnType);
        watchContractEvent: (<const abi, eventName, strict>(args) => WatchContractEventReturnType);
        watchEvent: (<const abiEvent, const abiEvents, strict>(args) => WatchEventReturnType);
        watchPendingTransactions: ((args) => WatchPendingTransactionsReturnType);
    }

    • account: undefined

      The Account of the Client.

    • Optional batch?: {
          multicall?: boolean | {
              batchSize?: number;
              wait?: number;
          };
      }

      Flags for batch settings.

      • Optional multicall?: boolean | {
            batchSize?: number;
            wait?: number;
        }

        Toggle to enable eth_call multicall aggregation.

    • cacheTime: number

      Time (in ms) that cached data will remain in memory.

    • call: ((parameters) => Promise<CallReturnType>)

      Executes a new message call immediately without submitting a transaction to the network.

      • Docs: https://viem.sh/docs/actions/public/call
      • JSON-RPC Methods: eth_call

      Returns

      The call data. CallReturnType

      Example

      import { createPublicClient, http } from 'viem'
      import { mainnet } from 'viem/chains'
      
      const client = createPublicClient({
        chain: mainnet,
        transport: http(),
      })
      const data = await client.call({
        account: '0xf39fd6e51aad88f6f4ce6ab8827279cfffb92266',
        data: '0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2',
        to: '0x70997970c51812dc3a010c7d01b50e0d17dc79c8',
      })
      Copy

      • • (parameters): Promise<CallReturnType>

        • Parameters

          • parameters: CallParameters<undefined | Chain>

          Returns Promise<CallReturnType>

    • Optional ccipRead?: false | {
          request?: ((parameters) => Promise<`0x${string}`>);
      }

      CCIP Read configuration.

    • chain: undefined | Chain

      Chain for the client.

    • createBlockFilter: (() => Promise<{
          id: `0x${string}`;
          request: EIP1193RequestFn<readonly [{
              Method: "eth_getFilterChanges";
              Parameters: [filterId: `0x${string}`];
              ReturnType: `0x${(...)}`[] | RpcLog[];
          }, {
              Method: "eth_getFilterLogs";
              Parameters: [filterId: `0x${string}`];
              ReturnType: RpcLog[];
          }, {
              Method: "eth_uninstallFilter";
              Parameters: [filterId: `0x${string}`];
              ReturnType: boolean;
          }]>;
          type: "block";
      }>)

      Creates a Filter to listen for new block hashes that can be used with getFilterChanges.

      • Docs: https://viem.sh/docs/actions/public/createBlockFilter
      • JSON-RPC Methods: eth_newBlockFilter

      Returns

      Filter. CreateBlockFilterReturnType

      Example

      import { createPublicClient, createBlockFilter, http } from 'viem'
      import { mainnet } from 'viem/chains'
      
      const client = createPublicClient({
        chain: mainnet,
        transport: http(),
      })
      const filter = await createBlockFilter(client)
      // { id: "0x345a6572337856574a76364e457a4366", type: 'block' }
      Copy

      • • (): Promise<{
              id: `0x${string}`;
              request: EIP1193RequestFn<readonly [{
                  Method: "eth_getFilterChanges";
                  Parameters: [filterId: `0x${string}`];
                  ReturnType: `0x${(...)}`[] | RpcLog[];
              }, {
                  Method: "eth_getFilterLogs";
                  Parameters: [filterId: `0x${string}`];
                  ReturnType: RpcLog[];
              }, {
                  Method: "eth_uninstallFilter";
                  Parameters: [filterId: `0x${string}`];
                  ReturnType: boolean;
              }]>;
              type: "block";
          }>

        • Returns Promise<{
              id: `0x${string}`;
              request: EIP1193RequestFn<readonly [{
                  Method: "eth_getFilterChanges";
                  Parameters: [filterId: `0x${string}`];
                  ReturnType: `0x${(...)}`[] | RpcLog[];
              }, {
                  Method: "eth_getFilterLogs";
                  Parameters: [filterId: `0x${string}`];
                  ReturnType: RpcLog[];
              }, {
                  Method: "eth_uninstallFilter";
                  Parameters: [filterId: `0x${string}`];
                  ReturnType: boolean;
              }]>;
              type: "block";
          }>

    • createContractEventFilter: (<const abi, eventName, args, strict, fromBlock, toBlock>(args) => Promise<CreateContractEventFilterReturnType<abi, eventName, args, strict, fromBlock, toBlock>>)

      Creates a Filter to retrieve event logs that can be used with getFilterChanges or getFilterLogs.

      • Docs: https://viem.sh/docs/contract/createContractEventFilter

      Returns

      Filter. CreateContractEventFilterReturnType

      Example

      import { createPublicClient, http, parseAbi } from 'viem'
      import { mainnet } from 'viem/chains'
      
      const client = createPublicClient({
        chain: mainnet,
        transport: http(),
      })
      const filter = await client.createContractEventFilter({
        abi: parseAbi(['event Transfer(address indexed, address indexed, uint256)']),
      })
      Copy

      • • <const abi, eventName, args, strict, fromBlock, toBlock>(args): Promise<CreateContractEventFilterReturnType<abi, eventName, args, strict, fromBlock, toBlock>>

        • Type Parameters

          • const abi extends Abi | readonly unknown[]
          • eventName extends undefined | string
          • args extends undefined | Record<string, unknown> | readonly unknown[]
          • strict extends undefined | boolean = undefined
          • fromBlock extends undefined | bigint | BlockTag = undefined
          • toBlock extends undefined | bigint | BlockTag = undefined

          Parameters

          • args: CreateContractEventFilterParameters<abi, eventName, args, strict, fromBlock, toBlock>

            CreateContractEventFilterParameters

          Returns Promise<CreateContractEventFilterReturnType<abi, eventName, args, strict, fromBlock, toBlock>>

    • createEventFilter: (<const abiEvent, const abiEvents, strict, fromBlock, toBlock, _EventName, _Args>(args?) => Promise<{
          [K in string | number | symbol]: Filter<"event", abiEvents, _EventName, _Args, strict, fromBlock, toBlock>[K]
      }>)

      Creates a Filter to listen for new events that can be used with getFilterChanges.

      • Docs: https://viem.sh/docs/actions/public/createEventFilter
      • JSON-RPC Methods: eth_newFilter

      Returns

      Filter. CreateEventFilterReturnType

      Example

      import { createPublicClient, http } from 'viem'
      import { mainnet } from 'viem/chains'
      
      const client = createPublicClient({
        chain: mainnet,
        transport: http(),
      })
      const filter = await client.createEventFilter({
        address: '0xfba3912ca04dd458c843e2ee08967fc04f3579c2',
      })
      Copy

      • • <const abiEvent, const abiEvents, strict, fromBlock, toBlock, _EventName, _Args>(args?): Promise<{
              [K in string | number | symbol]: Filter<"event", abiEvents, _EventName, _Args, strict, fromBlock, toBlock>[K]
          }>

        • Type Parameters

          • const abiEvent extends undefined | AbiEvent = undefined
          • const abiEvents extends undefined | readonly unknown[] | readonly AbiEvent[] = abiEvent extends AbiEvent
                ? [abiEvent<abiEvent>]
                : undefined
          • strict extends undefined | boolean = undefined
          • fromBlock extends undefined | bigint | BlockTag = undefined
          • toBlock extends undefined | bigint | BlockTag = undefined
          • _EventName extends undefined | string = MaybeAbiEventName<abiEvent>
          • _Args extends undefined | Record<string, unknown> | readonly unknown[] = undefined

          Parameters

          • Optional args: CreateEventFilterParameters<abiEvent, abiEvents, strict, fromBlock, toBlock, _EventName, _Args>

            CreateEventFilterParameters

          Returns Promise<{
              [K in string | number | symbol]: Filter<"event", abiEvents, _EventName, _Args, strict, fromBlock, toBlock>[K]
          }>

    • createPendingTransactionFilter: (() => Promise<{
          id: `0x${string}`;
          request: EIP1193RequestFn<readonly [{
              Method: "eth_getFilterChanges";
              Parameters: [filterId: `0x${string}`];
              ReturnType: `0x${(...)}`[] | RpcLog[];
          }, {
              Method: "eth_getFilterLogs";
              Parameters: [filterId: `0x${string}`];
              ReturnType: RpcLog[];
          }, {
              Method: "eth_uninstallFilter";
              Parameters: [filterId: `0x${string}`];
              ReturnType: boolean;
          }]>;
          type: "transaction";
      }>)

      Creates a Filter to listen for new pending transaction hashes that can be used with getFilterChanges.

      • Docs: https://viem.sh/docs/actions/public/createPendingTransactionFilter
      • JSON-RPC Methods: eth_newPendingTransactionFilter

      Returns

      Filter. CreateBlockFilterReturnType

      Example

      import { createPublicClient, http } from 'viem'
      import { mainnet } from 'viem/chains'
      
      const client = createPublicClient({
        chain: mainnet,
        transport: http(),
      })
      const filter = await client.createPendingTransactionFilter()
      // { id: "0x345a6572337856574a76364e457a4366", type: 'transaction' }
      Copy

      • • (): Promise<{
              id: `0x${string}`;
              request: EIP1193RequestFn<readonly [{
                  Method: "eth_getFilterChanges";
                  Parameters: [filterId: `0x${string}`];
                  ReturnType: `0x${(...)}`[] | RpcLog[];
              }, {
                  Method: "eth_getFilterLogs";
                  Parameters: [filterId: `0x${string}`];
                  ReturnType: RpcLog[];
              }, {
                  Method: "eth_uninstallFilter";
                  Parameters: [filterId: `0x${string}`];
                  ReturnType: boolean;
              }]>;
              type: "transaction";
          }>

        • Returns Promise<{
              id: `0x${string}`;
              request: EIP1193RequestFn<readonly [{
                  Method: "eth_getFilterChanges";
                  Parameters: [filterId: `0x${string}`];
                  ReturnType: `0x${(...)}`[] | RpcLog[];
              }, {
                  Method: "eth_getFilterLogs";
                  Parameters: [filterId: `0x${string}`];
                  ReturnType: RpcLog[];
              }, {
                  Method: "eth_uninstallFilter";
                  Parameters: [filterId: `0x${string}`];
                  ReturnType: boolean;
              }]>;
              type: "transaction";
          }>

    • estimateContractGas: (<chain, const abi, functionName, args>(args) => Promise<bigint>)

      Estimates the gas required to successfully execute a contract write function call.

      • Docs: https://viem.sh/docs/contract/estimateContractGas

      Remarks

      Internally, uses a Public Client to call the estimateGas action with ABI-encoded data.

      Returns

      The gas estimate (in wei). EstimateContractGasReturnType

      Example

      import { createPublicClient, http, parseAbi } from 'viem'
      import { mainnet } from 'viem/chains'
      
      const client = createPublicClient({
        chain: mainnet,
        transport: http(),
      })
      const gas = await client.estimateContractGas({
        address: '0xFBA3912Ca04dd458c843e2EE08967fC04f3579c2',
        abi: parseAbi(['function mint() public']),
        functionName: 'mint',
        account: '0xf39fd6e51aad88f6f4ce6ab8827279cfffb92266',
      })
      Copy

      • • <chain, const abi, functionName, args>(args): Promise<bigint>

        • Type Parameters

          • chain extends undefined | Chain
          • const abi extends Abi | readonly unknown[]
          • functionName extends string
          • args extends unknown

          Parameters

          • args: EstimateContractGasParameters<abi, functionName, args, chain>

            EstimateContractGasParameters

          Returns Promise<bigint>

    • estimateFeesPerGas: (<chainOverride, type>(args?) => Promise<EstimateFeesPerGasReturnType<type>>)

      Returns an estimate for the fees per gas for a transaction to be included in the next block.

      • Docs: https://viem.sh/docs/actions/public/estimateFeesPerGas

      Returns

      An estimate (in wei) for the fees per gas. EstimateFeesPerGasReturnType

      Example

      import { createPublicClient, http } from 'viem'
      import { mainnet } from 'viem/chains'
      
      const client = createPublicClient({
        chain: mainnet,
        transport: http(),
      })
      const maxPriorityFeePerGas = await client.estimateFeesPerGas()
      // { maxFeePerGas: ..., maxPriorityFeePerGas: ... }
      Copy

      • • <chainOverride, type>(args?): Promise<EstimateFeesPerGasReturnType<type>>

        • Type Parameters

          • chainOverride extends undefined | Chain = undefined
          • type extends FeeValuesType = "eip1559"

          Parameters

          • Optional args: EstimateFeesPerGasParameters<undefined | Chain, chainOverride, type>

          Returns Promise<EstimateFeesPerGasReturnType<type>>

    • estimateGas: ((args) => Promise<bigint>)

      Estimates the gas necessary to complete a transaction without submitting it to the network.

      • Docs: https://viem.sh/docs/actions/public/estimateGas
      • JSON-RPC Methods: eth_estimateGas

      Returns

      The gas estimate (in wei). EstimateGasReturnType

      Example

      import { createPublicClient, http, parseEther } from 'viem'
      import { mainnet } from 'viem/chains'
      
      const client = createPublicClient({
        chain: mainnet,
        transport: http(),
      })
      const gasEstimate = await client.estimateGas({
        account: '0xA0Cf798816D4b9b9866b5330EEa46a18382f251e',
        to: '0x70997970c51812dc3a010c7d01b50e0d17dc79c8',
        value: parseEther('1'),
      })
      Copy

      • • (args): Promise<bigint>

        • Parameters

          • args: EstimateGasParameters<undefined | Chain>

            EstimateGasParameters

          Returns Promise<bigint>

    • estimateMaxPriorityFeePerGas: (<chainOverride>(args?) => Promise<bigint>)

      Returns an estimate for the max priority fee per gas (in wei) for a transaction to be included in the next block.

      • Docs: https://viem.sh/docs/actions/public/estimateMaxPriorityFeePerGas

      Returns

      An estimate (in wei) for the max priority fee per gas. EstimateMaxPriorityFeePerGasReturnType

      Example

      import { createPublicClient, http } from 'viem'
      import { mainnet } from 'viem/chains'
      
      const client = createPublicClient({
        chain: mainnet,
        transport: http(),
      })
      const maxPriorityFeePerGas = await client.estimateMaxPriorityFeePerGas()
      // 10000000n
      Copy

      • • <chainOverride>(args?): Promise<bigint>

        • Type Parameters

          • chainOverride extends undefined | Chain = undefined

          Parameters

          • Optional args: {
                chain: null | chainOverride;
            }

            • chain: null | chainOverride

          Returns Promise<bigint>

    • extend: (<const client>(fn) => Client<Transport, undefined | Chain, undefined, PublicRpcSchema, {
          [K in string | number | symbol]: client[K]
      } & PublicActions<Transport, undefined | Chain>>)

      • • <const client>(fn): Client<Transport, undefined | Chain, undefined, PublicRpcSchema, {
              [K in string | number | symbol]: client[K]
          } & PublicActions<Transport, undefined | Chain>>

        • Type Parameters

          • const client extends {
                account?: undefined;
                batch?: undefined;
                cacheTime?: undefined;
                ccipRead?: undefined;
                chain?: undefined;
                key?: undefined;
                name?: undefined;
                pollingInterval?: undefined;
                request?: undefined;
                transport?: undefined;
                type?: undefined;
                uid?: undefined;
            } & ExactPartial<ExtendableProtectedActions<Transport, undefined | Chain, undefined>>

          Parameters

          • fn: ((client) => client)
            • • (client): client

              • Parameters

                • client: Client<Transport, undefined | Chain, undefined, PublicRpcSchema, PublicActions<Transport, undefined | Chain>>

                Returns client

          Returns Client<Transport, undefined | Chain, undefined, PublicRpcSchema, {
              [K in string | number | symbol]: client[K]
          } & PublicActions<Transport, undefined | Chain>>

    • getBalance: ((args) => Promise<bigint>)

      Returns the balance of an address in wei.

      • Docs: https://viem.sh/docs/actions/public/getBalance
      • JSON-RPC Methods: eth_getBalance

      Remarks

      You can convert the balance to ether units with formatEther.

      const balance = await getBalance(client, {
        address: '0xA0Cf798816D4b9b9866b5330EEa46a18382f251e',
        blockTag: 'safe'
      })
      const balanceAsEther = formatEther(balance)
      // "6.942"
      Copy

      Returns

      The balance of the address in wei. GetBalanceReturnType

      Example

      import { createPublicClient, http } from 'viem'
      import { mainnet } from 'viem/chains'
      
      const client = createPublicClient({
        chain: mainnet,
        transport: http(),
      })
      const balance = await client.getBalance({
        address: '0xA0Cf798816D4b9b9866b5330EEa46a18382f251e',
      })
      // 10000000000000000000000n (wei)
      Copy

      • • (args): Promise<bigint>

        • Parameters

          • args: GetBalanceParameters

            GetBalanceParameters

          Returns Promise<bigint>

    • getBlobBaseFee: (() => Promise<bigint>)

      Returns the base fee per blob gas in wei.

      • Docs: https://viem.sh/docs/actions/public/getBlobBaseFee
      • JSON-RPC Methods: eth_blobBaseFee

      Returns

      The blob base fee (in wei). GetBlobBaseFeeReturnType

      Example

      import { createPublicClient, http } from 'viem'
      import { mainnet } from 'viem/chains'
      import { getBlobBaseFee } from 'viem/public'
      
      const client = createPublicClient({
        chain: mainnet,
        transport: http(),
      })
      const blobBaseFee = await client.getBlobBaseFee()
      Copy

      • • (): Promise<bigint>

        • Returns Promise<bigint>

    • getBlock: (<includeTransactions, blockTag>(args?) => Promise<{
          baseFeePerGas: null | bigint;
          blobGasUsed: bigint;
          difficulty: bigint;
          excessBlobGas: bigint;
          extraData: `0x${string}`;
          gasLimit: bigint;
          gasUsed: bigint;
          hash: blockTag extends "pending"
              ? null
              : `0x${string}`;
          logsBloom: blockTag extends "pending"
              ? null
              : `0x${string}`;
          miner: `0x${string}`;
          mixHash: `0x${string}`;
          nonce: blockTag extends "pending"
              ? null
              : `0x${string}`;
          number: blockTag extends "pending"
              ? null
              : bigint;
          parentHash: `0x${string}`;
          receiptsRoot: `0x${string}`;
          sealFields: `0x${string}`[];
          sha3Uncles: `0x${string}`;
          size: bigint;
          stateRoot: `0x${string}`;
          timestamp: bigint;
          totalDifficulty: null | bigint;
          transactions: includeTransactions extends true
              ? ({
                  accessList?: undefined;
                  authorizationList?: undefined;
                  blobVersionedHashes?: undefined;
                  blockHash: ((...) extends (...)
                          ? (...)
                          : (...)) extends true
                      ? null
                      : `0x${(...)}`;
                  blockNumber: ((...) extends (...)
                          ? (...)
                          : (...)) extends true
                      ? null
                      : bigint;
                  chainId?: number;
                  from: `0x${string}`;
                  gas: bigint;
                  gasPrice: bigint;
                  hash: `0x${string}`;
                  input: `0x${string}`;
                  maxFeePerBlobGas?: undefined;
                  maxFeePerGas?: undefined;
                  maxPriorityFeePerGas?: undefined;
                  nonce: number;
                  r: `0x${string}`;
                  s: `0x${string}`;
                  to: null | `0x${(...)}`;
                  transactionIndex: ((...) extends (...)
                          ? (...)
                          : (...)) extends true
                      ? null
                      : number;
                  type: "legacy";
                  typeHex: null | `0x${(...)}`;
                  v: bigint;
                  value: bigint;
                  yParity?: undefined;
              } | {
                  accessList: AccessList;
                  authorizationList?: undefined;
                  blobVersionedHashes?: undefined;
                  blockHash: ((...) extends (...)
                          ? (...)
                          : (...)) extends true
                      ? null
                      : `0x${(...)}`;
                  blockNumber: ((...) extends (...)
                          ? (...)
                          : (...)) extends true
                      ? null
                      : bigint;
                  chainId: number;
                  from: `0x${string}`;
                  gas: bigint;
                  gasPrice: bigint;
                  hash: `0x${string}`;
                  input: `0x${string}`;
                  maxFeePerBlobGas?: undefined;
                  maxFeePerGas?: undefined;
                  maxPriorityFeePerGas?: undefined;
                  nonce: number;
                  r: `0x${string}`;
                  s: `0x${string}`;
                  to: null | `0x${(...)}`;
                  transactionIndex: ((...) extends (...)
                          ? (...)
                          : (...)) extends true
                      ? null
                      : number;
                  type: "eip2930";
                  typeHex: null | `0x${(...)}`;
                  v: bigint;
                  value: bigint;
                  yParity: number;
              } | {
                  accessList: AccessList;
                  authorizationList?: undefined;
                  blobVersionedHashes?: undefined;
                  blockHash: ((...) extends (...)
                          ? (...)
                          : (...)) extends true
                      ? null
                      : `0x${(...)}`;
                  blockNumber: ((...) extends (...)
                          ? (...)
                          : (...)) extends true
                      ? null
                      : bigint;
                  chainId: number;
                  from: `0x${string}`;
                  gas: bigint;
                  gasPrice?: undefined;
                  hash: `0x${string}`;
                  input: `0x${string}`;
                  maxFeePerBlobGas?: undefined;
                  maxFeePerGas: bigint;
                  maxPriorityFeePerGas: bigint;
                  nonce: number;
                  r: `0x${string}`;
                  s: `0x${string}`;
                  to: null | `0x${(...)}`;
                  transactionIndex: ((...) extends (...)
                          ? (...)
                          : (...)) extends true
                      ? null
                      : number;
                  type: "eip1559";
                  typeHex: null | `0x${(...)}`;
                  v: bigint;
                  value: bigint;
                  yParity: number;
              } | {
                  accessList: AccessList;
                  authorizationList?: undefined;
                  blobVersionedHashes: readonly `0x${(...)}`[];
                  blockHash: ((...) extends (...)
                          ? (...)
                          : (...)) extends true
                      ? null
                      : `0x${(...)}`;
                  blockNumber: ((...) extends (...)
                          ? (...)
                          : (...)) extends true
                      ? null
                      : bigint;
                  chainId: number;
                  from: `0x${string}`;
                  gas: bigint;
                  gasPrice?: undefined;
                  hash: `0x${string}`;
                  input: `0x${string}`;
                  maxFeePerBlobGas: bigint;
                  maxFeePerGas: bigint;
                  maxPriorityFeePerGas: bigint;
                  nonce: number;
                  r: `0x${string}`;
                  s: `0x${string}`;
                  to: null | `0x${(...)}`;
                  transactionIndex: ((...) extends (...)
                          ? (...)
                          : (...)) extends true
                      ? null
                      : number;
                  type: "eip4844";
                  typeHex: null | `0x${(...)}`;
                  v: bigint;
                  value: bigint;
                  yParity: number;
              } | {
                  accessList: AccessList;
                  authorizationList: SignedAuthorizationList;
                  blobVersionedHashes?: undefined;
                  blockHash: ((...) extends (...)
                          ? (...)
                          : (...)) extends true
                      ? null
                      : `0x${(...)}`;
                  blockNumber: ((...) extends (...)
                          ? (...)
                          : (...)) extends true
                      ? null
                      : bigint;
                  chainId: number;
                  from: `0x${string}`;
                  gas: bigint;
                  gasPrice?: undefined;
                  hash: `0x${string}`;
                  input: `0x${string}`;
                  maxFeePerBlobGas?: undefined;
                  maxFeePerGas: bigint;
                  maxPriorityFeePerGas: bigint;
                  nonce: number;
                  r: `0x${string}`;
                  s: `0x${string}`;
                  to: null | `0x${(...)}`;
                  transactionIndex: ((...) extends (...)
                          ? (...)
                          : (...)) extends true
                      ? null
                      : number;
                  type: "eip7702";
                  typeHex: null | `0x${(...)}`;
                  v: bigint;
                  value: bigint;
                  yParity: number;
              })[]
              : `0x${string}`[];
          transactionsRoot: `0x${string}`;
          uncles: `0x${string}`[];
          withdrawals?: Withdrawal[];
          withdrawalsRoot?: `0x${string}`;
      }>)

      Returns information about a block at a block number, hash, or tag.

      • Docs: https://viem.sh/docs/actions/public/getBlock
      • Examples: https://stackblitz.com/github/wevm/viem/tree/main/examples/blocks/fetching-blocks
      • JSON-RPC Methods:
        • Calls eth_getBlockByNumber for blockNumber & blockTag.
        • Calls eth_getBlockByHash for blockHash.

      Returns

      Information about the block. GetBlockReturnType

      Example

      import { createPublicClient, http } from 'viem'
      import { mainnet } from 'viem/chains'
      
      const client = createPublicClient({
        chain: mainnet,
        transport: http(),
      })
      const block = await client.getBlock()
      Copy

      • • <includeTransactions, blockTag>(args?): Promise<{
              baseFeePerGas: null | bigint;
              blobGasUsed: bigint;
              difficulty: bigint;
              excessBlobGas: bigint;
              extraData: `0x${string}`;
              gasLimit: bigint;
              gasUsed: bigint;
              hash: blockTag extends "pending"
                  ? null
                  : `0x${string}`;
              logsBloom: blockTag extends "pending"
                  ? null
                  : `0x${string}`;
              miner: `0x${string}`;
              mixHash: `0x${string}`;
              nonce: blockTag extends "pending"
                  ? null
                  : `0x${string}`;
              number: blockTag extends "pending"
                  ? null
                  : bigint;
              parentHash: `0x${string}`;
              receiptsRoot: `0x${string}`;
              sealFields: `0x${string}`[];
              sha3Uncles: `0x${string}`;
              size: bigint;
              stateRoot: `0x${string}`;
              timestamp: bigint;
              totalDifficulty: null | bigint;
              transactions: includeTransactions extends true
                  ? ({
                      accessList?: undefined;
                      authorizationList?: undefined;
                      blobVersionedHashes?: undefined;
                      blockHash: ((...) extends (...)
                              ? (...)
                              : (...)) extends true
                          ? null
                          : `0x${(...)}`;
                      blockNumber: ((...) extends (...)
                              ? (...)
                              : (...)) extends true
                          ? null
                          : bigint;
                      chainId?: number;
                      from: `0x${string}`;
                      gas: bigint;
                      gasPrice: bigint;
                      hash: `0x${string}`;
                      input: `0x${string}`;
                      maxFeePerBlobGas?: undefined;
                      maxFeePerGas?: undefined;
                      maxPriorityFeePerGas?: undefined;
                      nonce: number;
                      r: `0x${string}`;
                      s: `0x${string}`;
                      to: null | `0x${(...)}`;
                      transactionIndex: ((...) extends (...)
                              ? (...)
                              : (...)) extends true
                          ? null
                          : number;
                      type: "legacy";
                      typeHex: null | `0x${(...)}`;
                      v: bigint;
                      value: bigint;
                      yParity?: undefined;
                  } | {
                      accessList: AccessList;
                      authorizationList?: undefined;
                      blobVersionedHashes?: undefined;
                      blockHash: ((...) extends (...)
                              ? (...)
                              : (...)) extends true
                          ? null
                          : `0x${(...)}`;
                      blockNumber: ((...) extends (...)
                              ? (...)
                              : (...)) extends true
                          ? null
                          : bigint;
                      chainId: number;
                      from: `0x${string}`;
                      gas: bigint;
                      gasPrice: bigint;
                      hash: `0x${string}`;
                      input: `0x${string}`;
                      maxFeePerBlobGas?: undefined;
                      maxFeePerGas?: undefined;
                      maxPriorityFeePerGas?: undefined;
                      nonce: number;
                      r: `0x${string}`;
                      s: `0x${string}`;
                      to: null | `0x${(...)}`;
                      transactionIndex: ((...) extends (...)
                              ? (...)
                              : (...)) extends true
                          ? null
                          : number;
                      type: "eip2930";
                      typeHex: null | `0x${(...)}`;
                      v: bigint;
                      value: bigint;
                      yParity: number;
                  } | {
                      accessList: AccessList;
                      authorizationList?: undefined;
                      blobVersionedHashes?: undefined;
                      blockHash: ((...) extends (...)
                              ? (...)
                              : (...)) extends true
                          ? null
                          : `0x${(...)}`;
                      blockNumber: ((...) extends (...)
                              ? (...)
                              : (...)) extends true
                          ? null
                          : bigint;
                      chainId: number;
                      from: `0x${string}`;
                      gas: bigint;
                      gasPrice?: undefined;
                      hash: `0x${string}`;
                      input: `0x${string}`;
                      maxFeePerBlobGas?: undefined;
                      maxFeePerGas: bigint;
                      maxPriorityFeePerGas: bigint;
                      nonce: number;
                      r: `0x${string}`;
                      s: `0x${string}`;
                      to: null | `0x${(...)}`;
                      transactionIndex: ((...) extends (...)
                              ? (...)
                              : (...)) extends true
                          ? null
                          : number;
                      type: "eip1559";
                      typeHex: null | `0x${(...)}`;
                      v: bigint;
                      value: bigint;
                      yParity: number;
                  } | {
                      accessList: AccessList;
                      authorizationList?: undefined;
                      blobVersionedHashes: readonly `0x${(...)}`[];
                      blockHash: ((...) extends (...)
                              ? (...)
                              : (...)) extends true
                          ? null
                          : `0x${(...)}`;
                      blockNumber: ((...) extends (...)
                              ? (...)
                              : (...)) extends true
                          ? null
                          : bigint;
                      chainId: number;
                      from: `0x${string}`;
                      gas: bigint;
                      gasPrice?: undefined;
                      hash: `0x${string}`;
                      input: `0x${string}`;
                      maxFeePerBlobGas: bigint;
                      maxFeePerGas: bigint;
                      maxPriorityFeePerGas: bigint;
                      nonce: number;
                      r: `0x${string}`;
                      s: `0x${string}`;
                      to: null | `0x${(...)}`;
                      transactionIndex: ((...) extends (...)
                              ? (...)
                              : (...)) extends true
                          ? null
                          : number;
                      type: "eip4844";
                      typeHex: null | `0x${(...)}`;
                      v: bigint;
                      value: bigint;
                      yParity: number;
                  } | {
                      accessList: AccessList;
                      authorizationList: SignedAuthorizationList;
                      blobVersionedHashes?: undefined;
                      blockHash: ((...) extends (...)
                              ? (...)
                              : (...)) extends true
                          ? null
                          : `0x${(...)}`;
                      blockNumber: ((...) extends (...)
                              ? (...)
                              : (...)) extends true
                          ? null
                          : bigint;
                      chainId: number;
                      from: `0x${string}`;
                      gas: bigint;
                      gasPrice?: undefined;
                      hash: `0x${string}`;
                      input: `0x${string}`;
                      maxFeePerBlobGas?: undefined;
                      maxFeePerGas: bigint;
                      maxPriorityFeePerGas: bigint;
                      nonce: number;
                      r: `0x${string}`;
                      s: `0x${string}`;
                      to: null | `0x${(...)}`;
                      transactionIndex: ((...) extends (...)
                              ? (...)
                              : (...)) extends true
                          ? null
                          : number;
                      type: "eip7702";
                      typeHex: null | `0x${(...)}`;
                      v: bigint;
                      value: bigint;
                      yParity: number;
                  })[]
                  : `0x${string}`[];
              transactionsRoot: `0x${string}`;
              uncles: `0x${string}`[];
              withdrawals?: Withdrawal[];
              withdrawalsRoot?: `0x${string}`;
          }>

        • Type Parameters

          • includeTransactions extends boolean = false
          • blockTag extends BlockTag = "latest"

          Parameters

          • Optional args: GetBlockParameters<includeTransactions, blockTag>

            GetBlockParameters

          Returns Promise<{
              baseFeePerGas: null | bigint;
              blobGasUsed: bigint;
              difficulty: bigint;
              excessBlobGas: bigint;
              extraData: `0x${string}`;
              gasLimit: bigint;
              gasUsed: bigint;
              hash: blockTag extends "pending"
                  ? null
                  : `0x${string}`;
              logsBloom: blockTag extends "pending"
                  ? null
                  : `0x${string}`;
              miner: `0x${string}`;
              mixHash: `0x${string}`;
              nonce: blockTag extends "pending"
                  ? null
                  : `0x${string}`;
              number: blockTag extends "pending"
                  ? null
                  : bigint;
              parentHash: `0x${string}`;
              receiptsRoot: `0x${string}`;
              sealFields: `0x${string}`[];
              sha3Uncles: `0x${string}`;
              size: bigint;
              stateRoot: `0x${string}`;
              timestamp: bigint;
              totalDifficulty: null | bigint;
              transactions: includeTransactions extends true
                  ? ({
                      accessList?: undefined;
                      authorizationList?: undefined;
                      blobVersionedHashes?: undefined;
                      blockHash: ((...) extends (...)
                              ? (...)
                              : (...)) extends true
                          ? null
                          : `0x${(...)}`;
                      blockNumber: ((...) extends (...)
                              ? (...)
                              : (...)) extends true
                          ? null
                          : bigint;
                      chainId?: number;
                      from: `0x${string}`;
                      gas: bigint;
                      gasPrice: bigint;
                      hash: `0x${string}`;
                      input: `0x${string}`;
                      maxFeePerBlobGas?: undefined;
                      maxFeePerGas?: undefined;
                      maxPriorityFeePerGas?: undefined;
                      nonce: number;
                      r: `0x${string}`;
                      s: `0x${string}`;
                      to: null | `0x${(...)}`;
                      transactionIndex: ((...) extends (...)
                              ? (...)
                              : (...)) extends true
                          ? null
                          : number;
                      type: "legacy";
                      typeHex: null | `0x${(...)}`;
                      v: bigint;
                      value: bigint;
                      yParity?: undefined;
                  } | {
                      accessList: AccessList;
                      authorizationList?: undefined;
                      blobVersionedHashes?: undefined;
                      blockHash: ((...) extends (...)
                              ? (...)
                              : (...)) extends true
                          ? null
                          : `0x${(...)}`;
                      blockNumber: ((...) extends (...)
                              ? (...)
                              : (...)) extends true
                          ? null
                          : bigint;
                      chainId: number;
                      from: `0x${string}`;
                      gas: bigint;
                      gasPrice: bigint;
                      hash: `0x${string}`;
                      input: `0x${string}`;
                      maxFeePerBlobGas?: undefined;
                      maxFeePerGas?: undefined;
                      maxPriorityFeePerGas?: undefined;
                      nonce: number;
                      r: `0x${string}`;
                      s: `0x${string}`;
                      to: null | `0x${(...)}`;
                      transactionIndex: ((...) extends (...)
                              ? (...)
                              : (...)) extends true
                          ? null
                          : number;
                      type: "eip2930";
                      typeHex: null | `0x${(...)}`;
                      v: bigint;
                      value: bigint;
                      yParity: number;
                  } | {
                      accessList: AccessList;
                      authorizationList?: undefined;
                      blobVersionedHashes?: undefined;
                      blockHash: ((...) extends (...)
                              ? (...)
                              : (...)) extends true
                          ? null
                          : `0x${(...)}`;
                      blockNumber: ((...) extends (...)
                              ? (...)
                              : (...)) extends true
                          ? null
                          : bigint;
                      chainId: number;
                      from: `0x${string}`;
                      gas: bigint;
                      gasPrice?: undefined;
                      hash: `0x${string}`;
                      input: `0x${string}`;
                      maxFeePerBlobGas?: undefined;
                      maxFeePerGas: bigint;
                      maxPriorityFeePerGas: bigint;
                      nonce: number;
                      r: `0x${string}`;
                      s: `0x${string}`;
                      to: null | `0x${(...)}`;
                      transactionIndex: ((...) extends (...)
                              ? (...)
                              : (...)) extends true
                          ? null
                          : number;
                      type: "eip1559";
                      typeHex: null | `0x${(...)}`;
                      v: bigint;
                      value: bigint;
                      yParity: number;
                  } | {
                      accessList: AccessList;
                      authorizationList?: undefined;
                      blobVersionedHashes: readonly `0x${(...)}`[];
                      blockHash: ((...) extends (...)
                              ? (...)
                              : (...)) extends true
                          ? null
                          : `0x${(...)}`;
                      blockNumber: ((...) extends (...)
                              ? (...)
                              : (...)) extends true
                          ? null
                          : bigint;
                      chainId: number;
                      from: `0x${string}`;
                      gas: bigint;
                      gasPrice?: undefined;
                      hash: `0x${string}`;
                      input: `0x${string}`;
                      maxFeePerBlobGas: bigint;
                      maxFeePerGas: bigint;
                      maxPriorityFeePerGas: bigint;
                      nonce: number;
                      r: `0x${string}`;
                      s: `0x${string}`;
                      to: null | `0x${(...)}`;
                      transactionIndex: ((...) extends (...)
                              ? (...)
                              : (...)) extends true
                          ? null
                          : number;
                      type: "eip4844";
                      typeHex: null | `0x${(...)}`;
                      v: bigint;
                      value: bigint;
                      yParity: number;
                  } | {
                      accessList: AccessList;
                      authorizationList: SignedAuthorizationList;
                      blobVersionedHashes?: undefined;
                      blockHash: ((...) extends (...)
                              ? (...)
                              : (...)) extends true
                          ? null
                          : `0x${(...)}`;
                      blockNumber: ((...) extends (...)
                              ? (...)
                              : (...)) extends true
                          ? null
                          : bigint;
                      chainId: number;
                      from: `0x${string}`;
                      gas: bigint;
                      gasPrice?: undefined;
                      hash: `0x${string}`;
                      input: `0x${string}`;
                      maxFeePerBlobGas?: undefined;
                      maxFeePerGas: bigint;
                      maxPriorityFeePerGas: bigint;
                      nonce: number;
                      r: `0x${string}`;
                      s: `0x${string}`;
                      to: null | `0x${(...)}`;
                      transactionIndex: ((...) extends (...)
                              ? (...)
                              : (...)) extends true
                          ? null
                          : number;
                      type: "eip7702";
                      typeHex: null | `0x${(...)}`;
                      v: bigint;
                      value: bigint;
                      yParity: number;
                  })[]
                  : `0x${string}`[];
              transactionsRoot: `0x${string}`;
              uncles: `0x${string}`[];
              withdrawals?: Withdrawal[];
              withdrawalsRoot?: `0x${string}`;
          }>

    • getBlockNumber: ((args?) => Promise<bigint>)

      Returns the number of the most recent block seen.

      • Docs: https://viem.sh/docs/actions/public/getBlockNumber
      • Examples: https://stackblitz.com/github/wevm/viem/tree/main/examples/blocks/fetching-blocks
      • JSON-RPC Methods: eth_blockNumber

      Returns

      The number of the block. GetBlockNumberReturnType

      Example

      import { createPublicClient, http } from 'viem'
      import { mainnet } from 'viem/chains'
      
      const client = createPublicClient({
        chain: mainnet,
        transport: http(),
      })
      const blockNumber = await client.getBlockNumber()
      // 69420n
      Copy

      • • (args?): Promise<bigint>

        • Parameters

          • Optional args: GetBlockNumberParameters

            GetBlockNumberParameters

          Returns Promise<bigint>

    • getBlockTransactionCount: ((args?) => Promise<number>)

      Returns the number of Transactions at a block number, hash, or tag.

      • Docs: https://viem.sh/docs/actions/public/getBlockTransactionCount
      • JSON-RPC Methods:
        • Calls eth_getBlockTransactionCountByNumber for blockNumber & blockTag.
        • Calls eth_getBlockTransactionCountByHash for blockHash.

      Returns

      The block transaction count. GetBlockTransactionCountReturnType

      Example

      import { createPublicClient, http } from 'viem'
      import { mainnet } from 'viem/chains'
      
      const client = createPublicClient({
        chain: mainnet,
        transport: http(),
      })
      const count = await client.getBlockTransactionCount()
      Copy

      • • (args?): Promise<number>

        • Parameters

          • Optional args: GetBlockTransactionCountParameters

            GetBlockTransactionCountParameters

          Returns Promise<number>

    • getBytecode: ((args) => Promise<GetCodeReturnType>)

      Deprecated

      Use getCode instead.

      • • (args): Promise<GetCodeReturnType>

        • Parameters

          • args: GetCodeParameters

          Returns Promise<GetCodeReturnType>

    • getChainId: (() => Promise<number>)

      Returns the chain ID associated with the current network.

      • Docs: https://viem.sh/docs/actions/public/getChainId
      • JSON-RPC Methods: eth_chainId

      Returns

      The current chain ID. GetChainIdReturnType

      Example

      import { createPublicClient, http } from 'viem'
      import { mainnet } from 'viem/chains'
      
      const client = createPublicClient({
        chain: mainnet,
        transport: http(),
      })
      const chainId = await client.getChainId()
      // 1
      Copy

      • • (): Promise<number>

        • Returns Promise<number>

    • getCode: ((args) => Promise<GetCodeReturnType>)

      Retrieves the bytecode at an address.

      • Docs: https://viem.sh/docs/contract/getCode
      • JSON-RPC Methods: eth_getCode

      Returns

      The contract's bytecode. GetBytecodeReturnType

      Example

      import { createPublicClient, http } from 'viem'
      import { mainnet } from 'viem/chains'
      
      const client = createPublicClient({
        chain: mainnet,
        transport: http(),
      })
      const code = await client.getCode({
        address: '0xFBA3912Ca04dd458c843e2EE08967fC04f3579c2',
      })
      Copy

      • • (args): Promise<GetCodeReturnType>

        • Parameters

          • args: GetCodeParameters

            GetBytecodeParameters

          Returns Promise<GetCodeReturnType>

    • getContractEvents: (<const abi, eventName, strict, fromBlock, toBlock>(args) => Promise<GetContractEventsReturnType<abi, eventName, strict, fromBlock, toBlock>>)

      Returns a list of event logs emitted by a contract.

      • Docs: https://viem.sh/docs/actions/public/getContractEvents
      • JSON-RPC Methods: eth_getLogs

      Returns

      A list of event logs. GetContractEventsReturnType

      Example

      import { createPublicClient, http } from 'viem'
      import { mainnet } from 'viem/chains'
      import { wagmiAbi } from './abi'
      
      const client = createPublicClient({
        chain: mainnet,
        transport: http(),
      })
      const logs = await client.getContractEvents(client, {
       address: '0xFBA3912Ca04dd458c843e2EE08967fC04f3579c2',
       abi: wagmiAbi,
       eventName: 'Transfer'
      })
      Copy

      • • <const abi, eventName, strict, fromBlock, toBlock>(args): Promise<GetContractEventsReturnType<abi, eventName, strict, fromBlock, toBlock>>

        • Type Parameters

          • const abi extends Abi | readonly unknown[]
          • eventName extends undefined | string = undefined
          • strict extends undefined | boolean = undefined
          • fromBlock extends undefined | bigint | BlockTag = undefined
          • toBlock extends undefined | bigint | BlockTag = undefined

          Parameters

          • args: GetContractEventsParameters<abi, eventName, strict, fromBlock, toBlock>

          Returns Promise<GetContractEventsReturnType<abi, eventName, strict, fromBlock, toBlock>>

    • getEip712Domain: ((args) => Promise<GetEip712DomainReturnType>)

      Reads the EIP-712 domain from a contract, based on the ERC-5267 specification.

      Returns

      The EIP-712 domain, fields, and extensions. GetEip712DomainReturnType

      Example

      import { createPublicClient, http } from 'viem'
      import { mainnet } from 'viem/chains'
      
      const client = createPublicClient({
        chain: mainnet,
        transport: http(),
      })
      
      const domain = await client.getEip712Domain({
        address: '0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48',
      })
      // {
      //   domain: {
      //     name: 'ExampleContract',
      //     version: '1',
      //     chainId: 1,
      //     verifyingContract: '0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48',
      //   },
      //   fields: '0x0f',
      //   extensions: [],
      // }
      Copy

      • • (args): Promise<GetEip712DomainReturnType>

        • Parameters

          • args: GetEip712DomainParameters

          Returns Promise<GetEip712DomainReturnType>

    • getEnsAddress: ((args) => Promise<GetEnsAddressReturnType>)

      Gets address for ENS name.

      • Docs: https://viem.sh/docs/ens/actions/getEnsAddress
      • Examples: https://stackblitz.com/github/wevm/viem/tree/main/examples/ens

      Remarks

      Calls resolve(bytes, bytes) on ENS Universal Resolver Contract.

      Since ENS names prohibit certain forbidden characters (e.g. underscore) and have other validation rules, you likely want to normalize ENS names with UTS-46 normalization before passing them to getEnsAddress. You can use the built-in normalize function for this.

      Returns

      Address for ENS name or null if not found. GetEnsAddressReturnType

      Example

      import { createPublicClient, http } from 'viem'
      import { mainnet } from 'viem/chains'
      import { normalize } from 'viem/ens'
      
      const client = createPublicClient({
        chain: mainnet,
        transport: http(),
      })
      const ensAddress = await client.getEnsAddress({
        name: normalize('wevm.eth'),
      })
      // '0xd2135CfB216b74109775236E36d4b433F1DF507B'
      Copy

      • • (args): Promise<GetEnsAddressReturnType>

        • Parameters

          • args: {
                blockNumber?: bigint;
                blockTag?: BlockTag;
                coinType?: number;
                gatewayUrls?: string[];
                name: string;
                strict?: boolean;
                universalResolverAddress?: `0x${string}`;
            }

            GetEnsAddressParameters

            • Optional blockNumber?: bigint

              The balance of the account at a block number.

            • Optional blockTag?: BlockTag

              The balance of the account at a block tag.

              Default

              'latest'
              Copy

            • Optional coinType?: number

              ENSIP-9 compliant coinType used to resolve addresses for other chains

            • Optional gatewayUrls?: string[]

              Universal Resolver gateway URLs to use for resolving CCIP-read requests.

            • name: string

              Name to get the address for.

            • Optional strict?: boolean

              Whether or not to throw errors propagated from the ENS Universal Resolver Contract.

            • Optional universalResolverAddress?: `0x${string}`

              Address of ENS Universal Resolver Contract.

          Returns Promise<GetEnsAddressReturnType>

    • getEnsAvatar: ((args) => Promise<GetEnsAvatarReturnType>)

      Gets the avatar of an ENS name.

      • Docs: https://viem.sh/docs/ens/actions/getEnsAvatar
      • Examples: https://stackblitz.com/github/wevm/viem/tree/main/examples/ens

      Remarks

      Calls getEnsText with key set to 'avatar'.

      Since ENS names prohibit certain forbidden characters (e.g. underscore) and have other validation rules, you likely want to normalize ENS names with UTS-46 normalization before passing them to getEnsAddress. You can use the built-in normalize function for this.

      Returns

      Avatar URI or null if not found. GetEnsAvatarReturnType

      Example

      import { createPublicClient, http } from 'viem'
      import { mainnet } from 'viem/chains'
      import { normalize } from 'viem/ens'
      
      const client = createPublicClient({
        chain: mainnet,
        transport: http(),
      })
      const ensAvatar = await client.getEnsAvatar({
        name: normalize('wevm.eth'),
      })
      // 'https://ipfs.io/ipfs/Qma8mnp6xV3J2cRNf3mTth5C8nV11CAnceVinc3y8jSbio'
      Copy

      • • (args): Promise<GetEnsAvatarReturnType>

        • Parameters

          • args: {
                assetGatewayUrls?: AssetGatewayUrls;
                blockNumber?: bigint;
                blockTag?: BlockTag;
                gatewayUrls?: string[];
                name: string;
                strict?: boolean;
                universalResolverAddress?: `0x${string}`;
            }

            GetEnsAvatarParameters

            • Optional assetGatewayUrls?: AssetGatewayUrls

              Gateway urls to resolve IPFS and/or Arweave assets.

            • Optional blockNumber?: bigint

              The balance of the account at a block number.

            • Optional blockTag?: BlockTag

              The balance of the account at a block tag.

              Default

              'latest'
              Copy

            • Optional gatewayUrls?: string[]

              Universal Resolver gateway URLs to use for resolving CCIP-read requests.

            • name: string

              ENS name to get Text for.

            • Optional strict?: boolean

              Whether or not to throw errors propagated from the ENS Universal Resolver Contract.

            • Optional universalResolverAddress?: `0x${string}`

              Address of ENS Universal Resolver Contract.

          Returns Promise<GetEnsAvatarReturnType>

    • getEnsName: ((args) => Promise<GetEnsNameReturnType>)

      Gets primary name for specified address.

      • Docs: https://viem.sh/docs/ens/actions/getEnsName
      • Examples: https://stackblitz.com/github/wevm/viem/tree/main/examples/ens

      Remarks

      Calls reverse(bytes) on ENS Universal Resolver Contract to "reverse resolve" the address to the primary ENS name.

      Returns

      Name or null if not found. GetEnsNameReturnType

      Example

      import { createPublicClient, http } from 'viem'
      import { mainnet } from 'viem/chains'
      
      const client = createPublicClient({
        chain: mainnet,
        transport: http(),
      })
      const ensName = await client.getEnsName({
        address: '0xd2135CfB216b74109775236E36d4b433F1DF507B',
      })
      // 'wevm.eth'
      Copy

      • • (args): Promise<GetEnsNameReturnType>

        • Parameters

          • args: {
                address: `0x${string}`;
                blockNumber?: bigint;
                blockTag?: BlockTag;
                gatewayUrls?: string[];
                strict?: boolean;
                universalResolverAddress?: `0x${string}`;
            }

            GetEnsNameParameters

            • address: `0x${string}`

              Address to get ENS name for.

            • Optional blockNumber?: bigint

              The balance of the account at a block number.

            • Optional blockTag?: BlockTag

              The balance of the account at a block tag.

              Default

              'latest'
              Copy

            • Optional gatewayUrls?: string[]

              Universal Resolver gateway URLs to use for resolving CCIP-read requests.

            • Optional strict?: boolean

              Whether or not to throw errors propagated from the ENS Universal Resolver Contract.

            • Optional universalResolverAddress?: `0x${string}`

              Address of ENS Universal Resolver Contract.

          Returns Promise<GetEnsNameReturnType>

    • getEnsResolver: ((args) => Promise<`0x${string}`>)

      Gets resolver for ENS name.

      • Docs: https://viem.sh/docs/ens/actions/getEnsResolver
      • Examples: https://stackblitz.com/github/wevm/viem/tree/main/examples/ens

      Remarks

      Calls findResolver(bytes) on ENS Universal Resolver Contract to retrieve the resolver of an ENS name.

      Since ENS names prohibit certain forbidden characters (e.g. underscore) and have other validation rules, you likely want to normalize ENS names with UTS-46 normalization before passing them to getEnsAddress. You can use the built-in normalize function for this.

      Returns

      Address for ENS resolver. GetEnsResolverReturnType

      Example

      import { createPublicClient, http } from 'viem'
      import { mainnet } from 'viem/chains'
      import { normalize } from 'viem/ens'
      
      const client = createPublicClient({
        chain: mainnet,
        transport: http(),
      })
      const resolverAddress = await client.getEnsResolver({
        name: normalize('wevm.eth'),
      })
      // '0x4976fb03C32e5B8cfe2b6cCB31c09Ba78EBaBa41'
      Copy

      • • (args): Promise<`0x${string}`>

        • Parameters

          • args: {
                blockNumber?: bigint;
                blockTag?: BlockTag;
                name: string;
                universalResolverAddress?: `0x${string}`;
            }

            GetEnsResolverParameters

            • Optional blockNumber?: bigint

              The balance of the account at a block number.

            • Optional blockTag?: BlockTag

              The balance of the account at a block tag.

              Default

              'latest'
              Copy

            • name: string

              Name to get the address for.

            • Optional universalResolverAddress?: `0x${string}`

              Address of ENS Universal Resolver Contract.

          Returns Promise<`0x${string}`>

    • getEnsText: ((args) => Promise<GetEnsTextReturnType>)

      Gets a text record for specified ENS name.

      • Docs: https://viem.sh/docs/ens/actions/getEnsResolver
      • Examples: https://stackblitz.com/github/wevm/viem/tree/main/examples/ens

      Remarks

      Calls resolve(bytes, bytes) on ENS Universal Resolver Contract.

      Since ENS names prohibit certain forbidden characters (e.g. underscore) and have other validation rules, you likely want to normalize ENS names with UTS-46 normalization before passing them to getEnsAddress. You can use the built-in normalize function for this.

      Returns

      Address for ENS resolver. GetEnsTextReturnType

      Example

      import { createPublicClient, http } from 'viem'
      import { mainnet } from 'viem/chains'
      import { normalize } from 'viem/ens'
      
      const client = createPublicClient({
        chain: mainnet,
        transport: http(),
      })
      const twitterRecord = await client.getEnsText({
        name: normalize('wevm.eth'),
        key: 'com.twitter',
      })
      // 'wevm_dev'
      Copy

      • • (args): Promise<GetEnsTextReturnType>

        • Parameters

          • args: {
                blockNumber?: bigint;
                blockTag?: BlockTag;
                gatewayUrls?: string[];
                key: string;
                name: string;
                strict?: boolean;
                universalResolverAddress?: `0x${string}`;
            }

            GetEnsTextParameters

            • Optional blockNumber?: bigint

              The balance of the account at a block number.

            • Optional blockTag?: BlockTag

              The balance of the account at a block tag.

              Default

              'latest'
              Copy

            • Optional gatewayUrls?: string[]

              Universal Resolver gateway URLs to use for resolving CCIP-read requests.

            • key: string

              Text record to retrieve.

            • name: string

              ENS name to get Text for.

            • Optional strict?: boolean

              Whether or not to throw errors propagated from the ENS Universal Resolver Contract.

            • Optional universalResolverAddress?: `0x${string}`

              Address of ENS Universal Resolver Contract.

          Returns Promise<GetEnsTextReturnType>

    • getFeeHistory: ((args) => Promise<GetFeeHistoryReturnType>)

      Returns a collection of historical gas information.

      • Docs: https://viem.sh/docs/actions/public/getFeeHistory
      • JSON-RPC Methods: eth_feeHistory

      Returns

      The gas estimate (in wei). GetFeeHistoryReturnType

      Example

      import { createPublicClient, http } from 'viem'
      import { mainnet } from 'viem/chains'
      
      const client = createPublicClient({
        chain: mainnet,
        transport: http(),
      })
      const feeHistory = await client.getFeeHistory({
        blockCount: 4,
        rewardPercentiles: [25, 75],
      })
      Copy

      • • (args): Promise<GetFeeHistoryReturnType>

        • Parameters

          • args: GetFeeHistoryParameters

            GetFeeHistoryParameters

          Returns Promise<GetFeeHistoryReturnType>

    • getFilterChanges: (<filterType, const abi, eventName, strict, fromBlock, toBlock>(args) => Promise<GetFilterChangesReturnType<filterType, abi, eventName, strict, fromBlock, toBlock>>)

      Returns a list of logs or hashes based on a Filter since the last time it was called.

      • Docs: https://viem.sh/docs/actions/public/getFilterChanges
      • JSON-RPC Methods: eth_getFilterChanges

      Remarks

      A Filter can be created from the following actions:

      • createBlockFilter
      • createContractEventFilter
      • createEventFilter
      • createPendingTransactionFilter

      Depending on the type of filter, the return value will be different:

      • If the filter was created with createContractEventFilter or createEventFilter, it returns a list of logs.
      • If the filter was created with createPendingTransactionFilter, it returns a list of transaction hashes.
      • If the filter was created with createBlockFilter, it returns a list of block hashes.

      Returns

      Logs or hashes. GetFilterChangesReturnType

      Example

      // Blocks
      import { createPublicClient, http } from 'viem'
      import { mainnet } from 'viem/chains'
      
      const client = createPublicClient({
        chain: mainnet,
        transport: http(),
      })
      const filter = await client.createBlockFilter()
      const hashes = await client.getFilterChanges({ filter })
      Copy

      Example

      // Contract Events
      import { createPublicClient, http, parseAbi } from 'viem'
      import { mainnet } from 'viem/chains'
      
      const client = createPublicClient({
        chain: mainnet,
        transport: http(),
      })
      const filter = await client.createContractEventFilter({
        address: '0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48',
        abi: parseAbi(['event Transfer(address indexed, address indexed, uint256)']),
        eventName: 'Transfer',
      })
      const logs = await client.getFilterChanges({ filter })
      Copy

      Example

      // Raw Events
      import { createPublicClient, http, parseAbiItem } from 'viem'
      import { mainnet } from 'viem/chains'
      
      const client = createPublicClient({
        chain: mainnet,
        transport: http(),
      })
      const filter = await client.createEventFilter({
        address: '0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48',
        event: parseAbiItem('event Transfer(address indexed, address indexed, uint256)'),
      })
      const logs = await client.getFilterChanges({ filter })
      Copy

      Example

      // Transactions
      import { createPublicClient, http } from 'viem'
      import { mainnet } from 'viem/chains'
      
      const client = createPublicClient({
        chain: mainnet,
        transport: http(),
      })
      const filter = await client.createPendingTransactionFilter()
      const hashes = await client.getFilterChanges({ filter })
      Copy

      • • <filterType, const abi, eventName, strict, fromBlock, toBlock>(args): Promise<GetFilterChangesReturnType<filterType, abi, eventName, strict, fromBlock, toBlock>>

        • Type Parameters

          • filterType extends FilterType
          • const abi extends undefined | Abi | readonly unknown[]
          • eventName extends undefined | string
          • strict extends undefined | boolean = undefined
          • fromBlock extends undefined | bigint | BlockTag = undefined
          • toBlock extends undefined | bigint | BlockTag = undefined

          Parameters

          • args: GetFilterChangesParameters<filterType, abi, eventName, strict, fromBlock, toBlock>

            GetFilterChangesParameters

          Returns Promise<GetFilterChangesReturnType<filterType, abi, eventName, strict, fromBlock, toBlock>>

    • getFilterLogs: (<const abi, eventName, strict, fromBlock, toBlock>(args) => Promise<GetFilterLogsReturnType<abi, eventName, strict, fromBlock, toBlock>>)

      Returns a list of event logs since the filter was created.

      • Docs: https://viem.sh/docs/actions/public/getFilterLogs
      • JSON-RPC Methods: eth_getFilterLogs

      Remarks

      getFilterLogs is only compatible with event filters.

      Returns

      A list of event logs. GetFilterLogsReturnType

      Example

      import { createPublicClient, http, parseAbiItem } from 'viem'
      import { mainnet } from 'viem/chains'
      
      const client = createPublicClient({
        chain: mainnet,
        transport: http(),
      })
      const filter = await client.createEventFilter({
        address: '0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48',
        event: parseAbiItem('event Transfer(address indexed, address indexed, uint256)'),
      })
      const logs = await client.getFilterLogs({ filter })
      Copy

      • • <const abi, eventName, strict, fromBlock, toBlock>(args): Promise<GetFilterLogsReturnType<abi, eventName, strict, fromBlock, toBlock>>

        • Type Parameters

          • const abi extends undefined | Abi | readonly unknown[]
          • eventName extends undefined | string
          • strict extends undefined | boolean = undefined
          • fromBlock extends undefined | bigint | BlockTag = undefined
          • toBlock extends undefined | bigint | BlockTag = undefined

          Parameters

          • args: GetFilterLogsParameters<abi, eventName, strict, fromBlock, toBlock>

            GetFilterLogsParameters

          Returns Promise<GetFilterLogsReturnType<abi, eventName, strict, fromBlock, toBlock>>

    • getGasPrice: (() => Promise<bigint>)

      Returns the current price of gas (in wei).

      • Docs: https://viem.sh/docs/actions/public/getGasPrice
      • JSON-RPC Methods: eth_gasPrice

      Returns

      The gas price (in wei). GetGasPriceReturnType

      Example

      import { createPublicClient, http } from 'viem'
      import { mainnet } from 'viem/chains'
      
      const client = createPublicClient({
        chain: mainnet,
        transport: http(),
      })
      const gasPrice = await client.getGasPrice()
      Copy

      • • (): Promise<bigint>

        • Returns Promise<bigint>

    • getLogs: (<const abiEvent, const abiEvents, strict, fromBlock, toBlock>(args?) => Promise<GetLogsReturnType<abiEvent, abiEvents, strict, fromBlock, toBlock>>)

      Returns a list of event logs matching the provided parameters.

      • Docs: https://viem.sh/docs/actions/public/getLogs
      • Examples: https://stackblitz.com/github/wevm/viem/tree/main/examples/filters-and-logs/event-logs
      • JSON-RPC Methods: eth_getLogs

      Returns

      A list of event logs. GetLogsReturnType

      Example

      import { createPublicClient, http, parseAbiItem } from 'viem'
      import { mainnet } from 'viem/chains'
      
      const client = createPublicClient({
        chain: mainnet,
        transport: http(),
      })
      const logs = await client.getLogs()
      Copy

      • • <const abiEvent, const abiEvents, strict, fromBlock, toBlock>(args?): Promise<GetLogsReturnType<abiEvent, abiEvents, strict, fromBlock, toBlock>>

        • Type Parameters

          • const abiEvent extends undefined | AbiEvent = undefined
          • const abiEvents extends undefined | readonly unknown[] | readonly AbiEvent[] = abiEvent extends AbiEvent
                ? [abiEvent<abiEvent>]
                : undefined
          • strict extends undefined | boolean = undefined
          • fromBlock extends undefined | bigint | BlockTag = undefined
          • toBlock extends undefined | bigint | BlockTag = undefined

          Parameters

          • Optional args: GetLogsParameters<abiEvent, abiEvents, strict, fromBlock, toBlock>

            GetLogsParameters

          Returns Promise<GetLogsReturnType<abiEvent, abiEvents, strict, fromBlock, toBlock>>

    • getProof: ((args) => Promise<GetProofReturnType>)

      Returns the account and storage values of the specified account including the Merkle-proof.

      • Docs: https://viem.sh/docs/actions/public/getProof
      • JSON-RPC Methods:
        • Calls eth_getProof

      Returns

      Proof data. GetProofReturnType

      Example

      import { createPublicClient, http } from 'viem'
      import { mainnet } from 'viem/chains'
      
      const client = createPublicClient({
        chain: mainnet,
        transport: http(),
      })
      const block = await client.getProof({
       address: '0x...',
       storageKeys: ['0x...'],
      })
      Copy

      • • (args): Promise<GetProofReturnType>

        • Parameters

          • args: GetProofParameters

          Returns Promise<GetProofReturnType>

    • getStorageAt: ((args) => Promise<GetStorageAtReturnType>)

      Returns the value from a storage slot at a given address.

      • Docs: https://viem.sh/docs/contract/getStorageAt
      • JSON-RPC Methods: eth_getStorageAt

      Returns

      The value of the storage slot. GetStorageAtReturnType

      Example

      import { createPublicClient, http } from 'viem'
      import { mainnet } from 'viem/chains'
      import { getStorageAt } from 'viem/contract'
      
      const client = createPublicClient({
        chain: mainnet,
        transport: http(),
      })
      const code = await client.getStorageAt({
        address: '0xFBA3912Ca04dd458c843e2EE08967fC04f3579c2',
        slot: toHex(0),
      })
      Copy

      • • (args): Promise<GetStorageAtReturnType>

        • Parameters

          • args: GetStorageAtParameters

            GetStorageAtParameters

          Returns Promise<GetStorageAtReturnType>

    • getTransaction: (<blockTag>(args) => Promise<{
          accessList?: undefined;
          authorizationList?: undefined;
          blobVersionedHashes?: undefined;
          blockHash: (blockTag extends "pending"
                  ? true
                  : false) extends true
              ? null
              : `0x${string}`;
          blockNumber: (blockTag extends "pending"
                  ? true
                  : false) extends true
              ? null
              : bigint;
          chainId?: number;
          from: `0x${string}`;
          gas: bigint;
          gasPrice: bigint;
          hash: `0x${string}`;
          input: `0x${string}`;
          maxFeePerBlobGas?: undefined;
          maxFeePerGas?: undefined;
          maxPriorityFeePerGas?: undefined;
          nonce: number;
          r: `0x${string}`;
          s: `0x${string}`;
          to: null | `0x${string}`;
          transactionIndex: (blockTag extends "pending"
                  ? true
                  : false) extends true
              ? null
              : number;
          type: "legacy";
          typeHex: null | `0x${string}`;
          v: bigint;
          value: bigint;
          yParity?: undefined;
      } | {
          accessList: AccessList;
          authorizationList?: undefined;
          blobVersionedHashes?: undefined;
          blockHash: (blockTag extends "pending"
                  ? true
                  : false) extends true
              ? null
              : `0x${string}`;
          blockNumber: (blockTag extends "pending"
                  ? true
                  : false) extends true
              ? null
              : bigint;
          chainId: number;
          from: `0x${string}`;
          gas: bigint;
          gasPrice: bigint;
          hash: `0x${string}`;
          input: `0x${string}`;
          maxFeePerBlobGas?: undefined;
          maxFeePerGas?: undefined;
          maxPriorityFeePerGas?: undefined;
          nonce: number;
          r: `0x${string}`;
          s: `0x${string}`;
          to: null | `0x${string}`;
          transactionIndex: (blockTag extends "pending"
                  ? true
                  : false) extends true
              ? null
              : number;
          type: "eip2930";
          typeHex: null | `0x${string}`;
          v: bigint;
          value: bigint;
          yParity: number;
      } | {
          accessList: AccessList;
          authorizationList?: undefined;
          blobVersionedHashes?: undefined;
          blockHash: (blockTag extends "pending"
                  ? true
                  : false) extends true
              ? null
              : `0x${string}`;
          blockNumber: (blockTag extends "pending"
                  ? true
                  : false) extends true
              ? null
              : bigint;
          chainId: number;
          from: `0x${string}`;
          gas: bigint;
          gasPrice?: undefined;
          hash: `0x${string}`;
          input: `0x${string}`;
          maxFeePerBlobGas?: undefined;
          maxFeePerGas: bigint;
          maxPriorityFeePerGas: bigint;
          nonce: number;
          r: `0x${string}`;
          s: `0x${string}`;
          to: null | `0x${string}`;
          transactionIndex: (blockTag extends "pending"
                  ? true
                  : false) extends true
              ? null
              : number;
          type: "eip1559";
          typeHex: null | `0x${string}`;
          v: bigint;
          value: bigint;
          yParity: number;
      } | {
          accessList: AccessList;
          authorizationList?: undefined;
          blobVersionedHashes: readonly `0x${string}`[];
          blockHash: (blockTag extends "pending"
                  ? true
                  : false) extends true
              ? null
              : `0x${string}`;
          blockNumber: (blockTag extends "pending"
                  ? true
                  : false) extends true
              ? null
              : bigint;
          chainId: number;
          from: `0x${string}`;
          gas: bigint;
          gasPrice?: undefined;
          hash: `0x${string}`;
          input: `0x${string}`;
          maxFeePerBlobGas: bigint;
          maxFeePerGas: bigint;
          maxPriorityFeePerGas: bigint;
          nonce: number;
          r: `0x${string}`;
          s: `0x${string}`;
          to: null | `0x${string}`;
          transactionIndex: (blockTag extends "pending"
                  ? true
                  : false) extends true
              ? null
              : number;
          type: "eip4844";
          typeHex: null | `0x${string}`;
          v: bigint;
          value: bigint;
          yParity: number;
      } | {
          accessList: AccessList;
          authorizationList: SignedAuthorizationList;
          blobVersionedHashes?: undefined;
          blockHash: (blockTag extends "pending"
                  ? true
                  : false) extends true
              ? null
              : `0x${string}`;
          blockNumber: (blockTag extends "pending"
                  ? true
                  : false) extends true
              ? null
              : bigint;
          chainId: number;
          from: `0x${string}`;
          gas: bigint;
          gasPrice?: undefined;
          hash: `0x${string}`;
          input: `0x${string}`;
          maxFeePerBlobGas?: undefined;
          maxFeePerGas: bigint;
          maxPriorityFeePerGas: bigint;
          nonce: number;
          r: `0x${string}`;
          s: `0x${string}`;
          to: null | `0x${string}`;
          transactionIndex: (blockTag extends "pending"
                  ? true
                  : false) extends true
              ? null
              : number;
          type: "eip7702";
          typeHex: null | `0x${string}`;
          v: bigint;
          value: bigint;
          yParity: number;
      }>)

      Returns information about a Transaction given a hash or block identifier.

      • Docs: https://viem.sh/docs/actions/public/getTransaction
      • Example: https://stackblitz.com/github/wevm/viem/tree/main/examples/transactions/fetching-transactions
      • JSON-RPC Methods: eth_getTransactionByHash

      Returns

      The transaction information. GetTransactionReturnType

      Example

      import { createPublicClient, http } from 'viem'
      import { mainnet } from 'viem/chains'
      
      const client = createPublicClient({
        chain: mainnet,
        transport: http(),
      })
      const transaction = await client.getTransaction({
        hash: '0x4ca7ee652d57678f26e887c149ab0735f41de37bcad58c9f6d3ed5824f15b74d',
      })
      Copy

      • • <blockTag>(args): Promise<{
              accessList?: undefined;
              authorizationList?: undefined;
              blobVersionedHashes?: undefined;
              blockHash: (blockTag extends "pending"
                      ? true
                      : false) extends true
                  ? null
                  : `0x${string}`;
              blockNumber: (blockTag extends "pending"
                      ? true
                      : false) extends true
                  ? null
                  : bigint;
              chainId?: number;
              from: `0x${string}`;
              gas: bigint;
              gasPrice: bigint;
              hash: `0x${string}`;
              input: `0x${string}`;
              maxFeePerBlobGas?: undefined;
              maxFeePerGas?: undefined;
              maxPriorityFeePerGas?: undefined;
              nonce: number;
              r: `0x${string}`;
              s: `0x${string}`;
              to: null | `0x${string}`;
              transactionIndex: (blockTag extends "pending"
                      ? true
                      : false) extends true
                  ? null
                  : number;
              type: "legacy";
              typeHex: null | `0x${string}`;
              v: bigint;
              value: bigint;
              yParity?: undefined;
          } | {
              accessList: AccessList;
              authorizationList?: undefined;
              blobVersionedHashes?: undefined;
              blockHash: (blockTag extends "pending"
                      ? true
                      : false) extends true
                  ? null
                  : `0x${string}`;
              blockNumber: (blockTag extends "pending"
                      ? true
                      : false) extends true
                  ? null
                  : bigint;
              chainId: number;
              from: `0x${string}`;
              gas: bigint;
              gasPrice: bigint;
              hash: `0x${string}`;
              input: `0x${string}`;
              maxFeePerBlobGas?: undefined;
              maxFeePerGas?: undefined;
              maxPriorityFeePerGas?: undefined;
              nonce: number;
              r: `0x${string}`;
              s: `0x${string}`;
              to: null | `0x${string}`;
              transactionIndex: (blockTag extends "pending"
                      ? true
                      : false) extends true
                  ? null
                  : number;
              type: "eip2930";
              typeHex: null | `0x${string}`;
              v: bigint;
              value: bigint;
              yParity: number;
          } | {
              accessList: AccessList;
              authorizationList?: undefined;
              blobVersionedHashes?: undefined;
              blockHash: (blockTag extends "pending"
                      ? true
                      : false) extends true
                  ? null
                  : `0x${string}`;
              blockNumber: (blockTag extends "pending"
                      ? true
                      : false) extends true
                  ? null
                  : bigint;
              chainId: number;
              from: `0x${string}`;
              gas: bigint;
              gasPrice?: undefined;
              hash: `0x${string}`;
              input: `0x${string}`;
              maxFeePerBlobGas?: undefined;
              maxFeePerGas: bigint;
              maxPriorityFeePerGas: bigint;
              nonce: number;
              r: `0x${string}`;
              s: `0x${string}`;
              to: null | `0x${string}`;
              transactionIndex: (blockTag extends "pending"
                      ? true
                      : false) extends true
                  ? null
                  : number;
              type: "eip1559";
              typeHex: null | `0x${string}`;
              v: bigint;
              value: bigint;
              yParity: number;
          } | {
              accessList: AccessList;
              authorizationList?: undefined;
              blobVersionedHashes: readonly `0x${string}`[];
              blockHash: (blockTag extends "pending"
                      ? true
                      : false) extends true
                  ? null
                  : `0x${string}`;
              blockNumber: (blockTag extends "pending"
                      ? true
                      : false) extends true
                  ? null
                  : bigint;
              chainId: number;
              from: `0x${string}`;
              gas: bigint;
              gasPrice?: undefined;
              hash: `0x${string}`;
              input: `0x${string}`;
              maxFeePerBlobGas: bigint;
              maxFeePerGas: bigint;
              maxPriorityFeePerGas: bigint;
              nonce: number;
              r: `0x${string}`;
              s: `0x${string}`;
              to: null | `0x${string}`;
              transactionIndex: (blockTag extends "pending"
                      ? true
                      : false) extends true
                  ? null
                  : number;
              type: "eip4844";
              typeHex: null | `0x${string}`;
              v: bigint;
              value: bigint;
              yParity: number;
          } | {
              accessList: AccessList;
              authorizationList: SignedAuthorizationList;
              blobVersionedHashes?: undefined;
              blockHash: (blockTag extends "pending"
                      ? true
                      : false) extends true
                  ? null
                  : `0x${string}`;
              blockNumber: (blockTag extends "pending"
                      ? true
                      : false) extends true
                  ? null
                  : bigint;
              chainId: number;
              from: `0x${string}`;
              gas: bigint;
              gasPrice?: undefined;
              hash: `0x${string}`;
              input: `0x${string}`;
              maxFeePerBlobGas?: undefined;
              maxFeePerGas: bigint;
              maxPriorityFeePerGas: bigint;
              nonce: number;
              r: `0x${string}`;
              s: `0x${string}`;
              to: null | `0x${string}`;
              transactionIndex: (blockTag extends "pending"
                      ? true
                      : false) extends true
                  ? null
                  : number;
              type: "eip7702";
              typeHex: null | `0x${string}`;
              v: bigint;
              value: bigint;
              yParity: number;
          }>

        • Type Parameters

          • blockTag extends BlockTag = "latest"

          Parameters

          • args: GetTransactionParameters<blockTag>

            GetTransactionParameters

          Returns Promise<{
              accessList?: undefined;
              authorizationList?: undefined;
              blobVersionedHashes?: undefined;
              blockHash: (blockTag extends "pending"
                      ? true
                      : false) extends true
                  ? null
                  : `0x${string}`;
              blockNumber: (blockTag extends "pending"
                      ? true
                      : false) extends true
                  ? null
                  : bigint;
              chainId?: number;
              from: `0x${string}`;
              gas: bigint;
              gasPrice: bigint;
              hash: `0x${string}`;
              input: `0x${string}`;
              maxFeePerBlobGas?: undefined;
              maxFeePerGas?: undefined;
              maxPriorityFeePerGas?: undefined;
              nonce: number;
              r: `0x${string}`;
              s: `0x${string}`;
              to: null | `0x${string}`;
              transactionIndex: (blockTag extends "pending"
                      ? true
                      : false) extends true
                  ? null
                  : number;
              type: "legacy";
              typeHex: null | `0x${string}`;
              v: bigint;
              value: bigint;
              yParity?: undefined;
          } | {
              accessList: AccessList;
              authorizationList?: undefined;
              blobVersionedHashes?: undefined;
              blockHash: (blockTag extends "pending"
                      ? true
                      : false) extends true
                  ? null
                  : `0x${string}`;
              blockNumber: (blockTag extends "pending"
                      ? true
                      : false) extends true
                  ? null
                  : bigint;
              chainId: number;
              from: `0x${string}`;
              gas: bigint;
              gasPrice: bigint;
              hash: `0x${string}`;
              input: `0x${string}`;
              maxFeePerBlobGas?: undefined;
              maxFeePerGas?: undefined;
              maxPriorityFeePerGas?: undefined;
              nonce: number;
              r: `0x${string}`;
              s: `0x${string}`;
              to: null | `0x${string}`;
              transactionIndex: (blockTag extends "pending"
                      ? true
                      : false) extends true
                  ? null
                  : number;
              type: "eip2930";
              typeHex: null | `0x${string}`;
              v: bigint;
              value: bigint;
              yParity: number;
          } | {
              accessList: AccessList;
              authorizationList?: undefined;
              blobVersionedHashes?: undefined;
              blockHash: (blockTag extends "pending"
                      ? true
                      : false) extends true
                  ? null
                  : `0x${string}`;
              blockNumber: (blockTag extends "pending"
                      ? true
                      : false) extends true
                  ? null
                  : bigint;
              chainId: number;
              from: `0x${string}`;
              gas: bigint;
              gasPrice?: undefined;
              hash: `0x${string}`;
              input: `0x${string}`;
              maxFeePerBlobGas?: undefined;
              maxFeePerGas: bigint;
              maxPriorityFeePerGas: bigint;
              nonce: number;
              r: `0x${string}`;
              s: `0x${string}`;
              to: null | `0x${string}`;
              transactionIndex: (blockTag extends "pending"
                      ? true
                      : false) extends true
                  ? null
                  : number;
              type: "eip1559";
              typeHex: null | `0x${string}`;
              v: bigint;
              value: bigint;
              yParity: number;
          } | {
              accessList: AccessList;
              authorizationList?: undefined;
              blobVersionedHashes: readonly `0x${string}`[];
              blockHash: (blockTag extends "pending"
                      ? true
                      : false) extends true
                  ? null
                  : `0x${string}`;
              blockNumber: (blockTag extends "pending"
                      ? true
                      : false) extends true
                  ? null
                  : bigint;
              chainId: number;
              from: `0x${string}`;
              gas: bigint;
              gasPrice?: undefined;
              hash: `0x${string}`;
              input: `0x${string}`;
              maxFeePerBlobGas: bigint;
              maxFeePerGas: bigint;
              maxPriorityFeePerGas: bigint;
              nonce: number;
              r: `0x${string}`;
              s: `0x${string}`;
              to: null | `0x${string}`;
              transactionIndex: (blockTag extends "pending"
                      ? true
                      : false) extends true
                  ? null
                  : number;
              type: "eip4844";
              typeHex: null | `0x${string}`;
              v: bigint;
              value: bigint;
              yParity: number;
          } | {
              accessList: AccessList;
              authorizationList: SignedAuthorizationList;
              blobVersionedHashes?: undefined;
              blockHash: (blockTag extends "pending"
                      ? true
                      : false) extends true
                  ? null
                  : `0x${string}`;
              blockNumber: (blockTag extends "pending"
                      ? true
                      : false) extends true
                  ? null
                  : bigint;
              chainId: number;
              from: `0x${string}`;
              gas: bigint;
              gasPrice?: undefined;
              hash: `0x${string}`;
              input: `0x${string}`;
              maxFeePerBlobGas?: undefined;
              maxFeePerGas: bigint;
              maxPriorityFeePerGas: bigint;
              nonce: number;
              r: `0x${string}`;
              s: `0x${string}`;
              to: null | `0x${string}`;
              transactionIndex: (blockTag extends "pending"
                      ? true
                      : false) extends true
                  ? null
                  : number;
              type: "eip7702";
              typeHex: null | `0x${string}`;
              v: bigint;
              value: bigint;
              yParity: number;
          }>

    • getTransactionConfirmations: ((args) => Promise<bigint>)

      Returns the number of blocks passed (confirmations) since the transaction was processed on a block.

      • Docs: https://viem.sh/docs/actions/public/getTransactionConfirmations
      • Example: https://stackblitz.com/github/wevm/viem/tree/main/examples/transactions/fetching-transactions
      • JSON-RPC Methods: eth_getTransactionConfirmations

      Returns

      The number of blocks passed since the transaction was processed. If confirmations is 0, then the Transaction has not been confirmed & processed yet. GetTransactionConfirmationsReturnType

      Example

      import { createPublicClient, http } from 'viem'
      import { mainnet } from 'viem/chains'
      
      const client = createPublicClient({
        chain: mainnet,
        transport: http(),
      })
      const confirmations = await client.getTransactionConfirmations({
        hash: '0x4ca7ee652d57678f26e887c149ab0735f41de37bcad58c9f6d3ed5824f15b74d',
      })
      Copy

      • • (args): Promise<bigint>

        • Parameters

          • args: GetTransactionConfirmationsParameters<undefined | Chain>

            GetTransactionConfirmationsParameters

          Returns Promise<bigint>

    • getTransactionCount: ((args) => Promise<number>)

      Returns the number of Transactions an Account has broadcast / sent.

      • Docs: https://viem.sh/docs/actions/public/getTransactionCount
      • JSON-RPC Methods: eth_getTransactionCount

      Returns

      The number of transactions an account has sent. GetTransactionCountReturnType

      Example

      import { createPublicClient, http } from 'viem'
      import { mainnet } from 'viem/chains'
      
      const client = createPublicClient({
        chain: mainnet,
        transport: http(),
      })
      const transactionCount = await client.getTransactionCount({
        address: '0xA0Cf798816D4b9b9866b5330EEa46a18382f251e',
      })
      Copy

      • • (args): Promise<number>

        • Parameters

          • args: GetTransactionCountParameters

            GetTransactionCountParameters

          Returns Promise<number>

    • getTransactionReceipt: ((args) => Promise<TransactionReceipt>)

      Returns the Transaction Receipt given a Transaction hash.

      • Docs: https://viem.sh/docs/actions/public/getTransactionReceipt
      • Example: https://stackblitz.com/github/wevm/viem/tree/main/examples/transactions/fetching-transactions
      • JSON-RPC Methods: eth_getTransactionReceipt

      Returns

      The transaction receipt. GetTransactionReceiptReturnType

      Example

      import { createPublicClient, http } from 'viem'
      import { mainnet } from 'viem/chains'
      
      const client = createPublicClient({
        chain: mainnet,
        transport: http(),
      })
      const transactionReceipt = await client.getTransactionReceipt({
        hash: '0x4ca7ee652d57678f26e887c149ab0735f41de37bcad58c9f6d3ed5824f15b74d',
      })
      Copy

      • • (args): Promise<TransactionReceipt>

        • Parameters

          • args: GetTransactionReceiptParameters

            GetTransactionReceiptParameters

          Returns Promise<TransactionReceipt>

    • key: string

      A key for the client.

    • multicall: (<const contracts, allowFailure>(args) => Promise<MulticallReturnType<contracts, allowFailure>>)

      Similar to readContract, but batches up multiple functions on a contract in a single RPC call via the multicall3 contract.

      • Docs: https://viem.sh/docs/contract/multicall

      Returns

      An array of results with accompanying status. MulticallReturnType

      Example

      import { createPublicClient, http, parseAbi } from 'viem'
      import { mainnet } from 'viem/chains'
      
      const client = createPublicClient({
        chain: mainnet,
        transport: http(),
      })
      const abi = parseAbi([
        'function balanceOf(address) view returns (uint256)',
        'function totalSupply() view returns (uint256)',
      ])
      const result = await client.multicall({
        contracts: [
          {
            address: '0xFBA3912Ca04dd458c843e2EE08967fC04f3579c2',
            abi,
            functionName: 'balanceOf',
            args: ['0xA0Cf798816D4b9b9866b5330EEa46a18382f251e'],
          },
          {
            address: '0xFBA3912Ca04dd458c843e2EE08967fC04f3579c2',
            abi,
            functionName: 'totalSupply',
          },
        ],
      })
      // [{ result: 424122n, status: 'success' }, { result: 1000000n, status: 'success' }]
      Copy

      • • <const contracts, allowFailure>(args): Promise<MulticallReturnType<contracts, allowFailure>>

        • Type Parameters

          • const contracts extends readonly unknown[]
          • allowFailure extends boolean = true

          Parameters

          • args: MulticallParameters<contracts, allowFailure>

            MulticallParameters

          Returns Promise<MulticallReturnType<contracts, allowFailure>>

    • name: string

      A name for the client.

    • pollingInterval: number

      Frequency (in ms) for polling enabled actions & events. Defaults to 4_000 milliseconds.

    • prepareTransactionRequest: (<const request, chainOverride, accountOverride>(args) => Promise<{
          [K in string | number | symbol]: (UnionRequiredBy<Extract<(...) & (...) & (...), (...) extends (...)
              ? (...)
              : (...)> & {
              chainId?: (...) | (...);
          }, ParameterTypeToParameters<(...)[(...)] extends readonly (...)[]
              ? (...)[(...)]
              : (...) | (...) | (...) | (...) | (...) | (...)>> & (unknown extends request["kzg"]
              ? {}
              : Pick<request, "kzg">))[K]
      }>)

      Prepares a transaction request for signing.

      • Docs: https://viem.sh/docs/actions/wallet/prepareTransactionRequest

      Returns

      The transaction request. PrepareTransactionRequestReturnType

      Example

      import { createWalletClient, custom } from 'viem'
      import { mainnet } from 'viem/chains'
      
      const client = createWalletClient({
        chain: mainnet,
        transport: custom(window.ethereum),
      })
      const request = await client.prepareTransactionRequest({
        account: '0xA0Cf798816D4b9b9866b5330EEa46a18382f251e',
        to: '0x0000000000000000000000000000000000000000',
        value: 1n,
      })
      Copy

      Example

      // Account Hoisting
      import { createWalletClient, http } from 'viem'
      import { privateKeyToAccount } from 'viem/accounts'
      import { mainnet } from 'viem/chains'
      
      const client = createWalletClient({
        account: privateKeyToAccount('0x…'),
        chain: mainnet,
        transport: custom(window.ethereum),
      })
      const request = await client.prepareTransactionRequest({
        to: '0x0000000000000000000000000000000000000000',
        value: 1n,
      })
      Copy

      • • <const request, chainOverride, accountOverride>(args): Promise<{
              [K in string | number | symbol]: (UnionRequiredBy<Extract<(...) & (...) & (...), (...) extends (...)
                  ? (...)
                  : (...)> & {
                  chainId?: (...) | (...);
              }, ParameterTypeToParameters<(...)[(...)] extends readonly (...)[]
                  ? (...)[(...)]
                  : (...) | (...) | (...) | (...) | (...) | (...)>> & (unknown extends request["kzg"]
                  ? {}
                  : Pick<request, "kzg">))[K]
          }>

        • Type Parameters

          • const request extends (Omit<{
                accessList: undefined;
                authorizationList: undefined;
                blobVersionedHashes: undefined;
                blobs: undefined;
                data?: `0x${string}`;
                from: `0x${string}`;
                gas?: bigint;
                gasPrice?: bigint;
                kzg: undefined;
                maxFeePerBlobGas?: undefined;
                maxFeePerGas?: undefined;
                maxPriorityFeePerGas?: undefined;
                nonce?: number;
                sidecars: undefined;
                to?: null | `0x${string}`;
                type?: "legacy";
                value?: bigint;
            }, "from"> | Omit<{
                accessList?: AccessList;
                authorizationList: undefined;
                blobVersionedHashes: undefined;
                blobs: undefined;
                data?: `0x${string}`;
                from: `0x${string}`;
                gas?: bigint;
                gasPrice?: bigint;
                kzg: undefined;
                maxFeePerBlobGas?: undefined;
                maxFeePerGas?: undefined;
                maxPriorityFeePerGas?: undefined;
                nonce?: number;
                sidecars: undefined;
                to?: null | `0x${string}`;
                type?: "eip2930";
                value?: bigint;
            }, "from"> | Omit<{
                accessList?: AccessList;
                authorizationList: undefined;
                blobVersionedHashes: undefined;
                blobs: undefined;
                data?: `0x${string}`;
                from: `0x${string}`;
                gas?: bigint;
                gasPrice?: undefined;
                kzg: undefined;
                maxFeePerBlobGas?: undefined;
                maxFeePerGas?: bigint;
                maxPriorityFeePerGas?: bigint;
                nonce?: number;
                sidecars: undefined;
                to?: null | `0x${string}`;
                type?: "eip1559";
                value?: bigint;
            }, "from"> | Omit<{
                accessList?: AccessList;
                authorizationList: undefined;
                blobVersionedHashes?: readonly `0x${string}`[];
                blobs: readonly `0x${string}`[] | readonly Uint8Array[];
                data?: `0x${string}`;
                from: `0x${string}`;
                gas?: bigint;
                gasPrice?: undefined;
                kzg?: Kzg;
                maxFeePerBlobGas: bigint;
                maxFeePerGas?: bigint;
                maxPriorityFeePerGas?: bigint;
                nonce?: number;
                sidecars?: readonly BlobSidecar<`0x${(...)}`>[];
                to: null | `0x${string}`;
                type?: "eip4844";
                value?: bigint;
            }, "from"> | Omit<{
                accessList?: AccessList;
                authorizationList: AuthorizationList<number, boolean>;
                blobVersionedHashes: undefined;
                blobs: undefined;
                data?: `0x${string}`;
                from: `0x${string}`;
                gas?: bigint;
                gasPrice?: undefined;
                kzg: undefined;
                maxFeePerBlobGas?: undefined;
                maxFeePerGas?: bigint;
                maxPriorityFeePerGas?: bigint;
                nonce?: number;
                sidecars: undefined;
                to?: null | `0x${string}`;
                type?: "eip7702";
                value?: bigint;
            }, "from">) & {
                kzg?: Kzg;
            } & {
                nonceManager?: NonceManager;
                parameters?: readonly PrepareTransactionRequestParameterType[];
            }
          • chainOverride extends undefined | Chain = undefined
          • accountOverride extends undefined | `0x${string}` | Account = undefined

          Parameters

          • args: PrepareTransactionRequestParameters<undefined | Chain, undefined | Account, chainOverride, accountOverride, request>

            PrepareTransactionRequestParameters

          Returns Promise<{
              [K in string | number | symbol]: (UnionRequiredBy<Extract<(...) & (...) & (...), (...) extends (...)
                  ? (...)
                  : (...)> & {
                  chainId?: (...) | (...);
              }, ParameterTypeToParameters<(...)[(...)] extends readonly (...)[]
                  ? (...)[(...)]
                  : (...) | (...) | (...) | (...) | (...) | (...)>> & (unknown extends request["kzg"]
                  ? {}
                  : Pick<request, "kzg">))[K]
          }>

    • readContract: (<const abi, functionName, args>(args) => Promise<ReadContractReturnType<abi, functionName, args>>)

      Calls a read-only function on a contract, and returns the response.

      • Docs: https://viem.sh/docs/contract/readContract
      • Examples: https://stackblitz.com/github/wevm/viem/tree/main/examples/contracts/reading-contracts

      Remarks

      A "read-only" function (constant function) on a Solidity contract is denoted by a view or pure keyword. They can only read the state of the contract, and cannot make any changes to it. Since read-only methods do not change the state of the contract, they do not require any gas to be executed, and can be called by any user without the need to pay for gas.

      Internally, uses a Public Client to call the call action with ABI-encoded data.

      Returns

      The response from the contract. Type is inferred. ReadContractReturnType

      Example

      import { createPublicClient, http, parseAbi } from 'viem'
      import { mainnet } from 'viem/chains'
      import { readContract } from 'viem/contract'
      
      const client = createPublicClient({
        chain: mainnet,
        transport: http(),
      })
      const result = await client.readContract({
        address: '0xFBA3912Ca04dd458c843e2EE08967fC04f3579c2',
        abi: parseAbi(['function balanceOf(address) view returns (uint256)']),
        functionName: 'balanceOf',
        args: ['0xA0Cf798816D4b9b9866b5330EEa46a18382f251e'],
      })
      // 424122n
      Copy

      • • <const abi, functionName, args>(args): Promise<ReadContractReturnType<abi, functionName, args>>

        • Type Parameters

          • const abi extends Abi | readonly unknown[]
          • functionName extends string
          • args extends unknown

          Parameters

          • args: ReadContractParameters<abi, functionName, args>

            ReadContractParameters

          Returns Promise<ReadContractReturnType<abi, functionName, args>>

    • request: EIP1193RequestFn<PublicRpcSchema>

      Request function wrapped with friendly error handling

    • sendRawTransaction: ((args) => Promise<`0x${string}`>)

      Sends a signed transaction to the network

      • Docs: https://viem.sh/docs/actions/wallet/sendRawTransaction
      • JSON-RPC Method: eth_sendRawTransaction

      Returns

      The transaction hash. SendRawTransactionReturnType

      Example

      import { createWalletClient, custom } from 'viem'
      import { mainnet } from 'viem/chains'
      import { sendRawTransaction } from 'viem/wallet'
      
      const client = createWalletClient({
        chain: mainnet,
        transport: custom(window.ethereum),
      })
      
      const hash = await client.sendRawTransaction({
        serializedTransaction: '0x02f850018203118080825208808080c080a04012522854168b27e5dc3d5839bab5e6b39e1a0ffd343901ce1622e3d64b48f1a04e00902ae0502c4728cbf12156290df99c3ed7de85b1dbfe20b5c36931733a33'
      })
      Copy

      • • (args): Promise<`0x${string}`>

        • Parameters

          • args: SendRawTransactionParameters

          Returns Promise<`0x${string}`>

    • simulateContract: (<const abi, functionName, args, chainOverride, accountOverride>(args) => Promise<SimulateContractReturnType<abi, functionName, args, undefined | Chain, undefined | Account, chainOverride, accountOverride>>)

      Simulates/validates a contract interaction. This is useful for retrieving return data and revert reasons of contract write functions.

      • Docs: https://viem.sh/docs/contract/simulateContract
      • Examples: https://stackblitz.com/github/wevm/viem/tree/main/examples/contracts/writing-to-contracts

      Remarks

      This function does not require gas to execute and does not change the state of the blockchain. It is almost identical to readContract, but also supports contract write functions.

      Internally, uses a Public Client to call the call action with ABI-encoded data.

      Returns

      The simulation result and write request. SimulateContractReturnType

      Example

      import { createPublicClient, http } from 'viem'
      import { mainnet } from 'viem/chains'
      
      const client = createPublicClient({
        chain: mainnet,
        transport: http(),
      })
      const result = await client.simulateContract({
        address: '0xFBA3912Ca04dd458c843e2EE08967fC04f3579c2',
        abi: parseAbi(['function mint(uint32) view returns (uint32)']),
        functionName: 'mint',
        args: ['69420'],
        account: '0xA0Cf798816D4b9b9866b5330EEa46a18382f251e',
      })
      Copy

      • • <const abi, functionName, args, chainOverride, accountOverride>(args): Promise<SimulateContractReturnType<abi, functionName, args, undefined | Chain, undefined | Account, chainOverride, accountOverride>>

        • Type Parameters

          • const abi extends Abi | readonly unknown[]
          • functionName extends string
          • args extends unknown
          • chainOverride extends undefined | Chain
          • accountOverride extends undefined | `0x${string}` | Account = undefined

          Parameters

          • args: SimulateContractParameters<abi, functionName, args, undefined | Chain, chainOverride, accountOverride>

            SimulateContractParameters

          Returns Promise<SimulateContractReturnType<abi, functionName, args, undefined | Chain, undefined | Account, chainOverride, accountOverride>>

    • transport: TransportConfig<string, EIP1193RequestFn> & Record<string, any>

      The RPC transport

    • type: string

      The type of client.

    • uid: string

      A unique ID for the client.

    • uninstallFilter: ((args) => Promise<boolean>)

      Destroys a Filter that was created from one of the following Actions:

      • createBlockFilter

      • createEventFilter

      • createPendingTransactionFilter

      • Docs: https://viem.sh/docs/actions/public/uninstallFilter

      • JSON-RPC Methods: eth_uninstallFilter

      Returns

      A boolean indicating if the Filter was successfully uninstalled. UninstallFilterReturnType

      Example

      import { createPublicClient, http } from 'viem'
      import { mainnet } from 'viem/chains'
      import { createPendingTransactionFilter, uninstallFilter } from 'viem/public'
      
      const filter = await client.createPendingTransactionFilter()
      const uninstalled = await client.uninstallFilter({ filter })
      // true
      Copy

      • • (args): Promise<boolean>

        • Parameters

          • args: UninstallFilterParameters

            UninstallFilterParameters

          Returns Promise<boolean>

    • verifyMessage: ((args) => Promise<boolean>)

      Verify that a message was signed by the provided address.

      Compatible with Smart Contract Accounts & Externally Owned Accounts via ERC-6492.

      • Docs https://viem.sh/docs/actions/public/verifyMessage

      Returns

      Whether or not the signature is valid. VerifyMessageReturnType

      • • (args): Promise<boolean>

        • Parameters

          • args: {
                address: `0x${string}`;
                blockNumber?: bigint;
                blockTag?: BlockTag;
                factory?: `0x${string}`;
                factoryData?: `0x${string}`;
                message: SignableMessage;
                signature: `0x${string}` | Uint8Array | Signature;
            }

            • address: `0x${string}`

              The address that signed the original message.

            • Optional blockNumber?: bigint

              The balance of the account at a block number.

            • Optional blockTag?: BlockTag

              The balance of the account at a block tag.

              Default

              'latest'
              Copy

            • Optional factory?: `0x${string}`

            • Optional factoryData?: `0x${string}`

            • message: SignableMessage

              The message to be verified.

            • signature: `0x${string}` | Uint8Array | Signature

              The signature that was generated by signing the message with the address's private key.

          Returns Promise<boolean>

    • verifySiweMessage: ((args) => Promise<boolean>)

      Verifies EIP-4361 formatted message was signed.

      Compatible with Smart Contract Accounts & Externally Owned Accounts via ERC-6492.

      • Docs https://viem.sh/docs/siwe/actions/verifySiweMessage

      Returns

      Whether or not the signature is valid. VerifySiweMessageReturnType

      • • (args): Promise<boolean>

        • Parameters

          • args: {
                address?: `0x${string}`;
                blockNumber?: bigint;
                blockTag?: BlockTag;
                domain?: string;
                message: string;
                nonce?: string;
                scheme?: string;
                signature: `0x${string}`;
                time?: Date;
            }

            • Optional address?: `0x${string}`

              Ethereum address to check against.

            • Optional blockNumber?: bigint

              The balance of the account at a block number.

            • Optional blockTag?: BlockTag

              The balance of the account at a block tag.

              Default

              'latest'
              Copy

            • Optional domain?: string

              RFC 3986 authority to check against.

            • message: string

              EIP-4361 formatted message.

            • Optional nonce?: string

              Random string to check against.

            • Optional scheme?: string

              RFC 3986 URI scheme to check against.

            • signature: `0x${string}`

              Signature to check against.

            • Optional time?: Date

              Current time to check optional expirationTime and notBefore fields.

              Default

              new Date()
              Copy

          Returns Promise<boolean>

    • verifyTypedData: ((args) => Promise<boolean>)

      Verify that typed data was signed by the provided address.

      • Docs https://viem.sh/docs/actions/public/verifyTypedData

      Returns

      Whether or not the signature is valid. VerifyTypedDataReturnType

      • • (args): Promise<boolean>

        • Parameters

          • args: VerifyTypedDataParameters

          Returns Promise<boolean>

    • waitForTransactionReceipt: ((args) => Promise<TransactionReceipt>)

      Waits for the Transaction to be included on a Block (one confirmation), and then returns the Transaction Receipt. If the Transaction reverts, then the action will throw an error.

      • Docs: https://viem.sh/docs/actions/public/waitForTransactionReceipt
      • Example: https://stackblitz.com/github/wevm/viem/tree/main/examples/transactions/sending-transactions
      • JSON-RPC Methods:
        • Polls eth_getTransactionReceipt on each block until it has been processed.
        • If a Transaction has been replaced:
          • Calls eth_getBlockByNumber and extracts the transactions
          • Checks if one of the Transactions is a replacement
          • If so, calls eth_getTransactionReceipt.

      Remarks

      The waitForTransactionReceipt action additionally supports Replacement detection (e.g. sped up Transactions).

      Transactions can be replaced when a user modifies their transaction in their wallet (to speed up or cancel). Transactions are replaced when they are sent from the same nonce.

      There are 3 types of Transaction Replacement reasons:

      • repriced: The gas price has been modified (e.g. different maxFeePerGas)
      • cancelled: The Transaction has been cancelled (e.g. value === 0n)
      • replaced: The Transaction has been replaced (e.g. different value or data)

      Returns

      The transaction receipt. WaitForTransactionReceiptReturnType

      Example

      import { createPublicClient, http } from 'viem'
      import { mainnet } from 'viem/chains'
      
      const client = createPublicClient({
        chain: mainnet,
        transport: http(),
      })
      const transactionReceipt = await client.waitForTransactionReceipt({
        hash: '0x4ca7ee652d57678f26e887c149ab0735f41de37bcad58c9f6d3ed5824f15b74d',
      })
      Copy

      • • (args): Promise<TransactionReceipt>

        • Parameters

          • args: WaitForTransactionReceiptParameters<undefined | Chain>

            WaitForTransactionReceiptParameters

          Returns Promise<TransactionReceipt>

    • watchBlockNumber: ((args) => WatchBlockNumberReturnType)

      Watches and returns incoming block numbers.

      • Docs: https://viem.sh/docs/actions/public/watchBlockNumber
      • Examples: https://stackblitz.com/github/wevm/viem/tree/main/examples/blocks/watching-blocks
      • JSON-RPC Methods:
        • When poll: true, calls eth_blockNumber on a polling interval.
        • When poll: false & WebSocket Transport, uses a WebSocket subscription via eth_subscribe and the "newHeads" event.

      Returns

      A function that can be invoked to stop watching for new block numbers. WatchBlockNumberReturnType

      Example

      import { createPublicClient, http } from 'viem'
      import { mainnet } from 'viem/chains'
      
      const client = createPublicClient({
        chain: mainnet,
        transport: http(),
      })
      const unwatch = await client.watchBlockNumber({
        onBlockNumber: (blockNumber) => console.log(blockNumber),
      })
      Copy

      • • (args): WatchBlockNumberReturnType

        • Parameters

          • args: WatchBlockNumberParameters

            WatchBlockNumberParameters

          Returns WatchBlockNumberReturnType

    • watchBlocks: (<includeTransactions, blockTag>(args) => WatchBlocksReturnType)

      Watches and returns information for incoming blocks.

      • Docs: https://viem.sh/docs/actions/public/watchBlocks
      • Examples: https://stackblitz.com/github/wevm/viem/tree/main/examples/blocks/watching-blocks
      • JSON-RPC Methods:
        • When poll: true, calls eth_getBlockByNumber on a polling interval.
        • When poll: false & WebSocket Transport, uses a WebSocket subscription via eth_subscribe and the "newHeads" event.

      Returns

      A function that can be invoked to stop watching for new block numbers. WatchBlocksReturnType

      Example

      import { createPublicClient, http } from 'viem'
      import { mainnet } from 'viem/chains'
      
      const client = createPublicClient({
        chain: mainnet,
        transport: http(),
      })
      const unwatch = await client.watchBlocks({
        onBlock: (block) => console.log(block),
      })
      Copy

      • • <includeTransactions, blockTag>(args): WatchBlocksReturnType

        • Type Parameters

          • includeTransactions extends boolean = false
          • blockTag extends BlockTag = "latest"

          Parameters

          • args: WatchBlocksParameters<Transport, undefined | Chain, includeTransactions, blockTag>

            WatchBlocksParameters

          Returns WatchBlocksReturnType

    • watchContractEvent: (<const abi, eventName, strict>(args) => WatchContractEventReturnType)

      Watches and returns emitted contract event logs.

      • Docs: https://viem.sh/docs/contract/watchContractEvent

      Remarks

      This Action will batch up all the event logs found within the pollingInterval, and invoke them via onLogs.

      watchContractEvent will attempt to create an Event Filter and listen to changes to the Filter per polling interval, however, if the RPC Provider does not support Filters (e.g. eth_newFilter), then watchContractEvent will fall back to using getLogs instead.

      Returns

      A function that can be invoked to stop watching for new event logs. WatchContractEventReturnType

      Example

      import { createPublicClient, http, parseAbi } from 'viem'
      import { mainnet } from 'viem/chains'
      
      const client = createPublicClient({
        chain: mainnet,
        transport: http(),
      })
      const unwatch = client.watchContractEvent({
        address: '0xFBA3912Ca04dd458c843e2EE08967fC04f3579c2',
        abi: parseAbi(['event Transfer(address indexed from, address indexed to, uint256 value)']),
        eventName: 'Transfer',
        args: { from: '0xc961145a54C96E3aE9bAA048c4F4D6b04C13916b' },
        onLogs: (logs) => console.log(logs),
      })
      Copy

      • • <const abi, eventName, strict>(args): WatchContractEventReturnType

        • Type Parameters

          • const abi extends Abi | readonly unknown[]
          • eventName extends string
          • strict extends undefined | boolean = undefined

          Parameters

          • args: WatchContractEventParameters<abi, eventName, strict, Transport>

            WatchContractEventParameters

          Returns WatchContractEventReturnType

    • watchEvent: (<const abiEvent, const abiEvents, strict>(args) => WatchEventReturnType)

      Watches and returns emitted Event Logs.

      • Docs: https://viem.sh/docs/actions/public/watchEvent
      • JSON-RPC Methods:
        • RPC Provider supports eth_newFilter:
          • Calls eth_newFilter to create a filter (called on initialize).
          • On a polling interval, it will call eth_getFilterChanges.
        • RPC Provider does not support eth_newFilter:
          • Calls eth_getLogs for each block between the polling interval.

      Remarks

      This Action will batch up all the Event Logs found within the pollingInterval, and invoke them via onLogs.

      watchEvent will attempt to create an Event Filter and listen to changes to the Filter per polling interval, however, if the RPC Provider does not support Filters (e.g. eth_newFilter), then watchEvent will fall back to using getLogs instead.

      Returns

      A function that can be invoked to stop watching for new Event Logs. WatchEventReturnType

      Example

      import { createPublicClient, http } from 'viem'
      import { mainnet } from 'viem/chains'
      
      const client = createPublicClient({
        chain: mainnet,
        transport: http(),
      })
      const unwatch = client.watchEvent({
        onLogs: (logs) => console.log(logs),
      })
      Copy

      • • <const abiEvent, const abiEvents, strict>(args): WatchEventReturnType

        • Type Parameters

          • const abiEvent extends undefined | AbiEvent = undefined
          • const abiEvents extends undefined | readonly unknown[] | readonly AbiEvent[] = abiEvent extends AbiEvent
                ? [abiEvent<abiEvent>]
                : undefined
          • strict extends undefined | boolean = undefined

          Parameters

          • args: WatchEventParameters<abiEvent, abiEvents, strict, Transport>

            WatchEventParameters

          Returns WatchEventReturnType

    • watchPendingTransactions: ((args) => WatchPendingTransactionsReturnType)

      Watches and returns pending transaction hashes.

      • Docs: https://viem.sh/docs/actions/public/watchPendingTransactions
      • JSON-RPC Methods:
        • When poll: true
          • Calls eth_newPendingTransactionFilter to initialize the filter.
          • Calls eth_getFilterChanges on a polling interval.
        • When poll: false & WebSocket Transport, uses a WebSocket subscription via eth_subscribe and the "newPendingTransactions" event.

      Remarks

      This Action will batch up all the pending transactions found within the pollingInterval, and invoke them via onTransactions.

      Returns

      A function that can be invoked to stop watching for new pending transaction hashes. WatchPendingTransactionsReturnType

      Example

      import { createPublicClient, http } from 'viem'
      import { mainnet } from 'viem/chains'
      
      const client = createPublicClient({
        chain: mainnet,
        transport: http(),
      })
      const unwatch = await client.watchPendingTransactions({
        onTransactions: (hashes) => console.log(hashes),
      })
      Copy

      • • (args): WatchPendingTransactionsReturnType

        • Parameters

          • args: WatchPendingTransactionsParameters<Transport>

            WatchPendingTransactionsParameters

          Returns WatchPendingTransactionsReturnType

  • owner: `0x${string}`