AAStar SDK

Appearance

Enumerations ​

UserOpScenarioType ​

Defined in: packages/sdk/src/utils/testScenarios.ts:5

Enumeration Members ​

GASLESS_V4 ​
ts
GASLESS_V4: "GASLESS_V4";

Defined in: packages/sdk/src/utils/testScenarios.ts:7

NATIVE ​
ts
NATIVE: "NATIVE";

Defined in: packages/sdk/src/utils/testScenarios.ts:6

SUPER_BPNT ​
ts
SUPER_BPNT: "SUPER_BPNT";

Defined in: packages/sdk/src/utils/testScenarios.ts:8

SUPER_CPNT ​
ts
SUPER_CPNT: "SUPER_CPNT";

Defined in: packages/sdk/src/utils/testScenarios.ts:9

SUPER_CUSTOM ​
ts
SUPER_CUSTOM: "SUPER_CUSTOM";

Defined in: packages/sdk/src/utils/testScenarios.ts:10

Classes ​

FundingManager ​

Defined in: packages/sdk/src/utils/funding.ts:65

资金管理器 提供 ETH 和 ERC20 Token 的充值、验证等工具函数

Constructors ​

Constructor ​
ts
new FundingManager(): FundingManager;
Returns ​

FundingManager

Methods ​

batchFundETH() ​
ts
static batchFundETH(params, targets): Promise<FundingResult[]>;

Defined in: packages/sdk/src/utils/funding.ts:236

批量充值 ETH

Parameters ​
ParameterTypeDescription
paramsOmit<FundingParams, "targetAddress">基础参数
targetsobject[]目标地址和金额数组
Returns ​

Promise<FundingResult[]>

充值结果数组

batchFundToken() ​
ts
static batchFundToken(
   params, 
   tokenAddress, 
targets): Promise<FundingResult[]>;

Defined in: packages/sdk/src/utils/funding.ts:261

批量充值 Token

Parameters ​
ParameterTypeDescription
paramsOmit<FundingParams, "targetAddress">基础参数
tokenAddress`0x${string}`Token 合约地址
targetsobject[]目标地址和金额数组
Returns ​

Promise<FundingResult[]>

充值结果数组

ensureFunding() ​
ts
static ensureFunding(params): Promise<FundingResult[]>;

Defined in: packages/sdk/src/utils/funding.ts:184

智能充值：检查余额，不足时自动充值

Parameters ​
ParameterTypeDescription
paramsEnsureFundingParams充值参数
Returns ​

Promise<FundingResult[]>

充值结果数组

fundWithETH() ​
ts
static fundWithETH(params): Promise<FundingResult>;

Defined in: packages/sdk/src/utils/funding.ts:96

充值 ETH 到目标地址

Parameters ​
ParameterTypeDescription
paramsFundETHParams充值参数
Returns ​

Promise<FundingResult>

充值结果

fundWithToken() ​
ts
static fundWithToken(params): Promise<FundingResult>;

Defined in: packages/sdk/src/utils/funding.ts:126

充值 ERC20 Token 到目标地址

Parameters ​
ParameterTypeDescription
paramsFundTokenParams充值参数
Returns ​

Promise<FundingResult>

充值结果

getETHBalance() ​
ts
static getETHBalance(params): Promise<bigint>;

Defined in: packages/sdk/src/utils/funding.ts:158

检查 ETH 余额

Parameters ​
ParameterTypeDescription
paramsFundingParams基础参数
Returns ​

Promise<bigint>

ETH 余额（wei）

getTokenBalance() ​
ts
static getTokenBalance(params, tokenAddress): Promise<bigint>;

Defined in: packages/sdk/src/utils/funding.ts:169

检查 ERC20 Token 余额

Parameters ​
ParameterTypeDescription
paramsFundingParams基础参数
tokenAddress`0x${string}`Token 合约地址
Returns ​

Promise<bigint>

Token 余额

KeyManager ​

Defined in: packages/sdk/src/utils/keys.ts:26

密钥管理器 提供密钥生成、存储、加载等工具函数

Constructors ​

Constructor ​
ts
new KeyManager(): KeyManager;
Returns ​

KeyManager

Methods ​

generateKeyPair() ​
ts
static generateKeyPair(name): KeyPair;

Defined in: packages/sdk/src/utils/keys.ts:31

生成单个密钥对

Parameters ​
ParameterTypeDescription
namestring密钥名称（如 'Jason', 'Anni'）
Returns ​

KeyPair

generateKeyPairs() ​
ts
static generateKeyPairs(names): KeyPair[];

Defined in: packages/sdk/src/utils/keys.ts:45

批量生成密钥对

Parameters ​
ParameterTypeDescription
namesstring[]密钥名称数组
Returns ​

KeyPair[]

generateMultiple() ​
ts
static generateMultiple(count, prefix): KeyPair[];

Defined in: packages/sdk/src/utils/keys.ts:54

生成指定数量的密钥对（自动命名为 Operator_1, Operator_2, ...）

Parameters ​
ParameterTypeDefault valueDescription
countnumberundefined数量
prefixstring'Operator'名称前缀（默认 'Operator'）
Returns ​

