Type alias WalletActions<TChain, TAccount>

WalletActions<TChain, TAccount>: {
    addChain: ((args) => Promise<void>);
    deployContract: (<const TAbi, TChainOverride>(args) => Promise<DeployContractReturnType>);
    getAddresses: (() => Promise<GetAddressesReturnType>);
    getChainId: (() => Promise<GetChainIdReturnType>);
    getPermissions: (() => Promise<GetPermissionsReturnType>);
    prepareTransactionRequest: (<TChainOverride>(args) => Promise<PrepareTransactionRequestReturnType>);
    requestAddresses: (() => Promise<RequestAddressesReturnType>);
    requestPermissions: ((args) => Promise<RequestPermissionsReturnType>);
    sendRawTransaction: ((args) => Promise<SendRawTransactionReturnType>);
    sendTransaction: (<TChainOverride>(args) => Promise<SendTransactionReturnType>);
    signMessage: ((args) => Promise<SignMessageReturnType>);
    signTransaction: (<TChainOverride>(args) => Promise<SignTransactionReturnType>);
    signTypedData: (<const TTypedData, TPrimaryType>(args) => Promise<SignTypedDataReturnType>);
    switchChain: ((args) => Promise<void>);
    watchAsset: ((args) => Promise<WatchAssetReturnType>);
    writeContract: (<const TAbi, TFunctionName, TChainOverride>(args) => Promise<WriteContractReturnType>);
}

Type Parameters

TChain extends Chain | undefined = Chain | undefined
TAccount extends Account | undefined = Account | undefined

Type declaration

addChain: ((args) => Promise<void>)
- - (args): Promise<void>
  - Adds an EVM chain to the wallet.
    - Docs: https://viem.sh/docs/actions/wallet/addChain.html
    - JSON-RPC Methods: eth_addEthereumChain
    Parameters
    - args: AddChainParameters
      AddChainParameters
    Returns Promise<void>
    Example
```
import { createWalletClient, custom } from 'viem'
import { optimism } from 'viem/chains'

const client = createWalletClient({
  transport: custom(window.ethereum),
})
await client.addChain({ chain: optimism })
```
deployContract: (<const TAbi, TChainOverride>(args) => Promise<DeployContractReturnType>)
- - <const TAbi, TChainOverride>(args): Promise<DeployContractReturnType>
  - Deploys a contract to the network, given bytecode and constructor arguments.
    - Docs: https://viem.sh/docs/contract/deployContract.html
    - Examples: https://stackblitz.com/github/wevm/viem/tree/main/examples/contracts/deploying-contracts
    Type Parameters
    - const TAbi extends Abi | readonly unknown[]
    - TChainOverride extends Chain | undefined = undefined
    Parameters
    - args: DeployContractParameters<TAbi, TChain, TAccount, TChainOverride>
      DeployContractParameters
    Returns Promise<DeployContractReturnType>
    The Transaction hash. DeployContractReturnType
    Example
```
import { createWalletClient, http } from 'viem'
import { privateKeyToAccount } from 'viem/accounts'
import { mainnet } from 'viem/chains'

const client = createWalletClient({
  account: privateKeyToAccount('0x…'),
  chain: mainnet,
  transport: http(),
})
const hash = await client.deployContract({
  abi: [],
  account: '0x…,
  bytecode: '0x608060405260405161083e38038061083e833981016040819052610...',
})
```
getAddresses: (() => Promise<GetAddressesReturnType>)
- - (): Promise<GetAddressesReturnType>
  - Returns a list of account addresses owned by the wallet or client.
    - Docs: https://viem.sh/docs/actions/wallet/getAddresses.html
    - JSON-RPC Methods: eth_accounts
    Returns Promise<GetAddressesReturnType>
    List of account addresses owned by the wallet or client. GetAddressesReturnType
    Example
```
import { createWalletClient, custom } from 'viem'
import { mainnet } from 'viem/chains'

const client = createWalletClient({
  chain: mainnet,
  transport: custom(window.ethereum),
})
const accounts = await client.getAddresses()
```
getChainId: (() => Promise<GetChainIdReturnType>)
- - (): Promise<GetChainIdReturnType>
  - Returns the chain ID associated with the current network.
    - Docs: https://viem.sh/docs/actions/public/getChainId.html
    - JSON-RPC Methods: eth_chainId
    Returns Promise<GetChainIdReturnType>
    The current chain ID. GetChainIdReturnType
    Example
