CreateSelfFacilitatorParams

Defined in: src/x402/facilitator.ts:201

Parameters for createSelfFacilitator.

Properties

hooks?

readonly optional hooks?: ObservabilityHooks

Defined in: src/x402/facilitator.ts:239

Optional observability callbacks. Hooks are fire-and-forget — any throw or rejection inside a hook is silently discarded and never propagates to the verify / settle return path. See ObservabilityHooks.

The facilitator emits onVerify after every verify() call (including the internal re-verify that runs at the start of settle()) and onSettle after every settle() call.

---

network

readonly network: "testnet" | "mainnet"

Defined in: src/x402/facilitator.ts:212

Declared production-vs-test intent. MUST agree with walletClient.chain:

• "mainnet" requires a kawasekit chain with isTestnet === false.
• "testnet" requires a kawasekit chain with isTestnet === true.

The check is enforced at construction time and throws a fatal error on disagreement. The point is to make accidentally pointing a testnet configuration at a mainnet RPC (or vice versa) impossible — that mistake would broadcast real-fund transactions silently.

---

publicClient

readonly publicClient: object

Defined in: src/x402/facilitator.ts:224

Pre-configured public client on the same chain as walletClient. Used for balance and authorization-state reads during verify.

account

account: undefined

The Account of the Client.

batch?

optional batch?: object

Flags for batch settings.

batch.multicall?

optional multicall?: boolean | { batchSize?: number; deployless?: boolean; wait?: number; }

Toggle to enable eth_call multicall aggregation.

Union Members

boolean

---

Type Literal

{ batchSize?: number; deployless?: boolean; wait?: number; }

batchSize?

optional batchSize?: number

The maximum size (in bytes) for each calldata chunk.

Default

1_024

deployless?

optional deployless?: boolean

Enable deployless multicall.

wait?

optional wait?: number

The maximum number of milliseconds to wait before sending a batch.

Default

0

cacheTime

cacheTime: number

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

call

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

Parameters

parameters

CallParameters<Chain>

Returns

Promise<CallReturnType>

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',
})

ccipRead?

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

CCIP Read configuration.

Union Members

false

---

Type Literal

{ request?: (parameters) => Promise<`0x${string}`>; }

request?

optional request?: (parameters) => Promise<`0x${string}`>

A function that will be called to make the offchain CCIP lookup request.

Parameters

parameters

CcipRequestParameters

Returns

Promise<`0x${string}`>

See

https://eips.ethereum.org/EIPS/eip-3668#client-lookup-protocol

chain

chain: Chain

Chain for the client.

createAccessList

createAccessList: (parameters) => Promise<{ accessList: AccessList; gasUsed: bigint; }>

Creates an EIP-2930 access list that you can include in a transaction.

• Docs: https://viem.sh/docs/actions/public/createAccessList
• JSON-RPC Methods: eth_createAccessList

Parameters

parameters

CreateAccessListParameters<Chain>

Returns

Promise<{ accessList: AccessList; gasUsed: bigint; }>

The call data. CreateAccessListReturnType

Example

import { createPublicClient, http } from 'viem'
import { mainnet } from 'viem/chains'

const client = createPublicClient({
  chain: mainnet,
  transport: http(),
})

const data = await client.createAccessList({
  data: '0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2',
  to: '0x70997970c51812dc3a010c7d01b50e0d17dc79c8',
})

createBlockFilter

createBlockFilter: () => Promise<{ id: `0x${string}`; request: EIP1193RequestFn<readonly [{ Method: "eth_getFilterChanges"; Parameters: [`0x${string}`]; ReturnType: `0x${string}`[] | RpcLog[]; }, { Method: "eth_getFilterLogs"; Parameters: [`0x${string}`]; ReturnType: RpcLog[]; }, { Method: "eth_uninstallFilter"; Parameters: [`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

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

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' }

createContractEventFilter

createContractEventFilter: <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

Type Parameters

abi

abi extends Abi | readonly unknown[]

eventName

eventName extends string | undefined

args

args extends Record<string, unknown> | readonly unknown[] | undefined

strict

strict extends boolean | undefined = undefined

fromBlock

fromBlock extends bigint | BlockTag | undefined = undefined

toBlock

toBlock extends bigint | BlockTag | undefined = undefined

Parameters

args

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

CreateContractEventFilterParameters

Returns

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

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)']),
})

createEventFilter

createEventFilter: <abiEvent, 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

Type Parameters

abiEvent

abiEvent extends AbiEvent | undefined = undefined

abiEvents

abiEvents extends readonly unknown[] | readonly AbiEvent[] | undefined = abiEvent extends AbiEvent ? [abiEvent] : undefined

strict

strict extends boolean | undefined = undefined

fromBlock

fromBlock extends bigint | BlockTag | undefined = undefined

toBlock

toBlock extends bigint | BlockTag | undefined = undefined

_EventName

_EventName extends string | undefined = MaybeAbiEventName<abiEvent>

_Args

_Args extends Record<string, unknown> | readonly unknown[] | undefined = undefined

Parameters

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] }>

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',
})

createPendingTransactionFilter

createPendingTransactionFilter: () => Promise<{ id: `0x${string}`; request: EIP1193RequestFn<readonly [{ Method: "eth_getFilterChanges"; Parameters: [`0x${string}`]; ReturnType: `0x${string}`[] | RpcLog[]; }, { Method: "eth_getFilterLogs"; Parameters: [`0x${string}`]; ReturnType: RpcLog[]; }, { Method: "eth_uninstallFilter"; Parameters: [`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

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

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' }

dataSuffix?

optional dataSuffix?: DataSuffix

Data suffix to append to transaction data.

estimateContractGas

estimateContractGas: <chain, 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

Type Parameters

chain

chain extends Chain | undefined

abi

abi extends Abi | readonly unknown[]

functionName

functionName extends string

args

args extends unknown

Parameters

args

EstimateContractGasParameters<abi, functionName, args, chain>

EstimateContractGasParameters

Returns

Promise<bigint>

The gas estimate (in wei). EstimateContractGasReturnType

Remarks

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

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',
})

estimateFeesPerGas

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

Type Parameters

chainOverride

chainOverride extends Chain | undefined = undefined

type

type extends FeeValuesType = "eip1559"

Parameters

args?

EstimateFeesPerGasParameters<Chain, chainOverride, type>

Returns

Promise<EstimateFeesPerGasReturnType<type>>

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: ... }

estimateGas

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

Parameters

args

EstimateGasParameters<Chain>

EstimateGasParameters

Returns

Promise<bigint>

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'),
})

estimateMaxPriorityFeePerGas

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

Type Parameters

chainOverride

chainOverride extends Chain | undefined = undefined

Parameters

args?

chain?

chainOverride | null

Returns

Promise<bigint>

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

experimental_blockTag?

optional experimental_blockTag?: BlockTag

Default block tag to use for RPC requests.

extend

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

Type Parameters

client

client extends object & ExactPartial<ExtendableProtectedActions<Transport, Chain, undefined>>

Parameters

fn

(client) => client

Returns

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

fillTransaction

fillTransaction: <chainOverride, accountOverride>(args) => Promise<FillTransactionReturnType<Chain, chainOverride>>

Fills a transaction request with the necessary fields to be signed over.

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

Type Parameters

chainOverride

chainOverride extends Chain | undefined = undefined

accountOverride

accountOverride extends `0x${string}` | Account | undefined = undefined

Parameters

args

FillTransactionParameters<Chain, Account | undefined, chainOverride, accountOverride>

Returns

Promise<FillTransactionReturnType<Chain, chainOverride>>

The filled transaction. FillTransactionReturnType

Example

import { createPublicClient, http } from 'viem'
import { mainnet } from 'viem/chains'

const client = createPublicClient({
  chain: mainnet,
  transport: http(),
})
const result = await client.fillTransaction({
  account: '0xA0Cf798816D4b9b9866b5330EEa46a18382f251e',
  to: '0x70997970c51812dc3a010c7d01b50e0d17dc79c8',
  value: parseEther('1'),
})

getBalance

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

Parameters

args

GetBalanceParameters

GetBalanceParameters

Returns

Promise<bigint>

The balance of the address in wei. GetBalanceReturnType

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"

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)

getBlobBaseFee

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

Promise<bigint>

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()

getBlock

getBlock: <includeTransactions, blockTag>(args?) => Promise<{ baseFeePerGas: bigint | null; 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; parentBeaconBlockRoot?: `0x${string}`; parentHash: `0x${string}`; receiptsRoot: `0x${string}`; sealFields: `0x${string}`[]; sha3Uncles: `0x${string}`; size: bigint; stateRoot: `0x${string}`; timestamp: bigint; totalDifficulty: bigint | null; transactions: includeTransactions extends true ? ({ 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; blockTimestamp?: 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: `0x${string}` | null; transactionIndex: blockTag extends "pending" ? true : false extends true ? null : number; type: "legacy"; typeHex: `0x${string}` | null; 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; blockTimestamp?: 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: `0x${string}` | null; transactionIndex: blockTag extends "pending" ? true : false extends true ? null : number; type: "eip2930"; typeHex: `0x${string}` | null; 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; blockTimestamp?: 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: `0x${string}` | null; transactionIndex: blockTag extends "pending" ? true : false extends true ? null : number; type: "eip1559"; typeHex: `0x${string}` | null; 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; blockTimestamp?: 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: `0x${string}` | null; transactionIndex: blockTag extends "pending" ? true : false extends true ? null : number; type: "eip4844"; typeHex: `0x${string}` | null; 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; blockTimestamp?: 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: `0x${string}` | null; transactionIndex: blockTag extends "pending" ? true : false extends true ? null : number; type: "eip7702"; typeHex: `0x${string}` | null; 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.

Type Parameters

includeTransactions

includeTransactions extends boolean = false

blockTag

blockTag extends BlockTag = "latest"

Parameters

args?

GetBlockParameters<includeTransactions, blockTag>

GetBlockParameters

Returns

Promise<{ baseFeePerGas: bigint | null; 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; parentBeaconBlockRoot?: `0x${string}`; parentHash: `0x${string}`; receiptsRoot: `0x${string}`; sealFields: `0x${string}`[]; sha3Uncles: `0x${string}`; size: bigint; stateRoot: `0x${string}`; timestamp: bigint; totalDifficulty: bigint | null; transactions: includeTransactions extends true ? ({ 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; blockTimestamp?: 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: `0x${string}` | null; transactionIndex: blockTag extends "pending" ? true : false extends true ? null : number; type: "legacy"; typeHex: `0x${string}` | null; 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; blockTimestamp?: 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: `0x${string}` | null; transactionIndex: blockTag extends "pending" ? true : false extends true ? null : number; type: "eip2930"; typeHex: `0x${string}` | null; 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; blockTimestamp?: 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: `0x${string}` | null; transactionIndex: blockTag extends "pending" ? true : false extends true ? null : number; type: "eip1559"; typeHex: `0x${string}` | null; 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; blockTimestamp?: 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: `0x${string}` | null; transactionIndex: blockTag extends "pending" ? true : false extends true ? null : number; type: "eip4844"; typeHex: `0x${string}` | null; 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; blockTimestamp?: 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: `0x${string}` | null; transactionIndex: blockTag extends "pending" ? true : false extends true ? null : number; type: "eip7702"; typeHex: `0x${string}` | null; v: bigint; value: bigint; yParity: number; })[] : `0x${string}`[]; transactionsRoot: `0x${string}`; uncles: `0x${string}`[]; withdrawals?: Withdrawal[]; withdrawalsRoot?: `0x${string}`; }>

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()

getBlockNumber

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

Parameters

args?

GetBlockNumberParameters

GetBlockNumberParameters

Returns

Promise<bigint>

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

getBlockTransactionCount

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.

Parameters

args?

GetBlockTransactionCountParameters

GetBlockTransactionCountParameters

Returns

Promise<number>

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()

getBytecode

getBytecode: (args) => Promise<GetCodeReturnType>

Deprecated

Use getCode instead.

Parameters

args

GetCodeParameters

Returns

Promise<GetCodeReturnType>

getChainId

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

Promise<number>

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

getCode

getCode: (args) => Promise<GetCodeReturnType>

Retrieves the bytecode at an address.

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

Parameters

args

GetCodeParameters

GetBytecodeParameters

Returns

Promise<GetCodeReturnType>

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',
})

getContractEvents

getContractEvents: <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

Type Parameters

abi

abi extends Abi | readonly unknown[]

eventName

eventName extends string | undefined = undefined

strict

strict extends boolean | undefined = undefined

fromBlock

fromBlock extends bigint | BlockTag | undefined = undefined

toBlock

toBlock extends bigint | BlockTag | undefined = undefined

Parameters

args

GetContractEventsParameters<abi, eventName, strict, fromBlock, toBlock>

Returns

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

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'
})