KeyPair[]

loadFromEnvFile() ​
ts
static loadFromEnvFile(filePath): KeyPair[];

Defined in: packages/sdk/src/utils/keys.ts:83

从 .env 文件加载密钥

Parameters ​
ParameterTypeDescription
filePathstring文件路径（绝对路径）
Returns ​

KeyPair[]

密钥对数组

loadFromJsonFile() ​
ts
static loadFromJsonFile(filePath): KeyPair[];

Defined in: packages/sdk/src/utils/keys.ts:133

从 JSON 文件加载密钥

Parameters ​
ParameterTypeDescription
filePathstring文件路径（绝对路径）
Returns ​

KeyPair[]

printKeys() ​
ts
static printKeys(keys, showPrivateKey): void;

Defined in: packages/sdk/src/utils/keys.ts:152

打印密钥信息（隐藏私钥）

Parameters ​
ParameterTypeDefault valueDescription
keysKeyPair[]undefined密钥对数组
showPrivateKeybooleanfalse-
Returns ​

void

saveToEnvFile() ​
ts
static saveToEnvFile(
   filePath, 
   keys, 
   overwrite): void;

Defined in: packages/sdk/src/utils/keys.ts:65

保存密钥到 .env 文件

Parameters ​
ParameterTypeDefault valueDescription
filePathstringundefined文件路径（绝对路径）
keysKeyPair[]undefined密钥对数组
overwritebooleanfalse是否覆盖已存在的文件（默认 false）
Returns ​

void

saveToJsonFile() ​
ts
static saveToJsonFile(
   filePath, 
   keys, 
   overwrite): void;

Defined in: packages/sdk/src/utils/keys.ts:111

保存密钥到 JSON 文件（包含地址信息）

Parameters ​
ParameterTypeDefault valueDescription
filePathstringundefined文件路径（绝对路径）
keysKeyPair[]undefined密钥对数组
overwritebooleanfalse是否覆盖已存在的文件（默认 false）
Returns ​

void

UserOpScenarioBuilder ​

Defined in: packages/sdk/src/utils/testScenarios.ts:30

Constructors ​

Constructor ​
ts
new UserOpScenarioBuilder(): UserOpScenarioBuilder;
Returns ​

UserOpScenarioBuilder

Methods ​

buildTransferScenario() ​
ts
static buildTransferScenario(type, params): Promise<{
  opHash: `0x${string}`;
  userOp: any;
}>;

Defined in: packages/sdk/src/utils/testScenarios.ts:34

Builds a signed PackedUserOperation for a token transfer based on the specified scenario.

Parameters ​
ParameterType
typeUserOpScenarioType
paramsScenarioParams
Returns ​

Promise<{ opHash: `0x${string}`; userOp: any; }>

Interfaces ​

FundingParams ​

Defined in: packages/sdk/src/utils/funding.ts:7

资金管理参数

Properties ​

chain ​
ts
chain: Chain;

Defined in: packages/sdk/src/utils/funding.ts:11

链配置

rpcUrl ​
ts
rpcUrl: string;

Defined in: packages/sdk/src/utils/funding.ts:9

RPC URL

supplierKey ​
ts
supplierKey: `0x${string}`;

Defined in: packages/sdk/src/utils/funding.ts:13

资金提供者私钥

targetAddress ​
ts
targetAddress: `0x${string}`;

Defined in: packages/sdk/src/utils/funding.ts:15

目标地址

KeyPair ​

Defined in: packages/sdk/src/utils/keys.ts:16

密钥对接口

Properties ​

address ​
ts
address: `0x${string}`;

Defined in: packages/sdk/src/utils/keys.ts:19

name ​
ts
name: string;

Defined in: packages/sdk/src/utils/keys.ts:17

privateKey ​
ts
privateKey: `0x${string}`;

Defined in: packages/sdk/src/utils/keys.ts:18

ScenarioParams ​

Defined in: packages/sdk/src/utils/testScenarios.ts:13

Properties ​

amount ​
ts
amount: bigint;

Defined in: packages/sdk/src/utils/testScenarios.ts:18

chainId ​
ts
chainId: number;

Defined in: packages/sdk/src/utils/testScenarios.ts:20

entryPoint ​
ts
entryPoint: `0x${string}`;

Defined in: packages/sdk/src/utils/testScenarios.ts:19

gasToken? ​
ts
optional gasToken: `0x${string}`;

Defined in: packages/sdk/src/utils/testScenarios.ts:27

nonceKey? ​
ts
optional nonceKey: bigint;

Defined in: packages/sdk/src/utils/testScenarios.ts:26

operator? ​
ts
optional operator: `0x${string}`;

Defined in: packages/sdk/src/utils/testScenarios.ts:23

ownerAccount ​
ts
ownerAccount: any;

Defined in: packages/sdk/src/utils/testScenarios.ts:15

paymaster? ​
ts
optional paymaster: `0x${string}`;

Defined in: packages/sdk/src/utils/testScenarios.ts:22

