Lelantos SDK

Appearance

@lelantos-org/sdk / index / ViemChainAdapter

Class: ViemChainAdapter ​

Defined in: @lelantos-org/sdk/dist/chain/viem/index.d.ts:21

Adapters MUST be deterministic w.r.t. constructor inputs (no hidden global state).

Implements ​

Constructors ​

Constructor ​

ts
new ViemChainAdapter(opts): ViemChainAdapter;

Defined in: @lelantos-org/sdk/dist/chain/viem/index.d.ts:30

Parameters ​

ParameterType
optsViemChainAdapterOpts

Returns ​

ViemChainAdapter

Properties ​

publicClient ​

ts
readonly publicClient: object;

Defined in: @lelantos-org/sdk/dist/chain/viem/index.d.ts:22

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.

Union Members ​

boolean

Type Literal ​
ts
{
  batchSize?: number;
  deployless?: boolean;
  wait?: number;
}
batchSize? ​
ts
optional batchSize?: number;

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

Default ​
ts
1_024
deployless? ​
ts
optional deployless?: boolean;

Enable deployless multicall.

wait? ​
ts
optional wait?: number;

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

Default ​
ts
0

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.

Union Members ​

false

Type Literal ​
ts
{
  request?: (parameters) => Promise<`0x${string}`>;
}
request? ​
ts
optional request?: (parameters) => Promise<`0x${string}`>;

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

Parameters ​
ParameterType
parametersCcipRequestParameters
Returns ​

Promise<`0x${string}`>

See ​

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

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: RpcLog[] | `0x${string}`[];
   }, {
     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: RpcLog[] | `0x${string}`[]; }, { 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 Abi | readonly unknown[]-
eventName extends string | undefined-
args extends Record<string, unknown> | readonly 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] : undefined
strict extends boolean | undefinedundefined
fromBlock extends bigint | BlockTag | undefinedundefined
toBlock extends bigint | BlockTag | undefinedundefined
_EventName extends string | undefinedMaybeAbiEventName<abiEvent>
_Args extends Record<string, unknown> | readonly 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: RpcLog[] | `0x${string}`[];
   }, {
     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: RpcLog[] | `0x${string}`[]; }, { 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' }

dataSuffix? ​

ts
optional dataSuffix?: DataSuffix;

Data suffix to append to transaction data.

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 Abi | readonly unknown[]
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, undefined, Tokens | undefined>, Tokens | undefined>;
Type Parameters ​
Type Parameter
client extends object & ExactPartial<ExtendableProtectedActions<Transport, Chain | undefined, undefined, Tokens | undefined>>
Parameters ​
ParameterType
fn(client) => client
Returns ​

Client<Transport, Chain | undefined, undefined, PublicRpcSchema, { [K in string | number | symbol]: client[K] } & PublicActions<Transport, Chain | undefined, undefined, Tokens | undefined>, Tokens | 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, 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;
     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.

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; 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 ​
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

getBlockReceipts ​

ts
getBlockReceipts: (args?) => Promise<GetBlockReceiptsReturnType<Chain | undefined>>;

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

Parameters ​
ParameterTypeDescription
args?GetBlockReceiptsParametersGetBlockReceiptsParameters
Returns ​

Promise<GetBlockReceiptsReturnType<Chain | undefined>>

The transaction receipts. GetBlockReceiptsReturnType

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

const client = createPublicClient({
  chain: mainnet,
  transport: http(),
})
const receipts = await client.getBlockReceipts({
  blockNumber: 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 Abi | readonly unknown[]-
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'
})

getDelegation ​

ts
getDelegation: (args) => Promise<GetDelegationReturnType>;

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

Parameters ​
ParameterTypeDescription
argsGetDelegationParametersGetDelegationParameters
Returns ​

Promise<GetDelegationReturnType>

The delegated address, or undefined if not delegated. GetDelegationReturnType

Example ​
ts
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 ​

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 block number to perform the call against.
args.blockTag?BlockTagThe block tag to perform the call against. 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 block number to perform the call against.
args.blockTag?BlockTagThe block tag to perform the call against. 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 block number to perform the call against.
args.blockTag?BlockTagThe block tag to perform the call against. 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 block number to perform the call against.
args.blockTag?BlockTagThe block tag to perform the call against. 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 block number to perform the call against.
args.blockTag?BlockTagThe block tag to perform the call against. 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 Abi | readonly unknown[] | 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 Abi | readonly unknown[] | 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] : 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...'],
})