getDelegation

getDelegation: (args) => Promise<GetDelegationReturnType>

Returns the address that an account has delegated to via EIP-7702.

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

Parameters

args

GetDelegationParameters

GetDelegationParameters

Returns

Promise<GetDelegationReturnType>

The delegated address, or undefined if not delegated. GetDelegationReturnType

Example

import { createPublicClient, http } from 'viem'
import { mainnet } from 'viem/chains'

const client = createPublicClient({
  chain: mainnet,
  transport: http(),
})
const delegation = await client.getDelegation({
  address: '0xA0Cf798816D4b9b9866b5330EEa46a18382f251e',
})

getEip712Domain

getEip712Domain: (args) => Promise<GetEip712DomainReturnType>

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

Parameters

args

GetEip712DomainParameters

Returns

Promise<GetEip712DomainReturnType>

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: [],
// }

getEnsAddress

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

Parameters

args

GetEnsAddressParameters

blockNumber?

bigint

The block number to perform the call against.

blockTag?

BlockTag

The block tag to perform the call against.

Default

'latest'

coinType?

bigint

ENSIP-9 compliant coinType (chain) to get ENS address for.

To get the coinType for a chain id, use the toCoinType function:

import { toCoinType } from 'viem'
import { base } from 'viem/chains'

const coinType = toCoinType(base.id)

Default

60n

gatewayUrls?

string[]

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

name

string

Name to get the address for.

strict?

boolean

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

universalResolverAddress?

`0x${string}`

Address of ENS Universal Resolver Contract.

Returns

Promise<GetEnsAddressReturnType>

Address for ENS name or null if not found. GetEnsAddressReturnType

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.

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'

getEnsAvatar

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

Parameters

args

GetEnsAvatarParameters

assetGatewayUrls?

AssetGatewayUrls

Gateway urls to resolve IPFS and/or Arweave assets.

blockNumber?

bigint

The block number to perform the call against.

blockTag?

BlockTag

The block tag to perform the call against.

Default

'latest'

gatewayUrls?

string[]

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

name

string

ENS name to get Text for.

strict?

boolean

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

universalResolverAddress?

`0x${string}`

Address of ENS Universal Resolver Contract.

Returns

Promise<GetEnsAvatarReturnType>

Avatar URI or null if not found. GetEnsAvatarReturnType

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.

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'

getEnsName

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

Parameters

args

GetEnsNameParameters

address

`0x${string}`

Address to get ENS name for.

blockNumber?

bigint

The block number to perform the call against.

blockTag?

BlockTag

The block tag to perform the call against.

Default

'latest'

coinType?

bigint

ENSIP-9 compliant coinType (chain) to get ENS name for.

To get the coinType for a chain id, use the toCoinType function:

import { toCoinType } from 'viem'
import { base } from 'viem/chains'

const coinType = toCoinType(base.id)

Default

60n

gatewayUrls?

string[]

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

strict?

boolean

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

universalResolverAddress?

`0x${string}`

Address of ENS Universal Resolver Contract.

Returns

Promise<GetEnsNameReturnType>

Name or null if not found. GetEnsNameReturnType

Remarks

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

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'

getEnsResolver

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

Parameters

args

GetEnsResolverParameters

blockNumber?

bigint

The block number to perform the call against.

blockTag?

BlockTag

The block tag to perform the call against.

Default

'latest'

name

string

Name to get the address for.

universalResolverAddress?

`0x${string}`

Address of ENS Universal Resolver Contract.

Returns

Promise<`0x${string}`>

Address for ENS resolver. GetEnsResolverReturnType

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.

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'

getEnsText

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

Parameters

args

GetEnsTextParameters

blockNumber?

bigint

The block number to perform the call against.

blockTag?

BlockTag

The block tag to perform the call against.

Default

'latest'

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.

strict?

boolean

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

universalResolverAddress?

`0x${string}`

Address of ENS Universal Resolver Contract.

Returns

Promise<GetEnsTextReturnType>

Address for ENS resolver. GetEnsTextReturnType

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.

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'

getFeeHistory

getFeeHistory: (args) => Promise<GetFeeHistoryReturnType>

Returns a collection of historical gas information.

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

Parameters

args

GetFeeHistoryParameters

GetFeeHistoryParameters

Returns

Promise<GetFeeHistoryReturnType>

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],
})

getFilterChanges

getFilterChanges: <filterType, 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

Type Parameters

filterType

filterType extends FilterType

abi

abi extends Abi | readonly unknown[] | undefined

eventName

eventName extends string | undefined

strict

strict extends boolean | undefined = undefined

fromBlock

fromBlock extends bigint | BlockTag | undefined = undefined

toBlock

toBlock extends bigint | BlockTag | undefined = undefined

Parameters

args

GetFilterChangesParameters<filterType, abi, eventName, strict, fromBlock, toBlock>

GetFilterChangesParameters

Returns

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

Logs or hashes. GetFilterChangesReturnType

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.

Examples

// 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 })

// 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 })

// 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 })

// 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 })

getFilterLogs

getFilterLogs: <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

Type Parameters

abi

abi extends Abi | readonly unknown[] | undefined

eventName

eventName extends string | undefined

strict

strict extends boolean | undefined = undefined

fromBlock

fromBlock extends bigint | BlockTag | undefined = undefined

toBlock

toBlock extends bigint | BlockTag | undefined = undefined

Parameters

args

GetFilterLogsParameters<abi, eventName, strict, fromBlock, toBlock>

GetFilterLogsParameters

Returns

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

A list of event logs. GetFilterLogsReturnType

Remarks

getFilterLogs is only compatible with event filters.

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 })

getGasPrice

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

Promise<bigint>

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()

getLogs

getLogs: <abiEvent, 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/logs_event-logs
• JSON-RPC Methods: eth_getLogs

Type Parameters

abiEvent

abiEvent extends AbiEvent | undefined = undefined

abiEvents

abiEvents extends readonly unknown[] | readonly AbiEvent[] | undefined = abiEvent extends AbiEvent ? [abiEvent] : undefined

strict

strict extends boolean | undefined = undefined

fromBlock

fromBlock extends bigint | BlockTag | undefined = undefined

toBlock

toBlock extends bigint | BlockTag | undefined = undefined

Parameters

args?

GetLogsParameters<abiEvent, abiEvents, strict, fromBlock, toBlock>

GetLogsParameters

Returns

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

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()

getProof

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

Parameters

args

GetProofParameters

Returns

Promise<GetProofReturnType>

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...'],
})

getStorageAt

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

Parameters

args

GetStorageAtParameters

GetStorageAtParameters

Returns

Promise<GetStorageAtReturnType>

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),
})

getTransaction

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; blockTimestamp?: 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: `0x${string}` | null; transactionIndex: blockTag extends "pending" ? true : false extends true ? null : number; type: "legacy"; typeHex: `0x${string}` | null; 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; blockTimestamp?: 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: `0x${string}` | null; transactionIndex: blockTag extends "pending" ? true : false extends true ? null : number; type: "eip2930"; typeHex: `0x${string}` | null; 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; blockTimestamp?: 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: `0x${string}` | null; transactionIndex: blockTag extends "pending" ? true : false extends true ? null : number; type: "eip1559"; typeHex: `0x${string}` | null; 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; blockTimestamp?: 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: `0x${string}` | null; transactionIndex: blockTag extends "pending" ? true : false extends true ? null : number; type: "eip4844"; typeHex: `0x${string}` | null; 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; blockTimestamp?: 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: `0x${string}` | null; transactionIndex: blockTag extends "pending" ? true : false extends true ? null : number; type: "eip7702"; typeHex: `0x${string}` | null; 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

Type Parameters

blockTag

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; blockTimestamp?: 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: `0x${string}` | null; transactionIndex: blockTag extends "pending" ? true : false extends true ? null : number; type: "legacy"; typeHex: `0x${string}` | null; 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; blockTimestamp?: 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: `0x${string}` | null; transactionIndex: blockTag extends "pending" ? true : false extends true ? null : number; type: "eip2930"; typeHex: `0x${string}` | null; 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; blockTimestamp?: 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: `0x${string}` | null; transactionIndex: blockTag extends "pending" ? true : false extends true ? null : number; type: "eip1559"; typeHex: `0x${string}` | null; 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; blockTimestamp?: 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: `0x${string}` | null; transactionIndex: blockTag extends "pending" ? true : false extends true ? null : number; type: "eip4844"; typeHex: `0x${string}` | null; 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; blockTimestamp?: 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: `0x${string}` | null; transactionIndex: blockTag extends "pending" ? true : false extends true ? null : number; type: "eip7702"; typeHex: `0x${string}` | null; v: bigint; value: bigint; yParity: number; }>

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',
})

getTransactionConfirmations

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

Parameters

args

GetTransactionConfirmationsParameters<Chain>

GetTransactionConfirmationsParameters

Returns

Promise<bigint>

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',
})

getTransactionCount

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

Parameters

args

GetTransactionCountParameters

GetTransactionCountParameters

Returns

Promise<number>

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',
})

getTransactionReceipt

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

Parameters

args

GetTransactionReceiptParameters

GetTransactionReceiptParameters

Returns

Promise<TransactionReceipt>

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',
})

key

key: string

A key for the client.

multicall

multicall: <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

Type Parameters

contracts

contracts extends readonly unknown[]

allowFailure

allowFailure extends boolean = true

Parameters

args

MulticallParameters<contracts, allowFailure>

MulticallParameters

Returns

Promise<MulticallReturnType<contracts, allowFailure>>

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' }]

name

name: string

A name for the client.

pollingInterval

pollingInterval: number

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

prepareTransactionRequest

prepareTransactionRequest: <request, chainOverride, accountOverride>(args) => Promise<{ [K in string | number | symbol]: (UnionRequiredBy<Extract<UnionOmit<(…), (…)> & ((…) extends (…) ? (…) : (…)) & ((…) extends (…) ? (…) : (…)), IsNever<(…)> extends true ? unknown : ExactPartial<(…)>> & { chainId?: number }, ParameterTypeToParameters<request[“parameters”] extends readonly PrepareTransactionRequestParameterType[] ? any[any][number] : “type” | “gas” | “nonce” | “blobVersionedHashes” | “fees” | “chainId”>> & (unknown extends request[“kzg”] ? {} : Pick<request, “kzg”>) & { _capabilities?: { [key: string]: any } })[K] }>

Prepares a transaction request for signing.

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

Type Parameters

request