paymasterGasLimit? ​
ts
optional paymasterGasLimit: bigint;

Defined in: packages/sdk/src/utils/testScenarios.ts:24

paymasterPostOpGasLimit? ​
ts
optional paymasterPostOpGasLimit: bigint;

Defined in: packages/sdk/src/utils/testScenarios.ts:25

publicClient ​
ts
publicClient: object;

Defined in: packages/sdk/src/utils/testScenarios.ts:21

account ​
ts
account: undefined;

The Account of the Client.

batch? ​
ts
optional batch: object;

Flags for batch settings.

batch.multicall? ​
ts
optional multicall: 
  | boolean
  | {
  batchSize?: number;
  deployless?: boolean;
  wait?: number;
};

Toggle to enable eth_call multicall aggregation.

Type Declaration ​

boolean

ts
{
  batchSize?: number;
  deployless?: boolean;
  wait?: number;
}
cacheTime ​
ts
cacheTime: number;

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

call() ​
ts
call: (parameters) => Promise<CallReturnType>;

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

Parameters ​
ParameterType
parametersCallParameters<Chain | undefined>
Returns ​

Promise<CallReturnType>

The call data. CallReturnType

Example ​
ts
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? ​
ts
optional ccipRead: 
  | false
  | {
  request?: (parameters) => Promise<`0x${string}`>;
};

CCIP Read configuration.

Type Declaration ​

false

ts
{
  request?: (parameters) => Promise<`0x${string}`>;
}
chain ​
ts
chain: Chain | undefined;

Chain for the client.

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

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

Parameters ​
ParameterType
parametersCreateAccessListParameters<Chain | undefined>
Returns ​

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

The call data. CreateAccessListReturnType

Example ​
ts
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() ​
ts
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.

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 ​
ts
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() ​
ts
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.

Type Parameters ​
Type ParameterDefault type
abi extends readonly unknown[] | Abi-
eventName extends string | undefined-
args extends readonly unknown[] | Record<string, unknown> | undefined-
strict extends boolean | undefinedundefined
fromBlock extends bigint | BlockTag | undefinedundefined
toBlock extends bigint | BlockTag | undefinedundefined
Parameters ​
ParameterTypeDescription
argsCreateContractEventFilterParameters<abi, eventName, args, strict, fromBlock, toBlock>CreateContractEventFilterParameters
Returns ​

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

Filter. CreateContractEventFilterReturnType

Example ​
ts
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() ​
ts
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.

Type Parameters ​
Type ParameterDefault type
abiEvent extends AbiEvent | undefinedundefined
abiEvents extends readonly unknown[] | readonly AbiEvent[] | undefinedabiEvent extends AbiEvent ? [abiEvent<abiEvent>] : undefined
strict extends boolean | undefinedundefined
fromBlock extends bigint | BlockTag | undefinedundefined
toBlock extends bigint | BlockTag | undefinedundefined
_EventName extends string | undefinedMaybeAbiEventName<abiEvent>
_Args extends readonly unknown[] | Record<string, unknown> | undefinedundefined
Parameters ​
ParameterTypeDescription
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 ​
ts
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() ​
ts
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.

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 ​
ts
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' }
estimateContractGas() ​
ts
estimateContractGas: <chain, abi, functionName, args>(args) => Promise<bigint>;

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

Type Parameters ​
Type Parameter
chain extends Chain | undefined
abi extends readonly unknown[] | Abi
functionName extends string
args extends unknown
Parameters ​
ParameterTypeDescription
argsEstimateContractGasParameters<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 ​
ts
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() ​
ts
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.

Type Parameters ​
Type ParameterDefault type
chainOverride extends Chain | undefinedundefined
type extends FeeValuesType"eip1559"
Parameters ​
ParameterType
args?EstimateFeesPerGasParameters<Chain | undefined, chainOverride, type>
Returns ​

Promise<EstimateFeesPerGasReturnType<type>>

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

Example ​
ts
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() ​
ts
estimateGas: (args) => Promise<bigint>;

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

Parameters ​
ParameterTypeDescription
argsEstimateGasParameters<Chain | undefined>EstimateGasParameters
Returns ​

Promise<bigint>

The gas estimate (in wei). EstimateGasReturnType

Example ​
ts
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() ​
ts
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.

Type Parameters ​
Type ParameterDefault type
chainOverride extends Chain | undefinedundefined
Parameters ​
ParameterType
args?{ chain: chainOverride | null; }
args.chain?chainOverride | null
Returns ​

Promise<bigint>

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

Example ​
ts
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? ​
ts
optional experimental_blockTag: BlockTag;

Default block tag to use for RPC requests.

extend() ​
ts
extend: <client>(fn) => Client<Transport, Chain | undefined, undefined, PublicRpcSchema, { [K in string | number | symbol]: client[K] } & PublicActions<Transport, Chain | undefined>>;
Type Parameters ​
Type Parameter
client extends object & ExactPartial<ExtendableProtectedActions<Transport, Chain | undefined, undefined>>
Parameters ​
ParameterType
fn(client) => client
Returns ​

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