```
import { createWalletClient, http } from 'viem'
import { mainnet } from 'viem/chains'

const client = createWalletClient({
  chain: mainnet,
  transport: custom(window.ethereum),
})
const chainId = await client.getChainId()
// 1
```
getPermissions: (() => Promise<GetPermissionsReturnType>)
- - (): Promise<GetPermissionsReturnType>
  - Gets the wallets current permissions.
    - Docs: https://viem.sh/docs/actions/wallet/getPermissions.html
    - JSON-RPC Methods: wallet_getPermissions
    Returns Promise<GetPermissionsReturnType>
    The wallet permissions. GetPermissionsReturnType
    Example
```
import { createWalletClient, custom } from 'viem'
import { mainnet } from 'viem/chains'

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

prepareTransactionRequest: (<TChainOverride>(args) => Promise<PrepareTransactionRequestReturnType>)

<TChainOverride>(args): Promise<PrepareTransactionRequestReturnType>

Prepares a transaction request for signing.

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

Type Parameters

TChainOverride extends Chain | undefined = undefined

Parameters

args: PrepareTransactionRequestParameters<TChain, TAccount, TChainOverride>
PrepareTransactionRequestParameters

Returns Promise<PrepareTransactionRequestReturnType>

The transaction request. PrepareTransactionRequestReturnType

Example

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

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

Example

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

const client = createWalletClient({
  account: privateKeyToAccount('0x…'),
  chain: mainnet,
  transport: custom(window.ethereum),
})
const request = await client.prepareTransactionRequest({
  to: '0x0000000000000000000000000000000000000000',
  value: 1n,
})

requestAddresses: (() => Promise<RequestAddressesReturnType>)
- - (): Promise<RequestAddressesReturnType>
  - Requests a list of accounts managed by a wallet.
    - Docs: https://viem.sh/docs/actions/wallet/requestAddresses.html
    - JSON-RPC Methods: eth_requestAccounts
    Sends a request to the wallet, asking for permission to access the user's accounts. After the user accepts the request, it will return a list of accounts (addresses).
    
    This API can be useful for dapps that need to access the user's accounts in order to execute transactions or interact with smart contracts.
    Returns Promise<RequestAddressesReturnType>
    List of accounts managed by a wallet RequestAddressesReturnType
    Example
```
import { createWalletClient, custom } from 'viem'
import { mainnet } from 'viem/chains'

const client = createWalletClient({
  chain: mainnet,
  transport: custom(window.ethereum),
})
const accounts = await client.requestAddresses()
```
requestPermissions: ((args) => Promise<RequestPermissionsReturnType>)
- - (args): Promise<RequestPermissionsReturnType>
  - Requests permissions for a wallet.
    - Docs: https://viem.sh/docs/actions/wallet/requestPermissions.html
    - JSON-RPC Methods: wallet_requestPermissions
    Parameters
    - args: RequestPermissionsParameters
      RequestPermissionsParameters
    Returns Promise<RequestPermissionsReturnType>
    The wallet permissions. RequestPermissionsReturnType
    Example
```
import { createWalletClient, custom } from 'viem'
import { mainnet } from 'viem/chains'

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

sendRawTransaction: ((args) => Promise<SendRawTransactionReturnType>)

(args): Promise<SendRawTransactionReturnType>

Sends a signed transaction to the network

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

Parameters

args: SendRawTransactionParameters

Returns Promise<SendRawTransactionReturnType>

The transaction hash. SendRawTransactionReturnType

Example

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

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

const hash = await client.sendRawTransaction({
  serializedTransaction: '0x02f850018203118080825208808080c080a04012522854168b27e5dc3d5839bab5e6b39e1a0ffd343901ce1622e3d64b48f1a04e00902ae0502c4728cbf12156290df99c3ed7de85b1dbfe20b5c36931733a33'
})

sendTransaction: (<TChainOverride>(args) => Promise<SendTransactionReturnType>)