request extends Omit<{ accessList?: undefined; authorizationList?: undefined; blobs?: undefined; blobVersionedHashes?: undefined; data?: `0x${string}`; from?: `0x${string}`; gas?: bigint; gasPrice?: bigint; kzg?: undefined; maxFeePerBlobGas?: undefined; maxFeePerGas?: undefined; maxPriorityFeePerGas?: undefined; nonce?: number; sidecars?: undefined; to?: `0x${string}` | null; type?: "legacy"; value?: bigint; }, "from"> | Omit<{ accessList?: AccessList; authorizationList?: undefined; blobs?: undefined; blobVersionedHashes?: undefined; data?: `0x${string}`; from?: `0x${string}`; gas?: bigint; gasPrice?: bigint; kzg?: undefined; maxFeePerBlobGas?: undefined; maxFeePerGas?: undefined; maxPriorityFeePerGas?: undefined; nonce?: number; sidecars?: undefined; to?: `0x${string}` | null; type?: "eip2930"; value?: bigint; }, "from"> | Omit<{ accessList?: AccessList; authorizationList?: undefined; blobs?: undefined; blobVersionedHashes?: undefined; data?: `0x${string}`; from?: `0x${string}`; gas?: bigint; gasPrice?: undefined; kzg?: undefined; maxFeePerBlobGas?: undefined; maxFeePerGas?: bigint; maxPriorityFeePerGas?: bigint; nonce?: number; sidecars?: undefined; to?: `0x${string}` | null; type?: "eip1559"; value?: bigint; }, "from"> | Omit<{ accessList?: AccessList; authorizationList?: undefined; blobs?: readonly `0x${string}`[] | readonly ByteArray[]; blobVersionedHashes: readonly `0x${string}`[]; data?: `0x${string}`; from?: `0x${string}`; gas?: bigint; gasPrice?: undefined; kzg?: undefined; maxFeePerBlobGas?: bigint; maxFeePerGas?: bigint; maxPriorityFeePerGas?: bigint; nonce?: number; sidecars?: readonly BlobSidecar<`0x${string}`>[]; to: `0x${string}` | null; type?: "eip4844"; value?: bigint; }, "from"> | Omit<{ accessList?: AccessList; authorizationList?: undefined; blobs: readonly `0x${string}`[] | readonly ByteArray[]; blobVersionedHashes?: readonly `0x${string}`[]; data?: `0x${string}`; from?: `0x${string}`; gas?: bigint; gasPrice?: undefined; kzg?: Kzg; maxFeePerBlobGas?: bigint; maxFeePerGas?: bigint; maxPriorityFeePerGas?: bigint; nonce?: number; sidecars?: readonly BlobSidecar<`0x${string}`>[]; to: `0x${string}` | null; type?: "eip4844"; value?: bigint; }, "from"> | Omit<{ accessList?: AccessList; authorizationList?: AuthorizationList<number, boolean>; blobs?: undefined; blobVersionedHashes?: undefined; data?: `0x${string}`; from?: `0x${string}`; gas?: bigint; gasPrice?: undefined; kzg?: undefined; maxFeePerBlobGas?: undefined; maxFeePerGas?: bigint; maxPriorityFeePerGas?: bigint; nonce?: number; sidecars?: undefined; to?: `0x${string}` | null; type?: "eip7702"; value?: bigint; }, "from"> & object & object

chainOverride

chainOverride extends Chain | undefined = undefined

accountOverride

accountOverride extends `0x${string}` | Account | undefined = undefined

Parameters

args

PrepareTransactionRequestParameters<Chain, Account | undefined, chainOverride, accountOverride, request>

PrepareTransactionRequestParameters

Returns

Promise<{ [K in string | number | symbol]: (UnionRequiredBy<Extract<UnionOmit<(…), (…)> & ((…) extends (…) ? (…) : (…)) & ((…) extends (…) ? (…) : (…)), IsNever<(…)> extends true ? unknown : ExactPartial<(…)>> & { chainId?: number }, ParameterTypeToParameters<request[“parameters”] extends readonly PrepareTransactionRequestParameterType[] ? any[any][number] : “type” | “gas” | “nonce” | “blobVersionedHashes” | “fees” | “chainId”>> & (unknown extends request[“kzg”] ? {} : Pick<request, “kzg”>) & { _capabilities?: { [key: string]: any } })[K] }>

The transaction request. PrepareTransactionRequestReturnType

Examples

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,
})

// 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,
})

readContract

readContract: <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

Type Parameters

abi

abi extends Abi | readonly unknown[]

functionName

functionName extends string

args

args extends unknown

Parameters

args

ReadContractParameters<abi, functionName, args>

ReadContractParameters

Returns

Promise<ReadContractReturnType<abi, functionName, args>>

The response from the contract. Type is inferred. ReadContractReturnType

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.

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

request

request: EIP1193RequestFn<PublicRpcSchema>

Request function wrapped with friendly error handling

sendRawTransaction

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

Parameters

args

SendRawTransactionParameters

Returns

Promise<`0x${string}`>

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'
})

sendRawTransactionSync

sendRawTransactionSync: (args) => Promise<TransactionReceipt>

Sends a signed transaction to the network

• Docs: https://viem.sh/docs/actions/wallet/sendRawTransactionSync
• JSON-RPC Method: eth_sendRawTransactionSync

Parameters

args

SendRawTransactionSyncParameters

Returns

Promise<TransactionReceipt>

The transaction receipt. SendRawTransactionSyncReturnType

Example

import { createWalletClient, custom } from 'viem'
import { mainnet } from 'viem/chains'
import { sendRawTransactionSync } from 'viem/wallet'

const client = createWalletClient({
  chain: mainnet,
  transport: custom(window.ethereum),
})

const receipt = await client.sendRawTransactionSync({
  serializedTransaction: '0x02f850018203118080825208808080c080a04012522854168b27e5dc3d5839bab5e6b39e1a0ffd343901ce1622e3d64b48f1a04e00902ae0502c4728cbf12156290df99c3ed7de85b1dbfe20b5c36931733a33'
})

simulate

simulate: <calls>(args) => Promise<SimulateBlocksReturnType<calls>>

Deprecated

Use simulateBlocks instead.

Type Parameters

calls

calls extends readonly unknown[]

Parameters

args

SimulateBlocksParameters<calls>

Returns

Promise<SimulateBlocksReturnType<calls>>

simulateBlocks

simulateBlocks: <calls>(args) => Promise<SimulateBlocksReturnType<calls>>

Simulates a set of calls on block(s) with optional block and state overrides.

Type Parameters

calls

calls extends readonly unknown[]

Parameters

args

SimulateBlocksParameters<calls>

Returns

Promise<SimulateBlocksReturnType<calls>>

Simulated blocks. SimulateReturnType

Example

import { createPublicClient, http, parseEther } from 'viem'
import { mainnet } from 'viem/chains'

const client = createPublicClient({
  chain: mainnet,
  transport: http(),
})

const result = await client.simulateBlocks({
  blocks: [{
    blockOverrides: {
      number: 69420n,
    },
    calls: [{
      {
        account: '0x5a0b54d5dc17e482fe8b0bdca5320161b95fb929',
        data: '0xdeadbeef',
        to: '0x70997970c51812dc3a010c7d01b50e0d17dc79c8',
      },
      {
        account: '0x5a0b54d5dc17e482fe8b0bdca5320161b95fb929',
        to: '0x70997970c51812dc3a010c7d01b50e0d17dc79c8',
        value: parseEther('1'),
      },
    }],
    stateOverrides: [{
      address: '0x5a0b54d5dc17e482fe8b0bdca5320161b95fb929',
      balance: parseEther('10'),
    }],
  }]
})

simulateCalls

simulateCalls: <calls>(args) => Promise<SimulateCallsReturnType<calls>>

Simulates a set of calls.

Type Parameters

calls

calls extends readonly unknown[]

Parameters

args

SimulateCallsParameters<calls>

Returns

Promise<SimulateCallsReturnType<calls>>

Results. SimulateCallsReturnType

Example

import { createPublicClient, http, parseEther } from 'viem'
import { mainnet } from 'viem/chains'

const client = createPublicClient({
  chain: mainnet,
  transport: http(),
})

const result = await client.simulateCalls({
  account: '0x5a0b54d5dc17e482fe8b0bdca5320161b95fb929',
  calls: [{
    {
      data: '0xdeadbeef',
      to: '0x70997970c51812dc3a010c7d01b50e0d17dc79c8',
    },
    {
      to: '0x70997970c51812dc3a010c7d01b50e0d17dc79c8',
      value: parseEther('1'),
    },
  ]
})

simulateContract

simulateContract: <abi, functionName, args, chainOverride, accountOverride>(args) => Promise<SimulateContractReturnType<abi, functionName, args, Chain, Account | undefined, 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

Type Parameters

abi

abi extends Abi | readonly unknown[]

functionName

functionName extends string

args

args extends unknown

chainOverride

chainOverride extends Chain | undefined

accountOverride

accountOverride extends `0x${string}` | Account | undefined = undefined

Parameters

args

SimulateContractParameters<abi, functionName, args, Chain, chainOverride, accountOverride>

SimulateContractParameters

Returns

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

The simulation result and write request. SimulateContractReturnType

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.

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',
})

transport

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

The RPC transport

type

type: string

The type of client.

uid

uid: string

A unique ID for the client.

uninstallFilter

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

Parameters

args

UninstallFilterParameters

UninstallFilterParameters

Returns

Promise<boolean>

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

verifyHash

verifyHash: (args) => Promise<boolean>

Verify that a hash was signed by the provided address.

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

Parameters

args

VerifyHashParameters

Returns

Promise<boolean>

Whether or not the signature is valid. VerifyHashReturnType

verifyMessage

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

Parameters

args

address

`0x${string}`

The address that signed the original message.

blockNumber?

bigint

The block number to perform the call against.

blockTag?

BlockTag

The block tag to perform the call against.

Default

'latest'

chain?

Chain | null

The chain to use.

erc6492VerifierAddress?

`0x${string}`

The address of the ERC-6492 signature verifier contract.

factory?

`0x${string}`

factoryData?

`0x${string}`

message

SignableMessage

The message to be verified.

mode?

string & object | "auto" | "eoa"

Chooses which verification path to try first before falling back.

multicallAddress?

`0x${string}`

Multicall3 address for ERC-8010 verification.

signature

`0x${string}` | ByteArray | Signature

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

universalSignatureVerifierAddress?

`0x${string}`

Deprecated

use erc6492VerifierAddress instead.

Returns

Promise<boolean>

Whether or not the signature is valid. VerifyMessageReturnType

verifySiweMessage

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

Parameters

args

address?

`0x${string}`

Ethereum address to check against.

blockNumber?

bigint

The block number to perform the call against.

blockTag?

BlockTag

The block tag to perform the call against.

Default

'latest'

domain?

string

RFC 3986 authority to check against.

message

string

EIP-4361 formatted message.

nonce?

string

Random string to check against.

scheme?

string

RFC 3986 URI scheme to check against.

signature

`0x${string}`

Signature to check against.

time?

Date

Current time to check optional expirationTime and notBefore fields.

Default

new Date()

Returns

Promise<boolean>

Whether or not the signature is valid. VerifySiweMessageReturnType

verifyTypedData

verifyTypedData: (args) => Promise<boolean>

Verify that typed data was signed by the provided address.

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

Parameters

args

VerifyTypedDataParameters

Returns

Promise<boolean>

Whether or not the signature is valid. VerifyTypedDataReturnType

waitForTransactionReceipt

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.

Parameters

args

WaitForTransactionReceiptParameters<Chain>

WaitForTransactionReceiptParameters

Returns

Promise<TransactionReceipt>

The transaction receipt. WaitForTransactionReceiptReturnType

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)

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',
})

watchBlockNumber

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.

Parameters

args

WatchBlockNumberParameters

WatchBlockNumberParameters

Returns

WatchBlockNumberReturnType

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),
})

watchBlocks

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.

Type Parameters

includeTransactions

includeTransactions extends boolean = false

blockTag

blockTag extends BlockTag = "latest"

Parameters

args

WatchBlocksParameters<Transport, Chain, includeTransactions, blockTag>

WatchBlocksParameters

Returns

WatchBlocksReturnType

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),
})

watchContractEvent

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

Watches and returns emitted contract event logs.

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

Type Parameters

abi

abi extends Abi | readonly unknown[]

eventName

eventName extends string

strict

strict extends boolean | undefined = undefined

Parameters