getRawTransaction ​

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

Returns the raw, serialized Transaction given a hash.

Parameters ​
ParameterTypeDescription
argsGetRawTransactionParametersGetRawTransactionParameters
Returns ​

Promise<`0x${string}`>

The raw, serialized transaction. GetRawTransactionReturnType

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

const client = createPublicClient({
  chain: mainnet,
  transport: http(),
})
const rawTransaction = await client.getRawTransaction({
  hash: '0x4ca7ee652d57678f26e887c149ab0735f41de37bcad58c9f6d3ed5824f15b74d',
})

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;
  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.

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; 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 ​
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] : "chainId" | "type" | "gas" | "nonce" | "blobVersionedHashes" | "fees">> & (unknown extends request["kzg"] ? {} : Pick<request, "kzg">) & { _capabilities?: { [key: string]: any } })[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, 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] : "chainId" | "type" | "gas" | "nonce" | "blobVersionedHashes" | "fees">> & (unknown extends request["kzg"] ? {} : Pick<request, "kzg">) & { _capabilities?: { [key: string]: any } })[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 Abi | readonly unknown[]
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, 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 Abi | readonly unknown[]-
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, 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',
})

token ​

ts
token: object;

Read-only ERC-20 Actions, exposed under the token namespace.

Every action selects its token by token, which is either a token symbol (resolved from the Client's tokens array) or a contract address.

token.getAllowance ​
ts
getAllowance: (parameters) => Promise<Amount> & object;

Gets the amount of tokens a spender is allowed to spend on behalf of an account.

Type Declaration ​
call ​
ts
call: (args) => object & object & object & object;

Defines an allowance contract call, ready to pass to multicall, simulateContract, or any other action that accepts a contract call.

Parameters ​
ParameterTypeDescription
argsArgs<Chain | undefined, Tokens | undefined>getAllowance.Args
Returns ​

object & object & object & object

The contract call.

Param ​

parameters

getAllowance.Parameters

Returns ​

The remaining allowance, in base units and human-readable form. getAllowance.ReturnValue

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

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

const allowance = await client.token.getAllowance({
  account: '0x…',
  spender: '0x…',
  token: 'usdc',
})
token.getBalance ​
ts
getBalance: (parameters) => Promise<Amount> & object;

Gets the token balance of an account.

Type Declaration ​
call ​
ts
call: (args) => object & object & object & object;

Defines a balanceOf contract call, ready to pass to multicall, simulateContract, or any other action that accepts a contract call.

Parameters ​
ParameterTypeDescription
argsArgs<Chain | undefined, undefined, Tokens | undefined>getTokenBalance.Args
Returns ​

object & object & object & object

The contract call.

Param ​

parameters

getTokenBalance.Parameters

Returns ​

The token balance, in base units and human-readable form. getTokenBalance.ReturnValue

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

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

const balance = await client.token.getBalance({
  account: '0x…',
  token: 'usdc',
})
token.getMetadata ​
ts
getMetadata: (parameters) => Promise<ReturnValue>;

Gets the metadata (decimals, name, symbol) of the token. Fields declared on the Client's tokens array are used as-is; any missing field is fetched from the token contract.

Parameters ​
ParameterTypeDescription
parametersParameters<Chain | undefined, Tokens | undefined>getMetadata.Parameters
Returns ​

Promise<ReturnValue>

The token metadata (decimals, name, symbol). getMetadata.ReturnValue

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

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

const metadata = await client.token.getMetadata({ token: 'usdc' })
token.getTotalSupply ​
ts
getTotalSupply: (parameters) => Promise<Amount> & object;

Gets the total supply of the token.

Type Declaration ​
call ​
ts
call: (args) => object & object & object & object;

Defines a totalSupply contract call, ready to pass to multicall, simulateContract, or any other action that accepts a contract call.

Parameters ​
ParameterTypeDescription
argsArgs<Chain | undefined, Tokens | undefined>getTotalSupply.Args
Returns ​

object & object & object & object

The contract call.

Param ​

parameters

getTotalSupply.Parameters

Returns ​

The token total supply, in base units and human-readable form. getTotalSupply.ReturnValue

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

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

const totalSupply = await client.token.getTotalSupply({ token: 'usdc' })

tokens ​

ts
tokens: Tokens | undefined;

Collection of tokens declared on the Client.

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 ​
ParameterType
argsVerifyMessageParameters
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 ​
ParameterType
argsVerifySiweMessageParameters
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',
})