fillTransaction() ​
ts
fillTransaction: <chainOverride, accountOverride>(args) => Promise<FillTransactionReturnType<Chain | undefined, chainOverride>>;

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

Type Parameters ​
Type ParameterDefault type
chainOverride extends Chain | undefinedundefined
accountOverride extends `0x${string}` | Account | undefinedundefined
Parameters ​
ParameterType
argsFillTransactionParameters<Chain | undefined, Account | undefined, chainOverride, accountOverride>
Returns ​

Promise<FillTransactionReturnType<Chain | undefined, chainOverride>>

The filled transaction. FillTransactionReturnType

Example ​
ts
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() ​
ts
getBalance: (args) => Promise<bigint>;

Returns the balance of an address in wei.

Parameters ​
ParameterTypeDescription
argsGetBalanceParametersGetBalanceParameters
Returns ​

Promise<bigint>

The balance of the address in wei. GetBalanceReturnType

Remarks ​

You can convert the balance to ether units with formatEther.

ts
const balance = await getBalance(client, {
  address: '0xA0Cf798816D4b9b9866b5330EEa46a18382f251e',
  blockTag: 'safe'
})
const balanceAsEther = formatEther(balance)
// "6.942"
Example ​
ts
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() ​
ts
getBlobBaseFee: () => Promise<bigint>;

Returns the base fee per blob gas in wei.

Returns ​

Promise<bigint>

The blob base fee (in wei). GetBlobBaseFeeReturnType

Example ​
ts
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() ​
ts
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;
     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;
     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;
     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;
     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;
     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.

Type Parameters ​
Type ParameterDefault type
includeTransactions extends booleanfalse
blockTag extends BlockTag"latest"
Parameters ​
ParameterTypeDescription
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; 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; 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; 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; 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; 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 ​
ts
import { createPublicClient, http } from 'viem'
import { mainnet } from 'viem/chains'

const client = createPublicClient({
  chain: mainnet,
  transport: http(),
})
const block = await client.getBlock()
getBlockNumber() ​
ts
getBlockNumber: (args?) => Promise<bigint>;

Returns the number of the most recent block seen.

Parameters ​
ParameterTypeDescription
args?GetBlockNumberParametersGetBlockNumberParameters
Returns ​

Promise<bigint>

The number of the block. GetBlockNumberReturnType

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

const client = createPublicClient({
  chain: mainnet,
  transport: http(),
})
const blockNumber = await client.getBlockNumber()
// 69420n
getBlockTransactionCount() ​
ts
getBlockTransactionCount: (args?) => Promise<number>;

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

Parameters ​
ParameterTypeDescription
args?GetBlockTransactionCountParametersGetBlockTransactionCountParameters
Returns ​

Promise<number>

The block transaction count. GetBlockTransactionCountReturnType

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

const client = createPublicClient({
  chain: mainnet,
  transport: http(),
})
const count = await client.getBlockTransactionCount()
getBytecode() ​
ts
getBytecode: (args) => Promise<GetCodeReturnType>;
Parameters ​
ParameterType
argsGetCodeParameters
Returns ​

Promise<GetCodeReturnType>

Deprecated ​

Use getCode instead.

getChainId() ​
ts
getChainId: () => Promise<number>;

Returns the chain ID associated with the current network.

Returns ​

Promise<number>

The current chain ID. GetChainIdReturnType

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

const client = createPublicClient({
  chain: mainnet,
  transport: http(),
})
const chainId = await client.getChainId()
// 1
getCode() ​
ts
getCode: (args) => Promise<GetCodeReturnType>;

Retrieves the bytecode at an address.

Parameters ​
ParameterTypeDescription
argsGetCodeParametersGetBytecodeParameters
Returns ​

Promise<GetCodeReturnType>

The contract's bytecode. GetBytecodeReturnType

Example ​
ts
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() ​
ts
getContractEvents: <abi, eventName, strict, fromBlock, toBlock>(args) => Promise<GetContractEventsReturnType<abi, eventName, strict, fromBlock, toBlock>>;

Returns a list of event logs emitted by a contract.

Type Parameters ​
Type ParameterDefault type
abi extends readonly unknown[] | Abi-
eventName extends string | undefinedundefined
strict extends boolean | undefinedundefined
fromBlock extends bigint | BlockTag | undefinedundefined
toBlock extends bigint | BlockTag | undefinedundefined
Parameters ​
ParameterType
argsGetContractEventsParameters<abi, eventName, strict, fromBlock, toBlock>
Returns ​

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

A list of event logs. GetContractEventsReturnType

Example ​
ts
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'
})
getEip712Domain() ​
ts
getEip712Domain: (args) => Promise<GetEip712DomainReturnType>;

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

Parameters ​
ParameterType
argsGetEip712DomainParameters
Returns ​

Promise<GetEip712DomainReturnType>

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

Example ​
ts
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() ​
ts
getEnsAddress: (args) => Promise<GetEnsAddressReturnType>;

Gets address for ENS name.

