Type Alias WalletActions<TChain, TAccount>

WalletActions<TChain, TAccount>: {
    addChain: ((args: AddChainParameters) => Promise<void>);
    deployContract: (<const abi, chainOverride>(args: DeployContractParameters<abi, TChain, TAccount, chainOverride>) => Promise<DeployContractReturnType>);
    getAddresses: (() => Promise<GetAddressesReturnType>);
    getChainId: (() => Promise<GetChainIdReturnType>);
    getPermissions: (() => Promise<GetPermissionsReturnType>);
    prepareTransactionRequest: (<const TRequest, TChainOverride, TAccountOverride>(args: PrepareTransactionRequestParameters<TChain, TAccount, TChainOverride, TAccountOverride, TRequest>) => Promise<PrepareTransactionRequestReturnType<Chain, TAccount, TChainOverride, TAccountOverride, TRequest>>);
    requestAddresses: (() => Promise<RequestAddressesReturnType>);
    requestPermissions: ((args: RequestPermissionsParameters) => Promise<RequestPermissionsReturnType>);
    sendRawTransaction: ((args: SendRawTransactionParameters) => Promise<SendRawTransactionReturnType>);
    sendTransaction: (<const TRequest, TChainOverride>(args: SendTransactionParameters<TChain, TAccount, TChainOverride, TRequest>) => Promise<SendTransactionReturnType>);
    signMessage: ((args: SignMessageParameters<TAccount>) => Promise<SignMessageReturnType>);
    signTransaction: (<TChainOverride>(args: SignTransactionParameters<TChain, TAccount, TChainOverride>) => Promise<SignTransactionReturnType>);
    signTypedData: (<const TTypedData, TPrimaryType>(args: SignTypedDataParameters<TTypedData, TPrimaryType, TAccount>) => Promise<SignTypedDataReturnType>);
    switchChain: ((args: SwitchChainParameters) => Promise<void>);
    watchAsset: ((args: WatchAssetParameters) => Promise<WatchAssetReturnType>);
    writeContract: (<const abi, functionName, args, TChainOverride>(args: WriteContractParameters<abi, functionName, args, TChain, TAccount, TChainOverride>) => Promise<WriteContractReturnType>);
}

Type Parameters

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

Type declaration

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

const client = createWalletClient({
  transport: custom(window.ethereum),
})
await client.addChain({ chain: optimism })
```
- - (args): Promise<void>
  - Parameters
    - args: AddChainParameters
      AddChainParameters
    Returns Promise<void>
deployContract: (<const abi, chainOverride>(args: DeployContractParameters<abi, TChain, TAccount, chainOverride>) => Promise<DeployContractReturnType>)
Deploys a contract to the network, given bytecode and constructor arguments.
- Docs: https://viem.sh/docs/contract/deployContract
- Examples: https://stackblitz.com/github/wevm/viem/tree/main/examples/contracts/deploying-contracts
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...',
})
```
- - <const abi, chainOverride>(args): Promise<DeployContractReturnType>
  - Type Parameters
    - const abi extends Abi | readonly unknown[]
    - chainOverride extends Chain | undefined
    Parameters
    - args: DeployContractParameters<abi, TChain, TAccount, chainOverride>
      DeployContractParameters
    Returns Promise<DeployContractReturnType>
    The Transaction hash. DeployContractReturnType
getAddresses: (() => Promise<GetAddressesReturnType>)
Returns a list of account addresses owned by the wallet or client.
- Docs: https://viem.sh/docs/actions/wallet/getAddresses
- JSON-RPC Methods: eth_accounts
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()
```
- - (): Promise<GetAddressesReturnType>
  - Returns Promise<GetAddressesReturnType>
    List of account addresses owned by the wallet or client. GetAddressesReturnType
getChainId: (() => Promise<GetChainIdReturnType>)
Returns the chain ID associated with the current network.
- Docs: https://viem.sh/docs/actions/public/getChainId
- JSON-RPC Methods: eth_chainId
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
```
- - (): Promise<GetChainIdReturnType>
  - Returns Promise<GetChainIdReturnType>
    The current chain ID. GetChainIdReturnType