watchBlockHeaders ​

ts
watchBlockHeaders: (args) => WatchBlockHeadersReturnType;

Watches and returns incoming block headers without fetching full blocks.

Parameters ​
ParameterTypeDescription
argsneverWatchBlockHeadersParameters
Returns ​

WatchBlockHeadersReturnType

A function that can be invoked to stop watching for new block headers. WatchBlockHeadersReturnType

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

const client = createPublicClient({
  chain: mainnet,
  transport: webSocket(),
})
const unwatch = client.watchBlockHeaders({
  onBlockHeader: (blockHeader) => console.log(blockHeader),
})

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 Abi | readonly unknown[]-
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] : 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),
})

signer ​

ts
readonly signer: EthSigner;

Defined in: @lelantos-org/sdk/dist/chain/viem/index.d.ts:23

Methods ​

blockNumber() ​

ts
blockNumber(): Promise<number>;

Defined in: @lelantos-org/sdk/dist/chain/viem/index.d.ts:33

Current chain tip. Feeds SelectOpts.tipBlock, without which the selector's spend cooldown is inert. Names no address and no topic. Optional.

Returns ​

Promise<number>

Implementation of ​

ChainAdapter.blockNumber

cancelDelay() ​

ts
cancelDelay(): Promise<number>;

Defined in: @lelantos-org/sdk/dist/chain/viem/index.d.ts:38

Blocks before cancelDeposit is allowed. Optional.

Returns ​

Promise<number>

Implementation of ​

ChainAdapter.cancelDelay

cancelDeposit() ​

ts
cancelDeposit(id, inputs): Promise<{
  txHash: Hex32;
}>;

Defined in: @lelantos-org/sdk/dist/chain/viem/index.d.ts:82

MASP.cancelDeposit. On-chain digest check rejects tampered preimages. Optional.

Parameters ​

ParameterType
idbigint
inputsCancelDepositInputs

Returns ​

Promise<{ txHash: Hex32; }>

Implementation of ​

ChainAdapter.cancelDeposit

cancelDepositNative() ​

ts
cancelDepositNative(id, inputs): Promise<{
  txHash: Hex32;
}>;

Defined in: @lelantos-org/sdk/dist/chain/viem/index.d.ts:85

NativeAdapter.cancelNative — the only way to settle an adapter-owned escrow by refund, since the pool would return the coin to the adapter. No payer: the adapter supplies its own. Optional.

Parameters ​

ParameterType
idbigint
inputsOmit<CancelDepositInputs, "payer">

Returns ​

Promise<{ txHash: Hex32; }>

Implementation of ​

ChainAdapter.cancelDepositNative

chainId() ​

ts
chainId(): Promise<bigint>;

Defined in: @lelantos-org/sdk/dist/chain/viem/index.d.ts:31

Returns ​

Promise<bigint>

Implementation of ​

ChainAdapter.chainId

fetchAsset() ​

ts
fetchAsset(id): Promise<AssetEntry>;

Defined in: @lelantos-org/sdk/dist/chain/viem/index.d.ts:34

Parameters ​