Parameters ​
ParameterTypeDescription
args{ blockNumber?: bigint; blockTag?: BlockTag; coinType?: bigint; gatewayUrls?: string[]; name: string; strict?: boolean; universalResolverAddress?: `0x${string}`; }GetEnsAddressParameters
args.blockNumber?bigintThe balance of the account at a block number.
args.blockTag?BlockTagThe balance of the account at a block tag. Default 'latest'
args.coinType?bigintENSIP-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
args.gatewayUrls?string[]Universal Resolver gateway URLs to use for resolving CCIP-read requests.
args.namestringName to get the address for.
args.strict?booleanWhether or not to throw errors propagated from the ENS Universal Resolver Contract.
args.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 ​
ts
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() ​
ts
getEnsAvatar: (args) => Promise<GetEnsAvatarReturnType>;

Gets the avatar of an ENS name.

Parameters ​
ParameterTypeDescription
args{ assetGatewayUrls?: AssetGatewayUrls; blockNumber?: bigint; blockTag?: BlockTag; gatewayUrls?: string[]; name: string; strict?: boolean; universalResolverAddress?: `0x${string}`; }GetEnsAvatarParameters
args.assetGatewayUrls?AssetGatewayUrlsGateway urls to resolve IPFS and/or Arweave assets.
args.blockNumber?bigintThe balance of the account at a block number.
args.blockTag?BlockTagThe balance of the account at a block tag. Default 'latest'
args.gatewayUrls?string[]Universal Resolver gateway URLs to use for resolving CCIP-read requests.
args.namestringENS name to get Text for.
args.strict?booleanWhether or not to throw errors propagated from the ENS Universal Resolver Contract.
args.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 ​
ts
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() ​
ts
getEnsName: (args) => Promise<GetEnsNameReturnType>;

Gets primary name for specified address.

Parameters ​
ParameterTypeDescription
args{ address: `0x${string}`; blockNumber?: bigint; blockTag?: BlockTag; coinType?: bigint; gatewayUrls?: string[]; strict?: boolean; universalResolverAddress?: `0x${string}`; }GetEnsNameParameters
args.address`0x${string}`Address to get ENS name for.
args.blockNumber?bigintThe balance of the account at a block number.
args.blockTag?BlockTagThe balance of the account at a block tag. Default 'latest'
args.coinType?bigintENSIP-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
args.gatewayUrls?string[]Universal Resolver gateway URLs to use for resolving CCIP-read requests.
args.strict?booleanWhether or not to throw errors propagated from the ENS Universal Resolver Contract.
args.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 ​
ts
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() ​
ts
getEnsResolver: (args) => Promise<`0x${string}`>;

Gets resolver for ENS name.

Parameters ​
ParameterTypeDescription
args{ blockNumber?: bigint; blockTag?: BlockTag; name: string; universalResolverAddress?: `0x${string}`; }GetEnsResolverParameters
args.blockNumber?bigintThe balance of the account at a block number.
args.blockTag?BlockTagThe balance of the account at a block tag. Default 'latest'
args.namestringName to get the address for.
args.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 ​
ts
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() ​
ts
getEnsText: (args) => Promise<GetEnsTextReturnType>;

Gets a text record for specified ENS name.

Parameters ​
ParameterTypeDescription
args{ blockNumber?: bigint; blockTag?: BlockTag; gatewayUrls?: string[]; key: string; name: string; strict?: boolean; universalResolverAddress?: `0x${string}`; }GetEnsTextParameters
args.blockNumber?bigintThe balance of the account at a block number.
args.blockTag?BlockTagThe balance of the account at a block tag. Default 'latest'
args.gatewayUrls?string[]Universal Resolver gateway URLs to use for resolving CCIP-read requests.
args.keystringText record to retrieve.
args.namestringENS name to get Text for.
args.strict?booleanWhether or not to throw errors propagated from the ENS Universal Resolver Contract.
args.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 ​
ts
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() ​
ts
getFeeHistory: (args) => Promise<GetFeeHistoryReturnType>;

Returns a collection of historical gas information.

Parameters ​
ParameterTypeDescription
argsGetFeeHistoryParametersGetFeeHistoryParameters
Returns ​

Promise<GetFeeHistoryReturnType>

The gas estimate (in wei). GetFeeHistoryReturnType

Example ​
ts
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() ​
ts
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.

Type Parameters ​
Type ParameterDefault type
filterType extends FilterType-
abi extends readonly unknown[] | Abi | undefined-
eventName extends string | undefined-
strict extends boolean | undefinedundefined
fromBlock extends bigint | BlockTag | undefinedundefined
toBlock extends bigint | BlockTag | undefinedundefined
Parameters ​
ParameterTypeDescription
argsGetFilterChangesParameters<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:

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 ​
ts
// 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 })
ts
// 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 })
ts
// 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 })
ts
// 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() ​
ts
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.

Type Parameters ​
Type ParameterDefault type
abi extends readonly unknown[] | Abi | undefined-
eventName extends string | undefined-
strict extends boolean | undefinedundefined
fromBlock extends bigint | BlockTag | undefinedundefined
toBlock extends bigint | BlockTag | undefinedundefined
Parameters ​
ParameterTypeDescription
argsGetFilterLogsParameters<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 ​
ts
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() ​
ts
getGasPrice: () => Promise<bigint>;