<TChainOverride>(args): Promise<SendTransactionReturnType>

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

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

Type Parameters

TChainOverride extends Chain | undefined = undefined

Parameters

args: SendTransactionParameters<TChain, TAccount, TChainOverride>
SendTransactionParameters

Returns Promise<SendTransactionReturnType>

The Transaction hash. SendTransactionReturnType

Example

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

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

Example

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

const client = createWalletClient({
  account: privateKeyToAccount('0x…'),
  chain: mainnet,
  transport: http(),
})
const hash = await client.sendTransaction({
  to: '0x70997970c51812dc3a010c7d01b50e0d17dc79c8',
  value: 1000000000000000000n,
})

signMessage: ((args) => Promise<SignMessageReturnType>)

(args): Promise<SignMessageReturnType>

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

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

With the calculated signature, you can:

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

Parameters

args: SignMessageParameters<TAccount>
SignMessageParameters

Returns Promise<SignMessageReturnType>

The signed message. SignMessageReturnType

Example

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

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

Example

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

const client = createWalletClient({
  account: privateKeyToAccount('0x…'),
  chain: mainnet,
  transport: http(),
})
const signature = await client.signMessage({
  message: 'hello world',
})

signTransaction: (<TChainOverride>(args) => Promise<SignTransactionReturnType>)

<TChainOverride>(args): Promise<SignTransactionReturnType>

Signs a transaction.

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

Type Parameters

TChainOverride extends Chain | undefined = undefined

Parameters

args: SignTransactionParameters<TChain, TAccount, TChainOverride>
SignTransactionParameters

Returns Promise<SignTransactionReturnType>

The signed message. SignTransactionReturnType

Example

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

const client = createWalletClient({
  chain: mainnet,
  transport: custom(window.ethereum),
})
const request = await client.prepareTransactionRequest({
  account: '0xA0Cf798816D4b9b9866b5330EEa46a18382f251e',
  to: '0x0000000000000000000000000000000000000000',
  value: 1n,
})
const signature = await client.signTransaction(request)

Example

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

const client = createWalletClient({
  account: privateKeyToAccount('0x…'),
  chain: mainnet,
  transport: custom(window.ethereum),
})
const request = await client.prepareTransactionRequest({
  to: '0x0000000000000000000000000000000000000000',
  value: 1n,
})
const signature = await client.signTransaction(request)

signTypedData: (<const TTypedData, TPrimaryType>(args) => Promise<SignTypedDataReturnType>)

<const TTypedData, TPrimaryType>(args): Promise<SignTypedDataReturnType>

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

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

Type Parameters

const TTypedData extends TypedData | {
[key: string]: unknown;
}
TPrimaryType extends string

Parameters

args: SignTypedDataParameters<TTypedData, TPrimaryType, TAccount>
SignTypedDataParameters

Returns Promise<SignTypedDataReturnType>

The signed data. SignTypedDataReturnType

Example

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

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

Example

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

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

switchChain: ((args) => Promise<void>)
- - (args): Promise<void>
  - Switch the target chain in a wallet.
    - Docs: https://viem.sh/docs/actions/wallet/switchChain.html
    - JSON-RPC Methods: eth_switchEthereumChain
    Parameters
    - args: SwitchChainParameters
      SwitchChainParameters
    Returns Promise<void>
    Example