ParameterType
idAssetId

Returns ​

Promise<AssetEntry>

Implementation of ​

ChainAdapter.fetchAsset

fetchDepositEscrowed() ​

ts
fetchDepositEscrowed(id, fromBlock?): Promise<
  | DepositEscrowedRecord
| null>;

Defined in: @lelantos-org/sdk/dist/chain/viem/index.d.ts:37

Parameters ​

ParameterType
idbigint
fromBlock?bigint

Returns ​

Promise< | DepositEscrowedRecord | null>

fetchFeeBps() ​

ts
fetchFeeBps(): Promise<bigint>;

Defined in: @lelantos-org/sdk/dist/chain/viem/index.d.ts:35

0 disables fees.

Returns ​

Promise<bigint>

Implementation of ​

ChainAdapter.fetchFeeBps

getEscrowed() ​

ts
getEscrowed(id): Promise<EscrowedDepositView | null>;

Defined in: @lelantos-org/sdk/dist/chain/viem/index.d.ts:36

MASP.escrowed(id) — null if flushed/cancelled. Optional.

Parameters ​

ParameterType
idbigint

Returns ​

Promise<EscrowedDepositView | null>

Implementation of ​

ChainAdapter.getEscrowed

maspAddress() ​

ts
maspAddress(): Promise<EvmAddress>;

Defined in: @lelantos-org/sdk/dist/chain/viem/index.d.ts:116

Used as the Permit2 spender.

Returns ​

Promise<EvmAddress>

Implementation of ​

ChainAdapter.maspAddress

nativeAdapterAddress() ​

ts
nativeAdapterAddress(): EvmAddress | undefined;

Defined in: @lelantos-org/sdk/dist/chain/viem/index.d.ts:118

undefined when no NativeAdapter is configured for this chain.

Returns ​

EvmAddress | undefined

Implementation of ​

ChainAdapter.nativeAdapterAddress

nativeBalance() ​

ts
nativeBalance(account): Promise<bigint>;

Defined in: @lelantos-org/sdk/dist/chain/viem/index.d.ts:52

Wei. Optional.

Parameters ​

ParameterType
accountEvmAddress

Returns ​

Promise<bigint>

Implementation of ​

ChainAdapter.nativeBalance

payerAddress() ​

ts
payerAddress(): Promise<EvmAddress>;

Defined in: @lelantos-org/sdk/dist/chain/viem/index.d.ts:32

Signer's eth address (== pi.payer for deposit).

Returns ​

Promise<EvmAddress>

Implementation of ​

ChainAdapter.payerAddress

permit2Address() ​

ts
permit2Address(): EvmAddress;

Defined in: @lelantos-org/sdk/dist/chain/viem/index.d.ts:115

Optional; adapters that don't use Permit2 omit.

Returns ​

EvmAddress

Implementation of ​

ChainAdapter.permit2Address

permit2Allowance() ​

ts
permit2Allowance(
   tok, 
   owner, 
   spender
): Promise<{
  amount: TokenAmount;
  expiration: number;
  nonce: number;
}>;

Defined in: @lelantos-org/sdk/dist/chain/viem/index.d.ts:92

IAllowanceTransfer.allowance — cap, expiry, nonce. Optional.

Parameters ​

ParameterType
tokEvmAddress
ownerEvmAddress
spenderEvmAddress

Returns ​

Promise<{ amount: TokenAmount; expiration: number; nonce: number; }>

Implementation of ​

ChainAdapter.permit2Allowance

permit2Nonce() ​

ts
permit2Nonce(): Promise<bigint>;

Defined in: @lelantos-org/sdk/dist/chain/viem/index.d.ts:114

Free slot in Permit2's unordered nonce bitmap. Optional; adapters returning a deterministic nonce can omit.

Returns ​

Promise<bigint>

Implementation of ​

ChainAdapter.permit2Nonce

permit2PermitAllowance() ​

ts
permit2PermitAllowance(args, onTxHash?): Promise<{
  txHash: Hex32;
}>;