Returns the current price of gas (in wei).

Returns ​

Promise<bigint>

The gas price (in wei). GetGasPriceReturnType

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

const client = createPublicClient({
  chain: mainnet,
  transport: http(),
})
const gasPrice = await client.getGasPrice()
getLogs() ​
ts
getLogs: <abiEvent, abiEvents, strict, fromBlock, toBlock>(args?) => Promise<GetLogsReturnType<abiEvent, abiEvents, strict, fromBlock, toBlock>>;

Returns a list of event logs matching the provided parameters.

Type Parameters ​
Type ParameterDefault type
abiEvent extends AbiEvent | undefinedundefined
abiEvents extends readonly unknown[] | readonly AbiEvent[] | undefinedabiEvent extends AbiEvent ? [abiEvent<abiEvent>] : undefined
strict extends boolean | undefinedundefined
fromBlock extends bigint | BlockTag | undefinedundefined
toBlock extends bigint | BlockTag | undefinedundefined
Parameters ​
ParameterTypeDescription
args?GetLogsParameters<abiEvent, abiEvents, strict, fromBlock, toBlock>GetLogsParameters
Returns ​

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

A list of event logs. GetLogsReturnType

Example ​
ts
import { createPublicClient, http, parseAbiItem } from 'viem'
import { mainnet } from 'viem/chains'

const client = createPublicClient({
  chain: mainnet,
  transport: http(),
})
const logs = await client.getLogs()
getProof() ​
ts
getProof: (args) => Promise<GetProofReturnType>;

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

Parameters ​
ParameterType
argsGetProofParameters
Returns ​

Promise<GetProofReturnType>

Proof data. GetProofReturnType

Example ​
ts
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() ​
ts
getStorageAt: (args) => Promise<GetStorageAtReturnType>;

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

Parameters ​
ParameterTypeDescription
argsGetStorageAtParametersGetStorageAtParameters
Returns ​

Promise<GetStorageAtReturnType>

The value of the storage slot. GetStorageAtReturnType

Example ​
ts
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() ​
ts
getTransaction: <blockTag>(args) => Promise<
  | {
  accessList?: undefined;
  authorizationList?: undefined;
  blobVersionedHashes?: undefined;
  blockHash: blockTag extends "pending" ? true : false extends true ? null : `0x${string}`;
  blockNumber: blockTag extends "pending" ? true : false extends true ? null : bigint;
  chainId?: number;
  from: `0x${string}`;
  gas: bigint;
  gasPrice: bigint;
  hash: `0x${string}`;
  input: `0x${string}`;
  maxFeePerBlobGas?: undefined;
  maxFeePerGas?: undefined;
  maxPriorityFeePerGas?: undefined;
  nonce: number;
  r: `0x${string}`;
  s: `0x${string}`;
  to: `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;
  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;
  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;
  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;
  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.

Type Parameters ​
Type ParameterDefault type
blockTag extends BlockTag"latest"
Parameters ​
ParameterTypeDescription
argsGetTransactionParameters<blockTag>GetTransactionParameters
Returns ​

Promise< | { accessList?: undefined; authorizationList?: undefined; blobVersionedHashes?: undefined; blockHash: blockTag extends "pending" ? true : false extends true ? null : `0x${string}`; blockNumber: blockTag extends "pending" ? true : false extends true ? null : bigint; chainId?: number; from: `0x${string}`; gas: bigint; gasPrice: bigint; hash: `0x${string}`; input: `0x${string}`; maxFeePerBlobGas?: undefined; maxFeePerGas?: undefined; maxPriorityFeePerGas?: undefined; nonce: number; r: `0x${string}`; s: `0x${string}`; to: `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; 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; 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; 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; 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 ​
ts
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() ​
ts
getTransactionConfirmations: (args) => Promise<bigint>;

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

Parameters ​
ParameterTypeDescription
argsGetTransactionConfirmationsParameters<Chain | undefined>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 ​
ts
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() ​
ts
getTransactionCount: (args) => Promise<number>;

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

Parameters ​
ParameterTypeDescription
argsGetTransactionCountParametersGetTransactionCountParameters
Returns ​

Promise<number>

The number of transactions an account has sent. GetTransactionCountReturnType

Example ​
ts
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() ​
ts
getTransactionReceipt: (args) => Promise<TransactionReceipt>;

Returns the Transaction Receipt given a Transaction hash.

Parameters ​
ParameterTypeDescription
argsGetTransactionReceiptParametersGetTransactionReceiptParameters
Returns ​

Promise<TransactionReceipt>

The transaction receipt. GetTransactionReceiptReturnType

Example ​
ts
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 ​
ts
key: string;

A key for the client.

multicall() ​
ts
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.

Type Parameters ​
Type ParameterDefault type
contracts extends readonly unknown[]-
allowFailure extends booleantrue
Parameters ​
ParameterTypeDescription
argsMulticallParameters<contracts, allowFailure>MulticallParameters
Returns ​

Promise<MulticallReturnType<contracts, allowFailure>>

An array of results with accompanying status. MulticallReturnType

Example ​
ts
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 ​
ts
name: string;

A name for the client.

pollingInterval ​
ts
pollingInterval: number;

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

prepareTransactionRequest() ​
ts
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" | "nonce" | "chainId" | "gas" | "fees" | "blobVersionedHashes">> & (unknown extends request["kzg"] ? {} : Pick<request, "kzg">))[K] }>;

Prepares a transaction request for signing.

Type Parameters ​
Type ParameterDefault type
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 extends Chain | undefinedundefined
accountOverride extends `0x${string}` | Account | undefinedundefined
Parameters ​
ParameterTypeDescription
argsPrepareTransactionRequestParameters<Chain | undefined, 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" | "nonce" | "chainId" | "gas" | "fees" | "blobVersionedHashes">> & (unknown extends request["kzg"] ? {} : Pick<request, "kzg">))[K] }>

The transaction request. PrepareTransactionRequestReturnType

Examples ​
ts
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,
})
ts
// 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() ​
ts
readContract: <abi, functionName, args>(args) => Promise<ReadContractReturnType<abi, functionName, args>>;

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