args

WatchContractEventParameters<abi, eventName, strict, Transport>

WatchContractEventParameters

Returns

WatchContractEventReturnType

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

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.

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),
})

watchEvent

watchEvent: <abiEvent, 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.

Type Parameters

abiEvent

abiEvent extends AbiEvent | undefined = undefined

abiEvents

abiEvents extends readonly unknown[] | readonly AbiEvent[] | undefined = abiEvent extends AbiEvent ? [abiEvent] : undefined

strict

strict extends boolean | undefined = undefined

Parameters

args

WatchEventParameters<abiEvent, abiEvents, strict, Transport>

WatchEventParameters

Returns

WatchEventReturnType

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

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.

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),
})

watchPendingTransactions

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.

Parameters

args

WatchPendingTransactionsParameters<Transport>

WatchPendingTransactionsParameters

Returns

WatchPendingTransactionsReturnType

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

Remarks

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

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),
})

---

receiptTimeoutMs?

readonly optional receiptTimeoutMs?: number

Defined in: src/x402/facilitator.ts:229

Timeout (ms) for waitForTransactionReceipt during settle. Defaults to 60_000.

---

walletClient

readonly walletClient: object

Defined in: src/x402/facilitator.ts:219

Pre-configured wallet client that broadcasts settlement transactions. The bound account pays gas. walletClient.chain.id determines the only chain this facilitator serves, and walletClient.chain.isTestnet MUST agree with the declared network.

account

account: Account

The Account of the Client.

addChain

addChain: (args) => Promise<void>

Adds an EVM chain to the wallet.

• Docs: https://viem.sh/docs/actions/wallet/addChain
• JSON-RPC Methods: eth_addEthereumChain

Parameters

args

AddChainParameters

AddChainParameters

Returns

Promise<void>

Example

import { createWalletClient, custom } from 'viem'
import { optimism } from 'viem/chains'

const client = createWalletClient({
  transport: custom(window.ethereum),
})
await client.addChain({ chain: optimism })

batch?

optional batch?: object

Flags for batch settings.

batch.multicall?

optional multicall?: boolean | { batchSize?: number; deployless?: boolean; wait?: number; }

Toggle to enable eth_call multicall aggregation.

Union Members

boolean

---

Type Literal

{ batchSize?: number; deployless?: boolean; wait?: number; }

batchSize?

optional batchSize?: number

The maximum size (in bytes) for each calldata chunk.

Default

1_024

deployless?

optional deployless?: boolean

Enable deployless multicall.

wait?

optional wait?: number

The maximum number of milliseconds to wait before sending a batch.

Default

0

cacheTime

cacheTime: number

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

ccipRead?

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

CCIP Read configuration.

Union Members

false

---

Type Literal

{ request?: (parameters) => Promise<`0x${string}`>; }

request?

optional request?: (parameters) => Promise<`0x${string}`>

A function that will be called to make the offchain CCIP lookup request.

Parameters

parameters

CcipRequestParameters

Returns

Promise<`0x${string}`>

See

https://eips.ethereum.org/EIPS/eip-3668#client-lookup-protocol

chain

chain: Chain

Chain for the client.

dataSuffix?

optional dataSuffix?: DataSuffix

Data suffix to append to transaction data.

deployContract

deployContract: <abi, chainOverride>(args) => Promise<`0x${string}`>

Deploys a contract to the network, given bytecode and constructor arguments.

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

Type Parameters

abi

abi extends Abi | readonly unknown[]

chainOverride

chainOverride extends Chain | undefined

Parameters

args

DeployContractParameters<abi, Chain, Account, chainOverride>

DeployContractParameters

Returns

Promise<`0x${string}`>

The Transaction hash. DeployContractReturnType

Example

import { createWalletClient, http } from 'viem'
import { privateKeyToAccount } from 'viem/accounts'
import { mainnet } from 'viem/chains'

const client = createWalletClient({
  account: privateKeyToAccount('0x…'),
  chain: mainnet,
  transport: http(),
})
const hash = await client.deployContract({
  abi: [],
  account: '0x…,
  bytecode: '0x608060405260405161083e38038061083e833981016040819052610...',
})

experimental_blockTag?

optional experimental_blockTag?: BlockTag

Default block tag to use for RPC requests.

extend

extend: <client>(fn) => Client<Transport, Chain, Account, WalletRpcSchema, { [K in string | number | symbol]: client[K] } & WalletActions<Chain, Account>>

Type Parameters

client

client extends object & ExactPartial<ExtendableProtectedActions<Transport, Chain, Account>>

Parameters

fn

(client) => client

Returns

Client<Transport, Chain, Account, WalletRpcSchema, { [K in string | number | symbol]: client[K] } & WalletActions<Chain, Account>>

fillTransaction

fillTransaction: <chainOverride, accountOverride>(args) => Promise<FillTransactionReturnType<Chain, chainOverride>>

Fills a transaction request with the necessary fields to be signed over.

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

Type Parameters

chainOverride

chainOverride extends Chain | undefined = undefined

accountOverride

accountOverride extends `0x${string}` | Account | undefined = undefined

Parameters

args

FillTransactionParameters<Chain, Account, chainOverride, accountOverride>

Returns

Promise<FillTransactionReturnType<Chain, chainOverride>>

The filled transaction. FillTransactionReturnType

Example

import { createWalletClient, custom } from 'viem'
import { mainnet } from 'viem/chains'

const client = createWalletClient({
  chain: mainnet,
  transport: custom(window.ethereum),
})
const result = await client.fillTransaction({
  account: '0xA0Cf798816D4b9b9866b5330EEa46a18382f251e',
  to: '0x70997970c51812dc3a010c7d01b50e0d17dc79c8',
  value: parseEther('1'),
})

getAddresses

getAddresses: () => Promise<GetAddressesReturnType>

Returns a list of account addresses owned by the wallet or client.

• Docs: https://viem.sh/docs/actions/wallet/getAddresses
• JSON-RPC Methods: eth_accounts

Returns

Promise<GetAddressesReturnType>

List of account addresses owned by the wallet or client. GetAddressesReturnType

Example

import { createWalletClient, custom } from 'viem'
import { mainnet } from 'viem/chains'

const client = createWalletClient({
  chain: mainnet,
  transport: custom(window.ethereum),
})
const accounts = await client.getAddresses()

getCallsStatus

getCallsStatus: (parameters) => Promise<{ atomic: boolean; capabilities?: {[key: string]: any; } | {[key: string]: any; }; chainId: number; id: string; receipts?: WalletCallReceipt<bigint, "success" | "reverted">[]; status: "pending" | "success" | "failure" | undefined; statusCode: number; version: string; }>

Returns the status of a call batch that was sent via sendCalls.

• Docs: https://viem.sh/docs/actions/wallet/getCallsStatus
• JSON-RPC Methods: wallet_getCallsStatus

Parameters

parameters

GetCallsStatusParameters

Returns

Promise<{ atomic: boolean; capabilities?: {[key: string]: any; } | {[key: string]: any; }; chainId: number; id: string; receipts?: WalletCallReceipt<bigint, "success" | "reverted">[]; status: "pending" | "success" | "failure" | undefined; statusCode: number; version: string; }>

Status of the calls. GetCallsStatusReturnType

Example

import { createWalletClient, custom } from 'viem'
import { mainnet } from 'viem/chains'

const client = createWalletClient({
  chain: mainnet,
  transport: custom(window.ethereum),
})

const { receipts, status } = await client.getCallsStatus({ id: '0xdeadbeef' })

getCapabilities

getCapabilities: <chainId>(parameters?) => Promise<{ [K in string | number | symbol]: (chainId extends number ? { atomic?: { status: “supported” | “ready” | “unsupported” }; paymasterService?: { supported: boolean }; unstable_addSubAccount?: { keyTypes: ((…) | (…) | (…) | (…))[]; supported: boolean }; [key: string]: any } : ChainIdToCapabilities<Capabilities<{ atomic?: { status: … }; paymasterService?: { supported: … }; unstable_addSubAccount?: { keyTypes: …; supported: … }; [key: string]: any }>, number>)[K] }>

Extract capabilities that a connected wallet supports (e.g. paymasters, session keys, etc).

• Docs: https://viem.sh/docs/actions/wallet/getCapabilities
• JSON-RPC Methods: wallet_getCapabilities

Type Parameters

chainId

chainId extends number | undefined

Parameters

parameters?

GetCapabilitiesParameters<chainId>

Returns

Promise<{ [K in string | number | symbol]: (chainId extends number ? { atomic?: { status: “supported” | “ready” | “unsupported” }; paymasterService?: { supported: boolean }; unstable_addSubAccount?: { keyTypes: ((…) | (…) | (…) | (…))[]; supported: boolean }; [key: string]: any } : ChainIdToCapabilities<Capabilities<{ atomic?: { status: … }; paymasterService?: { supported: … }; unstable_addSubAccount?: { keyTypes: …; supported: … }; [key: string]: any }>, number>)[K] }>

The wallet’s capabilities. GetCapabilitiesReturnType

Example

import { createWalletClient, custom } from 'viem'
import { mainnet } from 'viem/chains'

const client = createWalletClient({
  chain: mainnet,
  transport: custom(window.ethereum),
})

const capabilities = await client.getCapabilities({
  account: '0xA0Cf798816D4b9b9866b5330EEa46a18382f251e',
})

getChainId

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

Promise<number>

The current chain ID. GetChainIdReturnType

Example

import { createWalletClient, http } from 'viem'
import { mainnet } from 'viem/chains'

const client = createWalletClient({
  chain: mainnet,
  transport: custom(window.ethereum),
})
const chainId = await client.getChainId()
// 1

getPermissions

getPermissions: () => Promise<GetPermissionsReturnType>

Gets the wallets current permissions.

• Docs: https://viem.sh/docs/actions/wallet/getPermissions
• JSON-RPC Methods: wallet_getPermissions

Returns

Promise<GetPermissionsReturnType>

The wallet permissions. GetPermissionsReturnType

Example

import { createWalletClient, custom } from 'viem'
import { mainnet } from 'viem/chains'

const client = createWalletClient({
  chain: mainnet,
  transport: custom(window.ethereum),
})
const permissions = await client.getPermissions()

key

key: string

A key for the client.

name

name: string

A name for the client.

pollingInterval

pollingInterval: number

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

prepareAuthorization

prepareAuthorization: (parameters) => Promise<PrepareAuthorizationReturnType>

Prepares an EIP-7702 Authorization object for signing. This Action will fill the required fields of the Authorization object if they are not provided (e.g. nonce and chainId).

With the prepared Authorization object, you can use signAuthorization to sign over the Authorization object.

Parameters

parameters

PrepareAuthorizationParameters<Account>

PrepareAuthorizationParameters

Returns

Promise<PrepareAuthorizationReturnType>

The prepared Authorization object. PrepareAuthorizationReturnType

Examples

import { createWalletClient, http } from 'viem'
import { privateKeyToAccount } from 'viem/accounts'
import { mainnet } from 'viem/chains'

const client = createWalletClient({
  chain: mainnet,
  transport: http(),
})

const authorization = await client.prepareAuthorization({
  account: privateKeyToAccount('0x..'),
  contractAddress: '0xA0Cf798816D4b9b9866b5330EEa46a18382f251e',
})

// 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: http(),
})

const authorization = await client.prepareAuthorization({
  contractAddress: '0xA0Cf798816D4b9b9866b5330EEa46a18382f251e',
})

prepareTransactionRequest

prepareTransactionRequest: <request, chainOverride, accountOverride>(args) => Promise<{ [K in string | number | symbol]: (UnionRequiredBy<Extract<UnionOmit<(…), (…)> & ((…) extends (…) ? (…) : (…)) & ((…) extends (…) ? (…) : (…)), IsNever<(…)> extends true ? unknown : ExactPartial<(…)>> & { chainId?: number }, ParameterTypeToParameters<request[“parameters”] extends readonly PrepareTransactionRequestParameterType[] ? any[any][number] : “type” | “gas” | “nonce” | “blobVersionedHashes” | “fees” | “chainId”>> & (unknown extends request[“kzg”] ? {} : Pick<request, “kzg”>) & { _capabilities?: { [key: string]: any } })[K] }>