getPermissions: (() => Promise<GetPermissionsReturnType>)
Gets the wallets current permissions.
- Docs: https://viem.sh/docs/actions/wallet/getPermissions
- JSON-RPC Methods: wallet_getPermissions
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()
```
- - (): Promise<GetPermissionsReturnType>
  - Returns Promise<GetPermissionsReturnType>
    The wallet permissions. GetPermissionsReturnType
prepareTransactionRequest: (<const TRequest, TChainOverride, TAccountOverride>(args: PrepareTransactionRequestParameters<TChain, TAccount, TChainOverride, TAccountOverride, TRequest>) => Promise<PrepareTransactionRequestReturnType<Chain, TAccount, TChainOverride, TAccountOverride, TRequest>>)
Prepares a transaction request for signing.
- Docs: https://viem.sh/docs/actions/wallet/prepareTransactionRequest
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,
})
```
- - <const TRequest, TChainOverride, TAccountOverride>(args): Promise<PrepareTransactionRequestReturnType<Chain, TAccount, TChainOverride, TAccountOverride, TRequest>>
  - Type Parameters
    - const TRequest extends PrepareTransactionRequestRequest<TChain, TChainOverride>
    - TChainOverride extends Chain | undefined = undefined
    - TAccountOverride extends Account | Address | undefined = undefined
    Parameters
    - args: PrepareTransactionRequestParameters<TChain, TAccount, TChainOverride, TAccountOverride, TRequest>
      PrepareTransactionRequestParameters
    Returns Promise<PrepareTransactionRequestReturnType<Chain, TAccount, TChainOverride, TAccountOverride, TRequest>>
    The transaction request. PrepareTransactionRequestReturnType
requestAddresses: (() => Promise<RequestAddressesReturnType>)
Requests a list of accounts managed by a wallet.
- Docs: https://viem.sh/docs/actions/wallet/requestAddresses
- JSON-RPC Methods: eth_requestAccounts
Sends a request to the wallet, asking for permission to access the user's accounts. After the user accepts the request, it will return a list of accounts (addresses).

This API can be useful for dapps that need to access the user's accounts in order to execute transactions or interact with smart contracts.
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()
```
- - (): Promise<RequestAddressesReturnType>
  - Returns Promise<RequestAddressesReturnType>
    List of accounts managed by a wallet RequestAddressesReturnType
requestPermissions: ((args: RequestPermissionsParameters) => Promise<RequestPermissionsReturnType>)
Requests permissions for a wallet.
- Docs: https://viem.sh/docs/actions/wallet/requestPermissions
- JSON-RPC Methods: wallet_requestPermissions
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: {}
})
```
- - (args): Promise<RequestPermissionsReturnType>
  - Parameters
    - args: RequestPermissionsParameters
      RequestPermissionsParameters
    Returns Promise<RequestPermissionsReturnType>
    The wallet permissions. RequestPermissionsReturnType

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

Sends a signed transaction to the network

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

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

- (args): Promise<SendRawTransactionReturnType>
- Parameters
  - args: SendRawTransactionParameters
  Returns Promise<SendRawTransactionReturnType>
  The transaction hash. SendRawTransactionReturnType

sendTransaction: (<const TRequest, TChainOverride>(args: SendTransactionParameters<TChain, TAccount, TChainOverride, TRequest>) => Promise<SendTransactionReturnType>)
Creates, signs, and sends a new transaction to the network.
- Docs: https://viem.sh/docs/actions/wallet/sendTransaction
- Examples: https://stackblitz.com/github/wevm/viem/tree/main/examples/transactions/sending-transactions
- JSON-RPC Methods:
  - JSON-RPC Accounts: eth_sendTransaction
  - Local Accounts: eth_sendRawTransaction
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,
})
```
- - <const TRequest, TChainOverride>(args): Promise<SendTransactionReturnType>
  - Type Parameters
    - const TRequest extends SendTransactionRequest<TChain, TChainOverride>
    - TChainOverride extends Chain | undefined = undefined
    Parameters
    - args: SendTransactionParameters<TChain, TAccount, TChainOverride, TRequest>
      SendTransactionParameters
    Returns Promise<SendTransactionReturnType>
    The Transaction hash. SendTransactionReturnType

signMessage: ((args: SignMessageParameters<TAccount>) => 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
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.

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

- (args): Promise<SignMessageReturnType>
- Parameters
  - args: SignMessageParameters<TAccount>
    SignMessageParameters
  Returns Promise<SignMessageReturnType>
  The signed message. SignMessageReturnType

signTransaction: (<TChainOverride>(args: SignTransactionParameters<TChain, TAccount, TChainOverride>) => Promise<SignTransactionReturnType>)

Signs a transaction.

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

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)

- <TChainOverride>(args): Promise<SignTransactionReturnType>
- Type Parameters
  - TChainOverride extends Chain | undefined
  Parameters
  - args: SignTransactionParameters<TChain, TAccount, TChainOverride>
    SignTransactionParameters
  Returns Promise<SignTransactionReturnType>
  The signed message. SignTransactionReturnType

signTypedData: (<const TTypedData, TPrimaryType>(args: SignTypedDataParameters<TTypedData, TPrimaryType, TAccount>) => 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
JSON-RPC Methods:
- JSON-RPC Accounts: eth_signTypedData_v4
- Local Accounts: Signs locally. No JSON-RPC request.

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

- <const TTypedData, TPrimaryType>(args): Promise<SignTypedDataReturnType>
- 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

switchChain: ((args: SwitchChainParameters) => Promise<void>)
Switch the target chain in a wallet.
- Docs: https://viem.sh/docs/actions/wallet/switchChain
- JSON-RPC Methods: eth_switchEthereumChain
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 })
```
- - (args): Promise<void>
  - Parameters
    - args: SwitchChainParameters
      SwitchChainParameters
    Returns Promise<void>