Type Parameters ​
Type Parameter
abi extends readonly unknown[] | Abi
functionName extends string
args extends unknown
Parameters ​
ParameterTypeDescription
argsReadContractParameters<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 ​
ts
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 ​
ts
request: EIP1193RequestFn<PublicRpcSchema>;

Request function wrapped with friendly error handling

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

Sends a signed transaction to the network

Parameters ​
ParameterType
argsSendRawTransactionParameters
Returns ​

Promise<`0x${string}`>

The transaction hash. SendRawTransactionReturnType

Example ​
ts
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() ​
ts
sendRawTransactionSync: (args) => Promise<TransactionReceipt>;

Sends a signed transaction to the network

Parameters ​
ParameterType
argsSendRawTransactionSyncParameters
Returns ​

Promise<TransactionReceipt>

The transaction receipt. SendRawTransactionSyncReturnType

Example ​
ts
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() ​
ts
simulate: <calls>(args) => Promise<SimulateBlocksReturnType<calls>>;
Type Parameters ​
Type Parameter
calls extends readonly unknown[]
Parameters ​
ParameterType
argsSimulateBlocksParameters<calls>
Returns ​

Promise<SimulateBlocksReturnType<calls>>

Deprecated ​

Use simulateBlocks instead.

simulateBlocks() ​
ts
simulateBlocks: <calls>(args) => Promise<SimulateBlocksReturnType<calls>>;

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

Type Parameters ​
Type Parameter
calls extends readonly unknown[]
Parameters ​
ParameterType
argsSimulateBlocksParameters<calls>
Returns ​

Promise<SimulateBlocksReturnType<calls>>

Simulated blocks. SimulateReturnType

Example ​
ts
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() ​
ts
simulateCalls: <calls>(args) => Promise<SimulateCallsReturnType<calls>>;

Simulates a set of calls.

Type Parameters ​
Type Parameter
calls extends readonly unknown[]
Parameters ​
ParameterType
argsSimulateCallsParameters<calls>
Returns ​

Promise<SimulateCallsReturnType<calls>>

Results. SimulateCallsReturnType

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

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

Type Parameters ​
Type ParameterDefault type
abi extends readonly unknown[] | Abi-
functionName extends string-
args extends unknown-
chainOverride extends Chain | undefined-
accountOverride extends `0x${string}` | Account | undefinedundefined
Parameters ​
ParameterTypeDescription
argsSimulateContractParameters<abi, functionName, args, Chain | undefined, chainOverride, accountOverride>SimulateContractParameters
Returns ​

Promise<SimulateContractReturnType<abi, functionName, args, Chain | undefined, 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 ​
ts
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 ​
ts
transport: TransportConfig<string, EIP1193RequestFn> & Record<string, any>;

The RPC transport

type ​
ts
type: string;

The type of client.

uid ​
ts
uid: string;

A unique ID for the client.

uninstallFilter() ​
ts
uninstallFilter: (args) => Promise<boolean>;

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

Parameters ​
ParameterTypeDescription
argsUninstallFilterParametersUninstallFilterParameters
Returns ​

Promise<boolean>

A boolean indicating if the Filter was successfully uninstalled. UninstallFilterReturnType

Example ​
ts
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() ​
ts
verifyHash: (args) => Promise<boolean>;

Verify that a hash was signed by the provided address.

Parameters ​
ParameterType
argsVerifyHashParameters
Returns ​

Promise<boolean>

Whether or not the signature is valid. VerifyHashReturnType

verifyMessage() ​
ts
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.