Prepares a transaction request for signing.

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

Type Parameters

request

request extends Omit<{ accessList?: undefined; authorizationList?: undefined; blobs?: undefined; blobVersionedHashes?: undefined; data?: `0x${string}`; from?: `0x${string}`; gas?: bigint; gasPrice?: bigint; kzg?: undefined; maxFeePerBlobGas?: undefined; maxFeePerGas?: undefined; maxPriorityFeePerGas?: undefined; nonce?: number; sidecars?: undefined; to?: `0x${string}` | null; type?: "legacy"; value?: bigint; }, "from"> | Omit<{ accessList?: AccessList; authorizationList?: undefined; blobs?: undefined; blobVersionedHashes?: undefined; data?: `0x${string}`; from?: `0x${string}`; gas?: bigint; gasPrice?: bigint; kzg?: undefined; maxFeePerBlobGas?: undefined; maxFeePerGas?: undefined; maxPriorityFeePerGas?: undefined; nonce?: number; sidecars?: undefined; to?: `0x${string}` | null; type?: "eip2930"; value?: bigint; }, "from"> | Omit<{ accessList?: AccessList; authorizationList?: undefined; blobs?: undefined; blobVersionedHashes?: undefined; data?: `0x${string}`; from?: `0x${string}`; gas?: bigint; gasPrice?: undefined; kzg?: undefined; maxFeePerBlobGas?: undefined; maxFeePerGas?: bigint; maxPriorityFeePerGas?: bigint; nonce?: number; sidecars?: undefined; to?: `0x${string}` | null; type?: "eip1559"; value?: bigint; }, "from"> | Omit<{ accessList?: AccessList; authorizationList?: undefined; blobs?: readonly `0x${string}`[] | readonly ByteArray[]; blobVersionedHashes: readonly `0x${string}`[]; data?: `0x${string}`; from?: `0x${string}`; gas?: bigint; gasPrice?: undefined; kzg?: undefined; maxFeePerBlobGas?: bigint; maxFeePerGas?: bigint; maxPriorityFeePerGas?: bigint; nonce?: number; sidecars?: readonly BlobSidecar<`0x${string}`>[]; to: `0x${string}` | null; type?: "eip4844"; value?: bigint; }, "from"> | Omit<{ accessList?: AccessList; authorizationList?: undefined; blobs: readonly `0x${string}`[] | readonly ByteArray[]; blobVersionedHashes?: readonly `0x${string}`[]; data?: `0x${string}`; from?: `0x${string}`; gas?: bigint; gasPrice?: undefined; kzg?: Kzg; maxFeePerBlobGas?: bigint; maxFeePerGas?: bigint; maxPriorityFeePerGas?: bigint; nonce?: number; sidecars?: readonly BlobSidecar<`0x${string}`>[]; to: `0x${string}` | null; type?: "eip4844"; value?: bigint; }, "from"> | Omit<{ accessList?: AccessList; authorizationList?: AuthorizationList<number, boolean>; blobs?: undefined; blobVersionedHashes?: undefined; data?: `0x${string}`; from?: `0x${string}`; gas?: bigint; gasPrice?: undefined; kzg?: undefined; maxFeePerBlobGas?: undefined; maxFeePerGas?: bigint; maxPriorityFeePerGas?: bigint; nonce?: number; sidecars?: undefined; to?: `0x${string}` | null; type?: "eip7702"; value?: bigint; }, "from"> & object & object

chainOverride

chainOverride extends Chain | undefined = undefined

accountOverride

accountOverride extends `0x${string}` | Account | undefined = undefined

Parameters

args

PrepareTransactionRequestParameters<Chain, Account, chainOverride, accountOverride, request>

PrepareTransactionRequestParameters

Returns

Promise<{ [K in string | number | symbol]: (UnionRequiredBy<Extract<UnionOmit<(…), (…)> & ((…) extends (…) ? (…) : (…)) & ((…) extends (…) ? (…) : (…)), IsNever<(…)> extends true ? unknown : ExactPartial<(…)>> & { chainId?: number }, ParameterTypeToParameters<request[“parameters”] extends readonly PrepareTransactionRequestParameterType[] ? any[any][number] : “type” | “gas” | “nonce” | “blobVersionedHashes” | “fees” | “chainId”>> & (unknown extends request[“kzg”] ? {} : Pick<request, “kzg”>) & { _capabilities?: { [key: string]: any } })[K] }>

The transaction request. PrepareTransactionRequestReturnType

Examples

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,
})

// 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,
})

request

request: EIP1193RequestFn<WalletRpcSchema>

Request function wrapped with friendly error handling

requestAddresses

requestAddresses: () => Promise<RequestAddressesReturnType>

Requests a list of accounts managed by a wallet.

• Docs: https://viem.sh/docs/actions/wallet/requestAddresses
• JSON-RPC Methods: eth_requestAccounts

Sends a request to the wallet, asking for permission to access the user’s accounts. After the user accepts the request, it will return a list of accounts (addresses).

This API can be useful for dapps that need to access the user’s accounts in order to execute transactions or interact with smart contracts.

Returns

Promise<RequestAddressesReturnType>

List of accounts managed by a wallet RequestAddressesReturnType

Example

import { createWalletClient, custom } from 'viem'
import { mainnet } from 'viem/chains'

const client = createWalletClient({
  chain: mainnet,
  transport: custom(window.ethereum),
})
const accounts = await client.requestAddresses()

requestPermissions

requestPermissions: (args) => Promise<RequestPermissionsReturnType>

Requests permissions for a wallet.

• Docs: https://viem.sh/docs/actions/wallet/requestPermissions
• JSON-RPC Methods: wallet_requestPermissions

Parameters

args

RequestPermissionsParameters

eth_accounts

Record<string, any>

Returns

Promise<RequestPermissionsReturnType>

The wallet permissions. RequestPermissionsReturnType

Example

import { createWalletClient, custom } from 'viem'
import { mainnet } from 'viem/chains'

const client = createWalletClient({
  chain: mainnet,
  transport: custom(window.ethereum),
})
const permissions = await client.requestPermissions({
  eth_accounts: {}
})

sendCalls

sendCalls: <calls, chainOverride>(parameters) => Promise<{ capabilities?: {[key: string]: any; }; id: string; }>

Requests the connected wallet to send a batch of calls.

• Docs: https://viem.sh/docs/actions/wallet/sendCalls
• JSON-RPC Methods: wallet_sendCalls

Type Parameters

calls

calls extends readonly unknown[]

chainOverride

chainOverride extends Chain | undefined = undefined

Parameters

parameters

SendCallsParameters<Chain, Account, chainOverride, calls>

Returns

Promise<{ capabilities?: {[key: string]: any; }; id: string; }>

Transaction identifier. SendCallsReturnType

Example

import { createWalletClient, custom } from 'viem'
import { mainnet } from 'viem/chains'

const client = createWalletClient({
  chain: mainnet,
  transport: custom(window.ethereum),
})

const id = await client.sendCalls({
  account: '0xA0Cf798816D4b9b9866b5330EEa46a18382f251e',
  calls: [
    {
      data: '0xdeadbeef',
      to: '0x70997970c51812dc3a010c7d01b50e0d17dc79c8',
    },
    {
      to: '0x70997970c51812dc3a010c7d01b50e0d17dc79c8',
      value: 69420n,
    },
  ],
})

sendCallsSync

sendCallsSync: <calls, chainOverride>(parameters) => Promise<{ atomic: boolean; capabilities?: {[key: string]: any; } | {[key: string]: any; }; chainId: number; id: string; receipts?: WalletCallReceipt<bigint, "success" | "reverted">[]; status: "pending" | "success" | "failure" | undefined; statusCode: number; version: string; }>

Requests the connected wallet to send a batch of calls, and waits for the calls to be included in a block.

• Docs: https://viem.sh/docs/actions/wallet/sendCallsSync
• JSON-RPC Methods: wallet_sendCalls

Type Parameters

calls

calls extends readonly unknown[]

chainOverride

chainOverride extends Chain | undefined = undefined

Parameters

parameters

SendCallsSyncParameters<Chain, Account, chainOverride, calls>

Returns

Promise<{ atomic: boolean; capabilities?: {[key: string]: any; } | {[key: string]: any; }; chainId: number; id: string; receipts?: WalletCallReceipt<bigint, "success" | "reverted">[]; status: "pending" | "success" | "failure" | undefined; statusCode: number; version: string; }>

Calls status. SendCallsSyncReturnType

Example

import { createWalletClient, custom } from 'viem'
import { mainnet } from 'viem/chains'

const client = createWalletClient({
  chain: mainnet,
  transport: custom(window.ethereum),
})

const status = await client.sendCallsSync({
  account: '0xA0Cf798816D4b9b9866b5330EEa46a18382f251e',
  calls: [
    {
      data: '0xdeadbeef',
      to: '0x70997970c51812dc3a010c7d01b50e0d17dc79c8',
    },
    {
      to: '0x70997970c51812dc3a010c7d01b50e0d17dc79c8',
      value: 69420n,
    },
  ],
})

sendRawTransaction

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

Parameters

args

SendRawTransactionParameters

Returns

Promise<`0x${string}`>

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'
})

sendRawTransactionSync

sendRawTransactionSync: (args) => Promise<TransactionReceipt>

Sends a signed transaction to the network synchronously, and waits for the transaction to be included in a block.

• Docs: https://viem.sh/docs/actions/wallet/sendRawTransactionSync
• JSON-RPC Method: eth_sendRawTransactionSync

Parameters

args

SendRawTransactionSyncParameters

Returns

Promise<TransactionReceipt>

The transaction receipt. SendRawTransactionSyncReturnType

Example

import { createWalletClient, custom } from 'viem'
import { mainnet } from 'viem/chains'
import { sendRawTransactionSync } from 'viem/wallet'

const client = createWalletClient({
  chain: mainnet,
  transport: custom(window.ethereum),
})

const receipt = await client.sendRawTransactionSync({
  serializedTransaction: '0x02f850018203118080825208808080c080a04012522854168b27e5dc3d5839bab5e6b39e1a0ffd343901ce1622e3d64b48f1a04e00902ae0502c4728cbf12156290df99c3ed7de85b1dbfe20b5c36931733a33'
})

sendTransaction

sendTransaction: <request, chainOverride>(args) => Promise<`0x${string}`>

Creates, signs, and sends a new transaction to the network.

• Docs: https://viem.sh/docs/actions/wallet/sendTransaction
• Examples: https://stackblitz.com/github/wevm/viem/tree/main/examples/transactions_sending-transactions
• JSON-RPC Methods:
  • JSON-RPC Accounts: eth_sendTransaction
  • Local Accounts: eth_sendRawTransaction

Type Parameters

request