Defined in: @lelantos-org/sdk/dist/chain/viem/index.d.ts:97

Submit pre-signed PermitSingle via IAllowanceTransfer.permit. Anyone can submit; relayer-gasless variants may override. Optional.

Parameters ​

ParameterType
args{ owner: EvmAddress; permit: PermitSingle; signature: string; }
args.ownerEvmAddress
args.permit?PermitSingle
args.signature?string
onTxHash?(hash) => void

Returns ​

Promise<{ txHash: Hex32; }>

Implementation of ​

ChainAdapter.permit2PermitAllowance

permit2PermitAllowanceBatch() ​

ts
permit2PermitAllowanceBatch(args, onTxHash?): Promise<{
  txHash: Hex32;
}>;

Defined in: @lelantos-org/sdk/dist/chain/viem/index.d.ts:107

Submit a pre-signed PermitBatch via the permit overload taking an array — one tx establishes N token windows. Optional.

Parameters ​

ParameterType
args{ owner: EvmAddress; permit: PermitBatch; signature: string; }
args.ownerEvmAddress
args.permit?PermitBatch
args.signature?string
onTxHash?(hash) => void

Returns ​

Promise<{ txHash: Hex32; }>

Implementation of ​

ChainAdapter.permit2PermitAllowanceBatch

signPermit2() ​

ts
signPermit2(args): Promise<Permit2Sig>;

Defined in: @lelantos-org/sdk/dist/chain/viem/index.d.ts:88

Sign Permit2 PermitWitnessTransferFrom witness-bound to piHash = keccak256(abi.encode(DepositRequest, aux)).

Parameters ​

ParameterType
argsPermit2SignArgs

Returns ​

Promise<Permit2Sig>

Implementation of ​

ChainAdapter.signPermit2

signPermit2Allowance() ​

ts
signPermit2Allowance(permit): Promise<{
  signature: string;
}>;

Defined in: @lelantos-org/sdk/dist/chain/viem/index.d.ts:89

Sign PermitSingle for AllowanceTransfer-mode deposits. Optional.

Parameters ​

ParameterType
permitPermitSingle

Returns ​

Promise<{ signature: string; }>

Implementation of ​

ChainAdapter.signPermit2Allowance

signPermit2AllowanceBatch() ​

ts
signPermit2AllowanceBatch(permit): Promise<{
  signature: string;
}>;

Defined in: @lelantos-org/sdk/dist/chain/viem/index.d.ts:104

Sign one PermitBatch covering N tokens. Optional.

Parameters ​

ParameterType
permitPermitBatch

Returns ​

Promise<{ signature: string; }>

Implementation of ​

ChainAdapter.signPermit2AllowanceBatch

submitDeposit() ​

ts
submitDeposit(args): Promise<{
  depositId: bigint;
  txHash: Hex32;
}>;

Defined in: @lelantos-org/sdk/dist/chain/viem/index.d.ts:53

MASP.deposit(d, sig, aux). Returns tx hash + deposit id from the DepositEscrowed log. Optional: relayer-broadcast adapters omit.

Parameters ​

ParameterType
args{ aux: AuxOutput; deposit: DepositRequest; feeAux: AuxOutput; onSent?: (txHash) => void; permit2: Permit2Sig; }
args.auxAuxOutput
args.depositDepositRequest
args.feeAuxAuxOutput
args.onSent?(txHash) => void
args.permit2Permit2Sig

Returns ​

Promise<{ depositId: bigint; txHash: Hex32; }>

Implementation of ​

ChainAdapter.submitDeposit

submitDepositAuthorized() ​

ts
submitDepositAuthorized(args): Promise<{
  depositId: bigint;
  txHash: Hex32;
}>;

Defined in: @lelantos-org/sdk/dist/chain/viem/index.d.ts:73

MASP.depositAuthorized. Pulls via Permit2 AllowanceTransfer against a previously-signed window; no per-deposit sig. Optional.

Parameters ​