watchAsset: ((args: WatchAssetParameters) => Promise<WatchAssetReturnType>)
Adds an EVM chain to the wallet.
- Docs: https://viem.sh/docs/actions/wallet/watchAsset
- JSON-RPC Methods: eth_switchEthereumChain
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',
  },
})
```
- - (args): Promise<WatchAssetReturnType>
  - Parameters
    - args: WatchAssetParameters
      WatchAssetParameters
    Returns Promise<WatchAssetReturnType>
    Boolean indicating if the token was successfully added. WatchAssetReturnType
writeContract: (<const abi, functionName, args, TChainOverride>(args: WriteContractParameters<abi, functionName, args, TChain, TAccount, TChainOverride>) => Promise<WriteContractReturnType>)
Executes a write function on a contract.
- Docs: https://viem.sh/docs/contract/writeContract
- Examples: https://stackblitz.com/github/wevm/viem/tree/main/examples/contracts/writing-to-contracts
A "write" function on a Solidity contract modifies the state of the blockchain. These types of functions require gas to be executed, and hence a Transaction is needed to be broadcast in order to change the state.

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

Warning: The write internally sends a transaction – it does not validate if the contract write will succeed (the contract may throw an error). It is highly recommended to simulate the contract write with contract.simulate before you execute it.
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)
```
- - <const abi, functionName, args, TChainOverride>(args): Promise<WriteContractReturnType>
  - Type Parameters
    - const abi extends Abi | readonly unknown[]
    - functionName extends ContractFunctionName<abi, "payable" | "nonpayable">
    - args extends ContractFunctionArgs<abi, "payable" | "nonpayable", functionName>
    - TChainOverride extends Chain | undefined = undefined
    Parameters
    - args: WriteContractParameters<abi, functionName, args, TChain, TAccount, TChainOverride>
      WriteContractParameters
    Returns Promise<WriteContractReturnType>
    A Transaction Hash. WriteContractReturnType

Type Alias WalletActions<TChain, TAccount>

Type Parameters

Type declaration

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

Example

Parameters

Returns Promise<void>

deployContract: (<const abi, chainOverride>(args: DeployContractParameters<abi, TChain, TAccount, chainOverride>) => Promise<DeployContractReturnType>)

Example

Type Parameters

Parameters

Returns Promise<DeployContractReturnType>

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

Example

Returns Promise<GetAddressesReturnType>

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

Example

Returns Promise<GetChainIdReturnType>

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

Example

Returns Promise<GetPermissionsReturnType>

prepareTransactionRequest: (<const TRequest, TChainOverride, TAccountOverride>(args: PrepareTransactionRequestParameters<TChain, TAccount, TChainOverride, TAccountOverride, TRequest>) => Promise<PrepareTransactionRequestReturnType<Chain, TAccount, TChainOverride, TAccountOverride, TRequest>>)

Example

Example

Type Parameters

Parameters

Returns Promise<PrepareTransactionRequestReturnType<Chain, TAccount, TChainOverride, TAccountOverride, TRequest>>

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

Example

Returns Promise<RequestAddressesReturnType>

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

Example

Parameters

Returns Promise<RequestPermissionsReturnType>

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

Example

Parameters

Returns Promise<SendRawTransactionReturnType>

sendTransaction: (<const TRequest, TChainOverride>(args: SendTransactionParameters<TChain, TAccount, TChainOverride, TRequest>) => Promise<SendTransactionReturnType>)

Example

Example

Type Parameters

Parameters

Returns Promise<SendTransactionReturnType>

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

Example

Example

Parameters

Returns Promise<SignMessageReturnType>

signTransaction: (<TChainOverride>(args: SignTransactionParameters<TChain, TAccount, TChainOverride>) => Promise<SignTransactionReturnType>)

Example

Example

Type Parameters

Parameters

Returns Promise<SignTransactionReturnType>

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

Example

Example

Type Parameters

Parameters

Returns Promise<SignTypedDataReturnType>

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

Example

Parameters

Returns Promise<void>

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

Example

Parameters

Returns Promise<WatchAssetReturnType>

writeContract: (<const abi, functionName, args, TChainOverride>(args: WriteContractParameters<abi, functionName, args, TChain, TAccount, TChainOverride>) => Promise<WriteContractReturnType>)

Example

Example

Type Parameters

Parameters

Returns Promise<WriteContractReturnType>

Settings