request extends Omit<{ accessList?: undefined; authorizationList?: undefined; blobs?: undefined; blobVersionedHashes?: undefined; data?: `0x${string}`; from?: `0x${string}`; gas?: bigint; gasPrice?: bigint; kzg?: undefined; maxFeePerBlobGas?: undefined; maxFeePerGas?: undefined; maxPriorityFeePerGas?: undefined; nonce?: number; sidecars?: undefined; to?: `0x${string}` | null; type?: "legacy"; value?: bigint; }, "from"> | Omit<{ accessList?: AccessList; authorizationList?: undefined; blobs?: undefined; blobVersionedHashes?: undefined; data?: `0x${string}`; from?: `0x${string}`; gas?: bigint; gasPrice?: bigint; kzg?: undefined; maxFeePerBlobGas?: undefined; maxFeePerGas?: undefined; maxPriorityFeePerGas?: undefined; nonce?: number; sidecars?: undefined; to?: `0x${string}` | null; type?: "eip2930"; value?: bigint; }, "from"> | Omit<{ accessList?: AccessList; authorizationList?: undefined; blobs?: undefined; blobVersionedHashes?: undefined; data?: `0x${string}`; from?: `0x${string}`; gas?: bigint; gasPrice?: undefined; kzg?: undefined; maxFeePerBlobGas?: undefined; maxFeePerGas?: bigint; maxPriorityFeePerGas?: bigint; nonce?: number; sidecars?: undefined; to?: `0x${string}` | null; type?: "eip1559"; value?: bigint; }, "from"> | Omit<{ accessList?: AccessList; authorizationList?: undefined; blobs?: readonly `0x${string}`[] | readonly ByteArray[]; blobVersionedHashes: readonly `0x${string}`[]; data?: `0x${string}`; from?: `0x${string}`; gas?: bigint; gasPrice?: undefined; kzg?: undefined; maxFeePerBlobGas?: bigint; maxFeePerGas?: bigint; maxPriorityFeePerGas?: bigint; nonce?: number; sidecars?: readonly BlobSidecar<`0x${string}`>[]; to: `0x${string}` | null; type?: "eip4844"; value?: bigint; }, "from"> | Omit<{ accessList?: AccessList; authorizationList?: undefined; blobs: readonly `0x${string}`[] | readonly ByteArray[]; blobVersionedHashes?: readonly `0x${string}`[]; data?: `0x${string}`; from?: `0x${string}`; gas?: bigint; gasPrice?: undefined; kzg?: Kzg; maxFeePerBlobGas?: bigint; maxFeePerGas?: bigint; maxPriorityFeePerGas?: bigint; nonce?: number; sidecars?: readonly BlobSidecar<`0x${string}`>[]; to: `0x${string}` | null; type?: "eip4844"; value?: bigint; }, "from"> | Omit<{ accessList?: AccessList; authorizationList?: AuthorizationList<number, boolean>; blobs?: undefined; blobVersionedHashes?: undefined; data?: `0x${string}`; from?: `0x${string}`; gas?: bigint; gasPrice?: undefined; kzg?: undefined; maxFeePerBlobGas?: undefined; maxFeePerGas?: bigint; maxPriorityFeePerGas?: bigint; nonce?: number; sidecars?: undefined; to?: `0x${string}` | null; type?: "eip7702"; value?: bigint; }, "from"> & object

chainOverride

chainOverride extends Chain | undefined = undefined

Parameters

args

SendTransactionParameters<Chain, Account, chainOverride, request>

SendTransactionParameters

Returns

Promise<`0x${string}`>

The Transaction hash. SendTransactionReturnType

Examples

import { createWalletClient, custom } from 'viem'
import { mainnet } from 'viem/chains'

const client = createWalletClient({
  chain: mainnet,
  transport: custom(window.ethereum),
})
const hash = await client.sendTransaction({
  account: '0xA0Cf798816D4b9b9866b5330EEa46a18382f251e',
  to: '0x70997970c51812dc3a010c7d01b50e0d17dc79c8',
  value: 1000000000000000000n,
})

// 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: http(),
})
const hash = await client.sendTransaction({
  to: '0x70997970c51812dc3a010c7d01b50e0d17dc79c8',
  value: 1000000000000000000n,
})

sendTransactionSync

sendTransactionSync: <request, chainOverride>(args) => Promise<TransactionReceipt>

Creates, signs, and sends a new transaction to the network synchronously. Returns the transaction receipt.

• Docs: https://viem.sh/docs/actions/wallet/sendTransactionSync
• Examples: https://stackblitz.com/github/wevm/viem/tree/main/examples/transactions_sending-transactions
• JSON-RPC Methods:
  • JSON-RPC Accounts: eth_sendTransaction
  • Local Accounts: eth_sendRawTransaction

Type Parameters

request

request extends Omit<{ accessList?: undefined; authorizationList?: undefined; blobs?: undefined; blobVersionedHashes?: undefined; data?: `0x${string}`; from?: `0x${string}`; gas?: bigint; gasPrice?: bigint; kzg?: undefined; maxFeePerBlobGas?: undefined; maxFeePerGas?: undefined; maxPriorityFeePerGas?: undefined; nonce?: number; sidecars?: undefined; to?: `0x${string}` | null; type?: "legacy"; value?: bigint; }, "from"> | Omit<{ accessList?: AccessList; authorizationList?: undefined; blobs?: undefined; blobVersionedHashes?: undefined; data?: `0x${string}`; from?: `0x${string}`; gas?: bigint; gasPrice?: bigint; kzg?: undefined; maxFeePerBlobGas?: undefined; maxFeePerGas?: undefined; maxPriorityFeePerGas?: undefined; nonce?: number; sidecars?: undefined; to?: `0x${string}` | null; type?: "eip2930"; value?: bigint; }, "from"> | Omit<{ accessList?: AccessList; authorizationList?: undefined; blobs?: undefined; blobVersionedHashes?: undefined; data?: `0x${string}`; from?: `0x${string}`; gas?: bigint; gasPrice?: undefined; kzg?: undefined; maxFeePerBlobGas?: undefined; maxFeePerGas?: bigint; maxPriorityFeePerGas?: bigint; nonce?: number; sidecars?: undefined; to?: `0x${string}` | null; type?: "eip1559"; value?: bigint; }, "from"> | Omit<{ accessList?: AccessList; authorizationList?: undefined; blobs?: readonly `0x${string}`[] | readonly ByteArray[]; blobVersionedHashes: readonly `0x${string}`[]; data?: `0x${string}`; from?: `0x${string}`; gas?: bigint; gasPrice?: undefined; kzg?: undefined; maxFeePerBlobGas?: bigint; maxFeePerGas?: bigint; maxPriorityFeePerGas?: bigint; nonce?: number; sidecars?: readonly BlobSidecar<`0x${string}`>[]; to: `0x${string}` | null; type?: "eip4844"; value?: bigint; }, "from"> | Omit<{ accessList?: AccessList; authorizationList?: undefined; blobs: readonly `0x${string}`[] | readonly ByteArray[]; blobVersionedHashes?: readonly `0x${string}`[]; data?: `0x${string}`; from?: `0x${string}`; gas?: bigint; gasPrice?: undefined; kzg?: Kzg; maxFeePerBlobGas?: bigint; maxFeePerGas?: bigint; maxPriorityFeePerGas?: bigint; nonce?: number; sidecars?: readonly BlobSidecar<`0x${string}`>[]; to: `0x${string}` | null; type?: "eip4844"; value?: bigint; }, "from"> | Omit<{ accessList?: AccessList; authorizationList?: AuthorizationList<number, boolean>; blobs?: undefined; blobVersionedHashes?: undefined; data?: `0x${string}`; from?: `0x${string}`; gas?: bigint; gasPrice?: undefined; kzg?: undefined; maxFeePerBlobGas?: undefined; maxFeePerGas?: bigint; maxPriorityFeePerGas?: bigint; nonce?: number; sidecars?: undefined; to?: `0x${string}` | null; type?: "eip7702"; value?: bigint; }, "from"> & object

chainOverride

chainOverride extends Chain | undefined = undefined

Parameters

args

SendTransactionSyncParameters<Chain, Account, chainOverride, request>

SendTransactionParameters

Returns

Promise<TransactionReceipt>

The transaction receipt. SendTransactionReturnType

Examples

import { createWalletClient, custom } from 'viem'
import { mainnet } from 'viem/chains'

const client = createWalletClient({
  chain: mainnet,
  transport: custom(window.ethereum),
})
const receipt = await client.sendTransactionSync({
  account: '0xA0Cf798816D4b9b9866b5330EEa46a18382f251e',
  to: '0x70997970c51812dc3a010c7d01b50e0d17dc79c8',
  value: 1000000000000000000n,
})

// 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: http(),
})
const receipt = await client.sendTransactionSync({
  to: '0x70997970c51812dc3a010c7d01b50e0d17dc79c8',
  value: 1000000000000000000n,
})

showCallsStatus

showCallsStatus: (parameters) => Promise<void>

Requests for the wallet to show information about a call batch that was sent via sendCalls.

• Docs: https://viem.sh/docs/actions/wallet/showCallsStatus
• JSON-RPC Methods: wallet_showCallsStatus

Parameters

parameters

ShowCallsStatusParameters

Returns

Promise<void>

Displays status of the calls in wallet. ShowCallsStatusReturnType

Example

import { createWalletClient, custom } from 'viem'
import { mainnet } from 'viem/chains'

const client = createWalletClient({
  chain: mainnet,
  transport: custom(window.ethereum),
})

await client.showCallsStatus({ id: '0xdeadbeef' })

signAuthorization

signAuthorization: (parameters) => Promise<SignAuthorizationReturnType>

Signs an EIP-7702 Authorization object.

With the calculated signature, you can:

• use verifyAuthorization to verify the signed Authorization object,
• use recoverAuthorizationAddress to recover the signing address from the signed Authorization object.

Parameters

parameters

SignAuthorizationParameters<Account>

SignAuthorizationParameters

Returns

Promise<SignAuthorizationReturnType>

The signed Authorization object. SignAuthorizationReturnType

Examples

import { createWalletClient, http } from 'viem'
import { privateKeyToAccount } from 'viem/accounts'
import { mainnet } from 'viem/chains'

const client = createWalletClient({
  chain: mainnet,
  transport: http(),
})

const signature = await client.signAuthorization({
  account: privateKeyToAccount('0x..'),
  contractAddress: '0xA0Cf798816D4b9b9866b5330EEa46a18382f251e',
})

// 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: http(),
})

const signature = await client.signAuthorization({
  contractAddress: '0xA0Cf798816D4b9b9866b5330EEa46a18382f251e',
})

signMessage

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

Calculates an Ethereum-specific signature in EIP-191 format: keccak256("\x19Ethereum Signed Message:\n" + len(message) + message)).

• Docs: https://viem.sh/docs/actions/wallet/signMessage
• JSON-RPC Methods:
  • JSON-RPC Accounts: personal_sign
  • Local Accounts: Signs locally. No JSON-RPC request.

With the calculated signature, you can:

• use verifyMessage to verify the signature,
• use recoverMessageAddress to recover the signing address from a signature.

Parameters

args

SignMessageParameters<Account>

SignMessageParameters

Returns

Promise<`0x${string}`>

The signed message. SignMessageReturnType

Examples

import { createWalletClient, custom } from 'viem'
import { mainnet } from 'viem/chains'

const client = createWalletClient({
  chain: mainnet,
  transport: custom(window.ethereum),
})
const signature = await client.signMessage({
  account: '0xA0Cf798816D4b9b9866b5330EEa46a18382f251e',
  message: 'hello world',
})

// 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: http(),
})
const signature = await client.signMessage({
  message: 'hello world',
})

signTransaction