ParameterType
args{ aux: AuxOutput; deposit: DepositRequest; feeAux: AuxOutput; onSent?: (txHash) => void; }
args.auxAuxOutput
args.depositDepositRequest
args.feeAuxAuxOutput
args.onSent?(txHash) => void

Returns ​

Promise<{ depositId: bigint; txHash: Hex32; }>

Implementation of ​

ChainAdapter.submitDepositAuthorized

submitDepositNative() ​

ts
submitDepositNative(args): Promise<{
  depositId: bigint;
  txHash: Hex32;
}>;

Defined in: @lelantos-org/sdk/dist/chain/viem/index.d.ts:63

NativeAdapter.depositNative with msg.value = value. The pool is ERC-20 only, so the adapter wraps the coin, escrows it under its own name and returns the excess — deposit.payer must therefore be the adapter, not the sender. Asset id must be WETH-registered. Optional, and unavailable on a chain with no adapter deployed.

Parameters ​

ParameterType
args{ aux: AuxOutput; deposit: DepositRequest; feeAux: AuxOutput; onSent?: (txHash) => void; value: bigint; }
args.auxAuxOutput
args.depositDepositRequest
args.feeAuxAuxOutput
args.onSent?(txHash) => void
args.valuebigint

Returns ​

Promise<{ depositId: bigint; txHash: Hex32; }>

Implementation of ​

ChainAdapter.submitDepositNative

tokenAllowance() ​

ts
tokenAllowance(
   a, 
   owner, 
   spender
): Promise<TokenAmount>;

Defined in: @lelantos-org/sdk/dist/chain/viem/index.d.ts:41

Parameters ​

ParameterType
aEvmAddress
ownerEvmAddress
spenderEvmAddress

Returns ​

Promise<TokenAmount>

Implementation of ​

ChainAdapter.tokenAllowance

tokenApprove() ​

ts
tokenApprove(
   a, 
   spender, 
   amount, 
   onTxHash?
): Promise<{
  txHash: Hex32;
}>;

Defined in: @lelantos-org/sdk/dist/chain/viem/index.d.ts:42

Parameters ​

ParameterType
aEvmAddress
spenderEvmAddress
amountTokenAmount
onTxHash?(hash) => void

Returns ​

Promise<{ txHash: Hex32; }>

Implementation of ​

ChainAdapter.tokenApprove

tokenBalanceOf() ​

ts
tokenBalanceOf(a, account): Promise<TokenAmount>;

Defined in: @lelantos-org/sdk/dist/chain/viem/index.d.ts:40

Parameters ​

ParameterType
aEvmAddress
accountEvmAddress

Returns ​

Promise<TokenAmount>

Implementation of ​

ChainAdapter.tokenBalanceOf

tokenMeta() ​

ts
tokenMeta(a): Promise<TokenMeta>;

Defined in: @lelantos-org/sdk/dist/chain/viem/index.d.ts:39

Optional. CLIs/UIs feature-check before calling.

Parameters ​

ParameterType
aEvmAddress

Returns ​

Promise<TokenMeta>

Implementation of ​

ChainAdapter.tokenMeta

waitTxReceipt() ​

ts
waitTxReceipt(txHash, confirmations?): Promise<{
  blockNumber: number;
  status: number;
}>;

Defined in: @lelantos-org/sdk/dist/chain/viem/index.d.ts:48

Returns block number + receipt status (1 = success, 0 = revert).

Parameters ​

ParameterType
txHashHex32
confirmations?number

Returns ​

Promise<{ blockNumber: number; status: number; }>

Implementation of ​

ChainAdapter.waitTxReceipt

wrapNative() ​

ts
wrapNative(wethAddr, value): Promise<{
  txHash: Hex32;
}>;

Defined in: @lelantos-org/sdk/dist/chain/viem/index.d.ts:45

WETH9.deposit{value}. Optional.

Parameters ​

ParameterType
wethAddrEvmAddress
valuebigint

Returns ​

Promise<{ txHash: Hex32; }>

Implementation of ​

ChainAdapter.wrapNative