Parameters ​
ParameterTypeDescription
args{ address: `0x${string}`; blockNumber?: bigint; blockTag?: BlockTag; chain?: Chain | null; erc6492VerifierAddress?: `0x${string}`; factory?: `0x${string}`; factoryData?: `0x${string}`; message: SignableMessage; multicallAddress?: `0x${string}`; signature: `0x${string}` | Signature | ByteArray; universalSignatureVerifierAddress?: `0x${string}`; }-
args.address`0x${string}`The address that signed the original message.
args.blockNumber?bigintThe balance of the account at a block number.
args.blockTag?BlockTagThe balance of the account at a block tag. Default 'latest'
args.chain?Chain | nullThe chain to use.
args.erc6492VerifierAddress?`0x${string}`The address of the ERC-6492 signature verifier contract.
args.factory?`0x${string}`-
args.factoryData?`0x${string}`-
args.messageSignableMessageThe message to be verified.
args.multicallAddress?`0x${string}`Multicall3 address for ERC-8010 verification.
args.signature`0x${string}` | Signature | ByteArrayThe signature that was generated by signing the message with the address's private key.
args.universalSignatureVerifierAddress?`0x${string}`Deprecated use erc6492VerifierAddress instead.
Returns ​

Promise<boolean>

Whether or not the signature is valid. VerifyMessageReturnType

verifySiweMessage() ​
ts
verifySiweMessage: (args) => Promise<boolean>;

Verifies EIP-4361 formatted message was signed.

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

Parameters ​
ParameterTypeDescription
args{ address?: `0x${string}`; blockNumber?: bigint; blockTag?: BlockTag; domain?: string; message: string; nonce?: string; scheme?: string; signature: `0x${string}`; time?: Date; }-
args.address?`0x${string}`Ethereum address to check against.
args.blockNumber?bigintThe balance of the account at a block number.
args.blockTag?BlockTagThe balance of the account at a block tag. Default 'latest'
args.domain?stringRFC 3986 authority to check against.
args.messagestringEIP-4361 formatted message.
args.nonce?stringRandom string to check against.
args.scheme?stringRFC 3986 URI scheme to check against.
args.signature`0x${string}`Signature to check against.
args.time?DateCurrent time to check optional expirationTime and notBefore fields. Default new Date()
Returns ​

Promise<boolean>

Whether or not the signature is valid. VerifySiweMessageReturnType

verifyTypedData() ​
ts
verifyTypedData: (args) => Promise<boolean>;

Verify that typed data was signed by the provided address.

Parameters ​
ParameterType
argsVerifyTypedDataParameters
Returns ​

Promise<boolean>

Whether or not the signature is valid. VerifyTypedDataReturnType

waitForTransactionReceipt() ​
ts
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.

Parameters ​
ParameterTypeDescription
argsWaitForTransactionReceiptParameters<Chain | undefined>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 ​
ts
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() ​
ts
watchBlockNumber: (args) => WatchBlockNumberReturnType;

Watches and returns incoming block numbers.

Parameters ​
ParameterTypeDescription
argsWatchBlockNumberParametersWatchBlockNumberParameters
Returns ​

WatchBlockNumberReturnType

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

Example ​
ts
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() ​
ts
watchBlocks: <includeTransactions, blockTag>(args) => WatchBlocksReturnType;

Watches and returns information for incoming blocks.

Type Parameters ​
Type ParameterDefault type
includeTransactions extends booleanfalse
blockTag extends BlockTag"latest"
Parameters ​
ParameterTypeDescription
argsWatchBlocksParameters<Transport, Chain | undefined, includeTransactions, blockTag>WatchBlocksParameters
Returns ​

WatchBlocksReturnType

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

Example ​
ts
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() ​
ts
watchContractEvent: <abi, eventName, strict>(args) => WatchContractEventReturnType;

Watches and returns emitted contract event logs.

Type Parameters ​
Type ParameterDefault type
abi extends readonly unknown[] | Abi-
eventName extends string-
strict extends boolean | undefinedundefined
Parameters ​
ParameterTypeDescription
argsWatchContractEventParameters<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 ​
ts
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() ​
ts
watchEvent: <abiEvent, abiEvents, strict>(args) => WatchEventReturnType;

Watches and returns emitted Event Logs.

Type Parameters ​
Type ParameterDefault type
abiEvent extends AbiEvent | undefinedundefined
abiEvents extends readonly unknown[] | readonly AbiEvent[] | undefinedabiEvent extends AbiEvent ? [abiEvent<abiEvent>] : undefined
strict extends boolean | undefinedundefined
Parameters ​
ParameterTypeDescription
argsWatchEventParameters<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 ​
ts
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() ​
ts
watchPendingTransactions: (args) => WatchPendingTransactionsReturnType;

Watches and returns pending transaction hashes.

Parameters ​
ParameterTypeDescription
argsWatchPendingTransactionsParameters<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 ​
ts
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),
})
recipient ​
ts
recipient: `0x${string}`;

Defined in: packages/sdk/src/utils/testScenarios.ts:16

sender ​
ts
sender: `0x${string}`;

Defined in: packages/sdk/src/utils/testScenarios.ts:14

tokenAddress ​
ts
tokenAddress: `0x${string}`;

Defined in: packages/sdk/src/utils/testScenarios.ts:17

Released under the MIT License. | Last Updated: 2026-01-15 09:16

Copyright © 2023-present AAStar Community