signTransaction: <chainOverride, request>(args) => Promise<TransactionSerialized<GetTransactionType<request, request extends LegacyProperties ? "legacy" : never | request extends EIP1559Properties ? "eip1559" : never | request extends EIP2930Properties ? "eip2930" : never | request extends EIP4844Properties ? "eip4844" : never | request extends EIP7702Properties ? "eip7702" : never | request["type"] extends string | undefined ? Extract<any[any], string> : never>, GetTransactionType<request, request extends LegacyProperties ? "legacy" : never | request extends EIP1559Properties ? "eip1559" : never | request extends EIP2930Properties ? "eip2930" : never | request extends EIP4844Properties ? "eip4844" : never | request extends EIP7702Properties ? "eip7702" : never | request["type"] extends string | undefined ? Extract<any[any], string> : never> extends "eip1559" ? `0x02${string}` : never | GetTransactionType<request, request extends LegacyProperties ? "legacy" : never | request extends EIP1559Properties ? "eip1559" : never | request extends EIP2930Properties ? "eip2930" : never | request extends EIP4844Properties ? "eip4844" : never | request extends EIP7702Properties ? "eip7702" : never | request["type"] extends string | undefined ? Extract<any[any], string> : never> extends "eip2930" ? `0x01${string}` : never | GetTransactionType<request, request extends LegacyProperties ? "legacy" : never | request extends EIP1559Properties ? "eip1559" : never | request extends EIP2930Properties ? "eip2930" : never | request extends EIP4844Properties ? "eip4844" : never | request extends EIP7702Properties ? "eip7702" : never | request["type"] extends string | undefined ? Extract<any[any], string> : never> extends "eip4844" ? `0x03${string}` : never | GetTransactionType<request, request extends LegacyProperties ? "legacy" : never | request extends EIP1559Properties ? "eip1559" : never | request extends EIP2930Properties ? "eip2930" : never | request extends EIP4844Properties ? "eip4844" : never | request extends EIP7702Properties ? "eip7702" : never | request["type"] extends string | undefined ? Extract<any[any], string> : never> extends "eip7702" ? `0x04${string}` : never | GetTransactionType<request, request extends LegacyProperties ? "legacy" : never | request extends EIP1559Properties ? "eip1559" : never | request extends EIP2930Properties ? "eip2930" : never | request extends EIP4844Properties ? "eip4844" : never | request extends EIP7702Properties ? "eip7702" : never | request["type"] extends string | undefined ? Extract<any[any], string> : never> extends "legacy" ? TransactionSerializedLegacy : never>>

Signs a transaction.

• Docs: https://viem.sh/docs/actions/wallet/signTransaction
• JSON-RPC Methods:
  • JSON-RPC Accounts: eth_signTransaction
  • Local Accounts: Signs locally. No JSON-RPC request.

Type Parameters

chainOverride

chainOverride extends Chain | undefined

request

request extends Omit<{ accessList?: undefined; authorizationList?: undefined; blobs?: undefined; blobVersionedHashes?: undefined; data?: `0x${string}`; from?: `0x${string}`; gas?: bigint; gasPrice?: bigint; kzg?: undefined; maxFeePerBlobGas?: undefined; maxFeePerGas?: undefined; maxPriorityFeePerGas?: undefined; nonce?: number; sidecars?: undefined; to?: `0x${string}` | null; type?: "legacy"; value?: bigint; }, "from"> | Omit<{ accessList?: AccessList; authorizationList?: undefined; blobs?: undefined; blobVersionedHashes?: undefined; data?: `0x${string}`; from?: `0x${string}`; gas?: bigint; gasPrice?: bigint; kzg?: undefined; maxFeePerBlobGas?: undefined; maxFeePerGas?: undefined; maxPriorityFeePerGas?: undefined; nonce?: number; sidecars?: undefined; to?: `0x${string}` | null; type?: "eip2930"; value?: bigint; }, "from"> | Omit<{ accessList?: AccessList; authorizationList?: undefined; blobs?: undefined; blobVersionedHashes?: undefined; data?: `0x${string}`; from?: `0x${string}`; gas?: bigint; gasPrice?: undefined; kzg?: undefined; maxFeePerBlobGas?: undefined; maxFeePerGas?: bigint; maxPriorityFeePerGas?: bigint; nonce?: number; sidecars?: undefined; to?: `0x${string}` | null; type?: "eip1559"; value?: bigint; }, "from"> | Omit<{ accessList?: AccessList; authorizationList?: undefined; blobs?: readonly `0x${string}`[] | readonly ByteArray[]; blobVersionedHashes: readonly `0x${string}`[]; data?: `0x${string}`; from?: `0x${string}`; gas?: bigint; gasPrice?: undefined; kzg?: undefined; maxFeePerBlobGas?: bigint; maxFeePerGas?: bigint; maxPriorityFeePerGas?: bigint; nonce?: number; sidecars?: readonly BlobSidecar<`0x${string}`>[]; to: `0x${string}` | null; type?: "eip4844"; value?: bigint; }, "from"> | Omit<{ accessList?: AccessList; authorizationList?: undefined; blobs: readonly `0x${string}`[] | readonly ByteArray[]; blobVersionedHashes?: readonly `0x${string}`[]; data?: `0x${string}`; from?: `0x${string}`; gas?: bigint; gasPrice?: undefined; kzg?: Kzg; maxFeePerBlobGas?: bigint; maxFeePerGas?: bigint; maxPriorityFeePerGas?: bigint; nonce?: number; sidecars?: readonly BlobSidecar<`0x${string}`>[]; to: `0x${string}` | null; type?: "eip4844"; value?: bigint; }, "from"> | Omit<{ accessList?: AccessList; authorizationList?: AuthorizationList<number, boolean>; blobs?: undefined; blobVersionedHashes?: undefined; data?: `0x${string}`; from?: `0x${string}`; gas?: bigint; gasPrice?: undefined; kzg?: undefined; maxFeePerBlobGas?: undefined; maxFeePerGas?: bigint; maxPriorityFeePerGas?: bigint; nonce?: number; sidecars?: undefined; to?: `0x${string}` | null; type?: "eip7702"; value?: bigint; }, "from"> = UnionOmit<ExtractChainFormatterParameters<DeriveChain<Chain, chainOverride>, "transactionRequest", TransactionRequest>, "from">

Parameters

args

SignTransactionParameters<Chain, Account, chainOverride, request>

SignTransactionParameters

Returns

Promise<TransactionSerialized<GetTransactionType<request, request extends LegacyProperties ? "legacy" : never | request extends EIP1559Properties ? "eip1559" : never | request extends EIP2930Properties ? "eip2930" : never | request extends EIP4844Properties ? "eip4844" : never | request extends EIP7702Properties ? "eip7702" : never | request["type"] extends string | undefined ? Extract<any[any], string> : never>, GetTransactionType<request, request extends LegacyProperties ? "legacy" : never | request extends EIP1559Properties ? "eip1559" : never | request extends EIP2930Properties ? "eip2930" : never | request extends EIP4844Properties ? "eip4844" : never | request extends EIP7702Properties ? "eip7702" : never | request["type"] extends string | undefined ? Extract<any[any], string> : never> extends "eip1559" ? `0x02${string}` : never | GetTransactionType<request, request extends LegacyProperties ? "legacy" : never | request extends EIP1559Properties ? "eip1559" : never | request extends EIP2930Properties ? "eip2930" : never | request extends EIP4844Properties ? "eip4844" : never | request extends EIP7702Properties ? "eip7702" : never | request["type"] extends string | undefined ? Extract<any[any], string> : never> extends "eip2930" ? `0x01${string}` : never | GetTransactionType<request, request extends LegacyProperties ? "legacy" : never | request extends EIP1559Properties ? "eip1559" : never | request extends EIP2930Properties ? "eip2930" : never | request extends EIP4844Properties ? "eip4844" : never | request extends EIP7702Properties ? "eip7702" : never | request["type"] extends string | undefined ? Extract<any[any], string> : never> extends "eip4844" ? `0x03${string}` : never | GetTransactionType<request, request extends LegacyProperties ? "legacy" : never | request extends EIP1559Properties ? "eip1559" : never | request extends EIP2930Properties ? "eip2930" : never | request extends EIP4844Properties ? "eip4844" : never | request extends EIP7702Properties ? "eip7702" : never | request["type"] extends string | undefined ? Extract<any[any], string> : never> extends "eip7702" ? `0x04${string}` : never | GetTransactionType<request, request extends LegacyProperties ? "legacy" : never | request extends EIP1559Properties ? "eip1559" : never | request extends EIP2930Properties ? "eip2930" : never | request extends EIP4844Properties ? "eip4844" : never | request extends EIP7702Properties ? "eip7702" : never | request["type"] extends string | undefined ? Extract<any[any], string> : never> extends "legacy" ? TransactionSerializedLegacy : never>>

The signed message. SignTransactionReturnType

Examples

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,
})
const signature = await client.signTransaction(request)

// 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,
})
const signature = await client.signTransaction(request)

signTypedData

signTypedData: <typedData, primaryType>(args) => Promise<`0x${string}`>

Signs typed data and calculates an Ethereum-specific signature in EIP-191 format: keccak256("\x19Ethereum Signed Message:\n" + len(message) + message)).

• Docs: https://viem.sh/docs/actions/wallet/signTypedData
• JSON-RPC Methods:
  • JSON-RPC Accounts: eth_signTypedData_v4
  • Local Accounts: Signs locally. No JSON-RPC request.

Type Parameters

typedData