```
import { createWalletClient, custom } from 'viem'
import { mainnet, optimism } from 'viem/chains'

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

watchAsset: ((args) => Promise<WatchAssetReturnType>)

(args): Promise<WatchAssetReturnType>

Adds an EVM chain to the wallet.

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

Parameters

args: WatchAssetParameters
WatchAssetParameters

Returns Promise<WatchAssetReturnType>

Boolean indicating if the token was successfully added. WatchAssetReturnType

Example

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

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

writeContract: (<const TAbi, TFunctionName, TChainOverride>(args) => Promise<WriteContractReturnType>)
- - <const TAbi, TFunctionName, TChainOverride>(args): Promise<WriteContractReturnType>
  - Executes a write function on a contract.
    - Docs: https://viem.sh/docs/contract/writeContract.html
    - Examples: https://stackblitz.com/github/wevm/viem/tree/main/examples/contracts/writing-to-contracts
    A "write" function on a Solidity contract modifies the state of the blockchain. These types of functions require gas to be executed, and hence a Transaction is needed to be broadcast in order to change the state.
    
    Internally, uses a Wallet Client to call the sendTransaction action with ABI-encoded data.
    
    Warning: The write internally sends a transaction – it does not validate if the contract write will succeed (the contract may throw an error). It is highly recommended to simulate the contract write with contract.simulate before you execute it.
    Type Parameters
    - const TAbi extends Abi | readonly unknown[]
    - TFunctionName extends string
    - TChainOverride extends Chain | undefined = undefined
    Parameters
    - args: WriteContractParameters<TAbi, TFunctionName, TChain, TAccount, TChainOverride>
      WriteContractParameters
    Returns Promise<WriteContractReturnType>
    A Transaction Hash. WriteContractReturnType
    Example
```
import { createWalletClient, custom, parseAbi } from 'viem'
import { mainnet } from 'viem/chains'

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

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

Type alias WalletActions<TChain, TAccount>

Type Parameters

TChain extends Chain | undefined = Chain | undefined

TAccount extends Account | undefined = Account | undefined

Type declaration

addChain: ((args) => Promise<void>)

Parameters

args: AddChainParameters

Returns Promise<void>

Example

deployContract: (<const TAbi, TChainOverride>(args) => Promise<DeployContractReturnType>)

Type Parameters

const TAbi extends Abi | readonly unknown[]

TChainOverride extends Chain | undefined = undefined

Parameters

args: DeployContractParameters<TAbi, TChain, TAccount, TChainOverride>

Returns Promise<DeployContractReturnType>

Example

getAddresses: (() => Promise<GetAddressesReturnType>)

Returns Promise<GetAddressesReturnType>

Example

getChainId: (() => Promise<GetChainIdReturnType>)

Returns Promise<GetChainIdReturnType>

Example

getPermissions: (() => Promise<GetPermissionsReturnType>)

Returns Promise<GetPermissionsReturnType>

Example

prepareTransactionRequest: (<TChainOverride>(args) => Promise<PrepareTransactionRequestReturnType>)

Type Parameters

TChainOverride extends Chain | undefined = undefined

Parameters

args: PrepareTransactionRequestParameters<TChain, TAccount, TChainOverride>

Returns Promise<PrepareTransactionRequestReturnType>

Example

Example

requestAddresses: (() => Promise<RequestAddressesReturnType>)

Returns Promise<RequestAddressesReturnType>

Example

requestPermissions: ((args) => Promise<RequestPermissionsReturnType>)

Parameters

args: RequestPermissionsParameters

Returns Promise<RequestPermissionsReturnType>

Example

sendRawTransaction: ((args) => Promise<SendRawTransactionReturnType>)

Parameters

args: SendRawTransactionParameters

Returns Promise<SendRawTransactionReturnType>

Example

sendTransaction: (<TChainOverride>(args) => Promise<SendTransactionReturnType>)

Type Parameters

TChainOverride extends Chain | undefined = undefined

Parameters

args: SendTransactionParameters<TChain, TAccount, TChainOverride>

Returns Promise<SendTransactionReturnType>

Example

Example

signMessage: ((args) => Promise<SignMessageReturnType>)

Parameters

args: SignMessageParameters<TAccount>

Returns Promise<SignMessageReturnType>

Example

Example

signTransaction: (<TChainOverride>(args) => Promise<SignTransactionReturnType>)

Type Parameters

TChainOverride extends Chain | undefined = undefined

Parameters

args: SignTransactionParameters<TChain, TAccount, TChainOverride>

Returns Promise<SignTransactionReturnType>

Example

Example

signTypedData: (<const TTypedData, TPrimaryType>(args) => Promise<SignTypedDataReturnType>)

Type Parameters

const TTypedData extends TypedData | { [key: string]: unknown; }

TPrimaryType extends string

Parameters

args: SignTypedDataParameters<TTypedData, TPrimaryType, TAccount>

Returns Promise<SignTypedDataReturnType>

Example

Example

switchChain: ((args) => Promise<void>)

const TTypedData extends TypedData | {
[key: string]: unknown;
}