typedData extends {[key: string]: readonly TypedDataParameter[]; [key: `string[${string}]`]: undefined; [key: `function[${string}]`]: undefined; [key: `address[${string}]`]: undefined; [key: `bool[${string}]`]: undefined; [key: `bytes[${string}]`]: undefined; [key: `bytes1[${string}]`]: undefined; [key: `bytes2[${string}]`]: undefined; [key: `bytes3[${string}]`]: undefined; [key: `bytes4[${string}]`]: undefined; [key: `bytes5[${string}]`]: undefined; [key: `bytes6[${string}]`]: undefined; [key: `bytes7[${string}]`]: undefined; [key: `bytes8[${string}]`]: undefined; [key: `bytes9[${string}]`]: undefined; [key: `bytes10[${string}]`]: undefined; [key: `bytes11[${string}]`]: undefined; [key: `bytes12[${string}]`]: undefined; [key: `bytes13[${string}]`]: undefined; [key: `bytes14[${string}]`]: undefined; [key: `bytes15[${string}]`]: undefined; [key: `bytes16[${string}]`]: undefined; [key: `bytes17[${string}]`]: undefined; [key: `bytes18[${string}]`]: undefined; [key: `bytes19[${string}]`]: undefined; [key: `bytes20[${string}]`]: undefined; [key: `bytes21[${string}]`]: undefined; [key: `bytes22[${string}]`]: undefined; [key: `bytes23[${string}]`]: undefined; [key: `bytes24[${string}]`]: undefined; [key: `bytes25[${string}]`]: undefined; [key: `bytes26[${string}]`]: undefined; [key: `bytes27[${string}]`]: undefined; [key: `bytes28[${string}]`]: undefined; [key: `bytes29[${string}]`]: undefined; [key: `bytes30[${string}]`]: undefined; [key: `bytes31[${string}]`]: undefined; [key: `bytes32[${string}]`]: undefined; [key: `int[${string}]`]: undefined; [key: `int8[${string}]`]: undefined; [key: `int16[${string}]`]: undefined; [key: `int24[${string}]`]: undefined; [key: `int32[${string}]`]: undefined; [key: `int40[${string}]`]: undefined; [key: `int48[${string}]`]: undefined; [key: `int56[${string}]`]: undefined; [key: `int64[${string}]`]: undefined; [key: `int72[${string}]`]: undefined; [key: `int80[${string}]`]: undefined; [key: `int88[${string}]`]: undefined; [key: `int96[${string}]`]: undefined; [key: `int104[${string}]`]: undefined; [key: `int112[${string}]`]: undefined; [key: `int120[${string}]`]: undefined; [key: `int128[${string}]`]: undefined; [key: `int136[${string}]`]: undefined; [key: `int144[${string}]`]: undefined; [key: `int152[${string}]`]: undefined; [key: `int160[${string}]`]: undefined; [key: `int168[${string}]`]: undefined; [key: `int176[${string}]`]: undefined; [key: `int184[${string}]`]: undefined; [key: `int192[${string}]`]: undefined; [key: `int200[${string}]`]: undefined; [key: `int208[${string}]`]: undefined; [key: `int216[${string}]`]: undefined; [key: `int224[${string}]`]: undefined; [key: `int232[${string}]`]: undefined; [key: `int240[${string}]`]: undefined; [key: `int248[${string}]`]: undefined; [key: `int256[${string}]`]: undefined; [key: `uint[${string}]`]: undefined; [key: `uint8[${string}]`]: undefined; [key: `uint16[${string}]`]: undefined; [key: `uint24[${string}]`]: undefined; [key: `uint32[${string}]`]: undefined; [key: `uint40[${string}]`]: undefined; [key: `uint48[${string}]`]: undefined; [key: `uint56[${string}]`]: undefined; [key: `uint64[${string}]`]: undefined; [key: `uint72[${string}]`]: undefined; [key: `uint80[${string}]`]: undefined; [key: `uint88[${string}]`]: undefined; [key: `uint96[${string}]`]: undefined; [key: `uint104[${string}]`]: undefined; [key: `uint112[${string}]`]: undefined; [key: `uint120[${string}]`]: undefined; [key: `uint128[${string}]`]: undefined; [key: `uint136[${string}]`]: undefined; [key: `uint144[${string}]`]: undefined; [key: `uint152[${string}]`]: undefined; [key: `uint160[${string}]`]: undefined; [key: `uint168[${string}]`]: undefined; [key: `uint176[${string}]`]: undefined; [key: `uint184[${string}]`]: undefined; [key: `uint192[${string}]`]: undefined; [key: `uint200[${string}]`]: undefined; [key: `uint208[${string}]`]: undefined; [key: `uint216[${string}]`]: undefined; [key: `uint224[${string}]`]: undefined; [key: `uint232[${string}]`]: undefined; [key: `uint240[${string}]`]: undefined; [key: `uint248[${string}]`]: undefined; [key: `uint256[${string}]`]: undefined; address?: undefined; bool?: undefined; bytes?: undefined; bytes1?: undefined; bytes10?: undefined; bytes11?: undefined; bytes12?: undefined; bytes13?: undefined; bytes14?: undefined; bytes15?: undefined; bytes16?: undefined; bytes17?: undefined; bytes18?: undefined; bytes19?: undefined; bytes2?: undefined; bytes20?: undefined; bytes21?: undefined; bytes22?: undefined; bytes23?: undefined; bytes24?: undefined; bytes25?: undefined; bytes26?: undefined; bytes27?: undefined; bytes28?: undefined; bytes29?: undefined; bytes3?: undefined; bytes30?: undefined; bytes31?: undefined; bytes32?: undefined; bytes4?: undefined; bytes5?: undefined; bytes6?: undefined; bytes7?: undefined; bytes8?: undefined; bytes9?: undefined; int104?: undefined; int112?: undefined; int120?: undefined; int128?: undefined; int136?: undefined; int144?: undefined; int152?: undefined; int16?: undefined; int160?: undefined; int168?: undefined; int176?: undefined; int184?: undefined; int192?: undefined; int200?: undefined; int208?: undefined; int216?: undefined; int224?: undefined; int232?: undefined; int24?: undefined; int240?: undefined; int248?: undefined; int256?: undefined; int32?: undefined; int40?: undefined; int48?: undefined; int56?: undefined; int64?: undefined; int72?: undefined; int8?: undefined; int80?: undefined; int88?: undefined; int96?: undefined; string?: undefined; uint104?: undefined; uint112?: undefined; uint120?: undefined; uint128?: undefined; uint136?: undefined; uint144?: undefined; uint152?: undefined; uint16?: undefined; uint160?: undefined; uint168?: undefined; uint176?: undefined; uint184?: undefined; uint192?: undefined; uint200?: undefined; uint208?: undefined; uint216?: undefined; uint224?: undefined; uint232?: undefined; uint24?: undefined; uint240?: undefined; uint248?: undefined; uint256?: undefined; uint32?: undefined; uint40?: undefined; uint48?: undefined; uint56?: undefined; uint64?: undefined; uint72?: undefined; uint8?: undefined; uint80?: undefined; uint88?: undefined; uint96?: undefined; } | {[key: string]: unknown; }

primaryType

primaryType extends string

Parameters

args

SignTypedDataParameters<typedData, primaryType, Account>

SignTypedDataParameters

Returns

Promise<`0x${string}`>

The signed data. SignTypedDataReturnType

Examples

import { createWalletClient, custom } from 'viem'
import { mainnet } from 'viem/chains'

const client = createWalletClient({
  chain: mainnet,
  transport: custom(window.ethereum),
})
const signature = await client.signTypedData({
  account: '0xA0Cf798816D4b9b9866b5330EEa46a18382f251e',
  domain: {
    name: 'Ether Mail',
    version: '1',
    chainId: 1,
    verifyingContract: '0xCcCCccccCCCCcCCCCCCcCcCccCcCCCcCcccccccC',
  },
  types: {
    Person: [
      { name: 'name', type: 'string' },
      { name: 'wallet', type: 'address' },
    ],
    Mail: [
      { name: 'from', type: 'Person' },
      { name: 'to', type: 'Person' },
      { name: 'contents', type: 'string' },
    ],
  },
  primaryType: 'Mail',
  message: {
    from: {
      name: 'Cow',
      wallet: '0xCD2a3d9F938E13CD947Ec05AbC7FE734Df8DD826',
    },
    to: {
      name: 'Bob',
      wallet: '0xbBbBBBBbbBBBbbbBbbBbbbbBBbBbbbbBbBbbBBbB',
    },
    contents: 'Hello, Bob!',
  },
})

// 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: http(),
})
const signature = await client.signTypedData({
  domain: {
    name: 'Ether Mail',
    version: '1',
    chainId: 1,
    verifyingContract: '0xCcCCccccCCCCcCCCCCCcCcCccCcCCCcCcccccccC',
  },
  types: {
    Person: [
      { name: 'name', type: 'string' },
      { name: 'wallet', type: 'address' },
    ],
    Mail: [
      { name: 'from', type: 'Person' },
      { name: 'to', type: 'Person' },
      { name: 'contents', type: 'string' },
    ],
  },
  primaryType: 'Mail',
  message: {
    from: {
      name: 'Cow',
      wallet: '0xCD2a3d9F938E13CD947Ec05AbC7FE734Df8DD826',
    },
    to: {
      name: 'Bob',
      wallet: '0xbBbBBBBbbBBBbbbBbbBbbbbBBbBbbbbBbBbbBBbB',
    },
    contents: 'Hello, Bob!',
  },
})

switchChain

switchChain: (args) => Promise<void>

Switch the target chain in a wallet.

• Docs: https://viem.sh/docs/actions/wallet/switchChain
• JSON-RPC Methods: eth_switchEthereumChain

Parameters

args

SwitchChainParameters

SwitchChainParameters

Returns

Promise<void>

Example

import { createWalletClient, custom } from 'viem'
import { mainnet, optimism } from 'viem/chains'

const client = createWalletClient({
  chain: mainnet,
  transport: custom(window.ethereum),
})
await client.switchChain({ id: optimism.id })

transport

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

The RPC transport

type

type: string

The type of client.

uid

uid: string

A unique ID for the client.

waitForCallsStatus

waitForCallsStatus: (parameters) => Promise<{ atomic: boolean; capabilities?: {[key: string]: any; } | {[key: string]: any; }; chainId: number; id: string; receipts?: WalletCallReceipt<bigint, "success" | "reverted">[]; status: "pending" | "success" | "failure" | undefined; statusCode: number; version: string; }>

Waits for the status & receipts of a call bundle that was sent via sendCalls.

• Docs: https://viem.sh/docs/actions/wallet/waitForCallsStatus
• JSON-RPC Methods: wallet_getCallsStatus

Parameters

parameters

WaitForCallsStatusParameters

WaitForCallsStatusParameters

Returns

Promise<{ atomic: boolean; capabilities?: {[key: string]: any; } | {[key: string]: any; }; chainId: number; id: string; receipts?: WalletCallReceipt<bigint, "success" | "reverted">[]; status: "pending" | "success" | "failure" | undefined; statusCode: number; version: string; }>

Status & receipts of the call bundle. WaitForCallsStatusReturnType

Example

import { createWalletClient, custom } from 'viem'
import { mainnet } from 'viem/chains'

const client = createWalletClient({
  chain: mainnet,
  transport: custom(window.ethereum),
})

const { receipts, status } = await waitForCallsStatus(client, { id: '0xdeadbeef' })

watchAsset

watchAsset: (args) => Promise<boolean>

Adds an EVM chain to the wallet.

• Docs: https://viem.sh/docs/actions/wallet/watchAsset
• JSON-RPC Methods: eth_switchEthereumChain

Parameters

args

WatchAssetParams

WatchAssetParameters

Returns

Promise<boolean>

Boolean indicating if the token was successfully added. WatchAssetReturnType

Example

import { createWalletClient, custom } from 'viem'
import { mainnet } from 'viem/chains'

const client = createWalletClient({
  chain: mainnet,
  transport: custom(window.ethereum),
})
const success = await client.watchAsset({
  type: 'ERC20',
  options: {
    address: '0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2',
    decimals: 18,
    symbol: 'WETH',
  },
})

writeContract

writeContract: <abi, functionName, args, chainOverride>(args) => Promise<`0x${string}`>

Executes a write function on a contract.

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

A “write” function on a Solidity contract modifies the state of the blockchain. These types of functions require gas to be executed, and hence a Transaction is needed to be broadcast in order to change the state.

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

Warning: The write internally sends a transaction – it does not validate if the contract write will succeed (the contract may throw an error). It is highly recommended to simulate the contract write with contract.simulate before you execute it.

Type Parameters

abi

abi extends Abi | readonly unknown[]

functionName

functionName extends string

args

args extends unknown

chainOverride

chainOverride extends Chain | undefined = undefined

Parameters

args

WriteContractParameters<abi, functionName, args, Chain, Account, chainOverride>

WriteContractParameters

Returns

Promise<`0x${string}`>

A Transaction Hash. WriteContractReturnType

Examples

import { createWalletClient, custom, parseAbi } from 'viem'
import { mainnet } from 'viem/chains'

const client = createWalletClient({
  chain: mainnet,
  transport: custom(window.ethereum),
})
const hash = await client.writeContract({
  address: '0xFBA3912Ca04dd458c843e2EE08967fC04f3579c2',
  abi: parseAbi(['function mint(uint32 tokenId) nonpayable']),
  functionName: 'mint',
  args: [69420],
})

// With Validation
import { createWalletClient, custom, parseAbi } from 'viem'
import { mainnet } from 'viem/chains'

const client = createWalletClient({
  chain: mainnet,
  transport: custom(window.ethereum),
})
const { request } = await client.simulateContract({
  address: '0xFBA3912Ca04dd458c843e2EE08967fC04f3579c2',
  abi: parseAbi(['function mint(uint32 tokenId) nonpayable']),
  functionName: 'mint',
  args: [69420],
}
const hash = await client.writeContract(request)

writeContractSync

writeContractSync: <abi, functionName, args, chainOverride>(args) => Promise<TransactionReceipt>

Executes a write function on a contract synchronously. Returns the transaction receipt.

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

A “write” function on a Solidity contract modifies the state of the blockchain. These types of functions require gas to be executed, and hence a Transaction is needed to be broadcast in order to change the state.

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

Warning: The write internally sends a transaction – it does not validate if the contract write will succeed (the contract may throw an error). It is highly recommended to simulate the contract write with contract.simulate before you execute it.

Type Parameters

abi

abi extends Abi | readonly unknown[]

functionName

functionName extends string

args

args extends unknown

chainOverride

chainOverride extends Chain | undefined = undefined

Parameters

args

WriteContractSyncParameters<abi, functionName, args, Chain, Account, chainOverride>

WriteContractSyncParameters

Returns

Promise<TransactionReceipt>

A Transaction Receipt. WriteContractSyncReturnType

Example

import { createWalletClient, custom, parseAbi } from 'viem'
import { mainnet } from 'viem/chains'

const client = createWalletClient({
  chain: mainnet,
  transport: custom(window.ethereum),
})
const receipt = await client.writeContractSync({
  address: '0xFBA3912Ca04dd458c843e2EE08967fC04f3579c2',
  abi: parseAbi(['function mint(uint32 tokenId) nonpayable']),
  functionName: 'mint',
  args: [69420],
})