Interface ViemClients

interface ViemClients {
    publicClient: PublicClient;
    walletClient?: {
        account: Account;
        addChain: ((args) => Promise<void>);
        batch?: {
            multicall?: boolean | {
                batchSize?: number;
                wait?: number;
            };
        };
        cacheTime: number;
        chain: Chain;
        deployContract: (<const TAbi, TChainOverride>(args) => Promise<`0x${string}`>);
        extend: (<const client>(fn) => Client<Transport, Chain, Account, WalletRpcSchema, {
            [K in string | number | symbol]: client[K]
        } & WalletActions<Chain, Account>>);
        getAddresses: (() => Promise<GetAddressesReturnType>);
        getChainId: (() => Promise<number>);
        getPermissions: (() => Promise<GetPermissionsReturnType>);
        key: string;
        name: string;
        pollingInterval: number;
        prepareTransactionRequest: (<TChainOverride>(args) => Promise<PrepareTransactionRequestReturnType>);
        request: EIP1193RequestFn<WalletRpcSchema>;
        requestAddresses: (() => Promise<RequestAddressesReturnType>);
        requestPermissions: ((args) => Promise<RequestPermissionsReturnType>);
        sendRawTransaction: ((args) => Promise<`0x${string}`>);
        sendTransaction: (<TChainOverride>(args) => Promise<`0x${string}`>);
        signMessage: ((args) => Promise<`0x${string}`>);
        signTransaction: (<TChainOverride>(args) => Promise<`0x${string}`>);
        signTypedData: (<const TTypedData, TPrimaryType>(args) => Promise<`0x${string}`>);
        switchChain: ((args) => Promise<void>);
        transport: TransportConfig<string, EIP1193RequestFn> & Record<string, any>;
        type: string;
        uid: string;
        watchAsset: ((args) => Promise<boolean>);
        writeContract: (<const TAbi, TFunctionName, TChainOverride>(args) => Promise<`0x${string}`>);
    };
}

Properties

publicClient walletClient?

Properties

publicClient

publicClient: PublicClient

Optional walletClient

walletClient?: {
    account: Account;
    addChain: ((args) => Promise<void>);
    batch?: {
        multicall?: boolean | {
            batchSize?: number;
            wait?: number;
        };
    };
    cacheTime: number;
    chain: Chain;
    deployContract: (<const TAbi, TChainOverride>(args) => Promise<`0x${string}`>);
    extend: (<const client>(fn) => Client<Transport, Chain, Account, WalletRpcSchema, {
        [K in string | number | symbol]: client[K]
    } & WalletActions<Chain, Account>>);
    getAddresses: (() => Promise<GetAddressesReturnType>);
    getChainId: (() => Promise<number>);
    getPermissions: (() => Promise<GetPermissionsReturnType>);
    key: string;
    name: string;
    pollingInterval: number;
    prepareTransactionRequest: (<TChainOverride>(args) => Promise<PrepareTransactionRequestReturnType>);
    request: EIP1193RequestFn<WalletRpcSchema>;
    requestAddresses: (() => Promise<RequestAddressesReturnType>);
    requestPermissions: ((args) => Promise<RequestPermissionsReturnType>);
    sendRawTransaction: ((args) => Promise<`0x${string}`>);
    sendTransaction: (<TChainOverride>(args) => Promise<`0x${string}`>);
    signMessage: ((args) => Promise<`0x${string}`>);
    signTransaction: (<TChainOverride>(args) => Promise<`0x${string}`>);
    signTypedData: (<const TTypedData, TPrimaryType>(args) => Promise<`0x${string}`>);
    switchChain: ((args) => Promise<void>);
    transport: TransportConfig<string, EIP1193RequestFn> & Record<string, any>;
    type: string;
    uid: string;
    watchAsset: ((args) => Promise<boolean>);
    writeContract: (<const TAbi, TFunctionName, TChainOverride>(args) => Promise<`0x${string}`>);
}

Type declaration

  • account: Account

    The Account of the Client.

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

    Adds an EVM chain to the wallet.

    Param: args

    AddChainParameters

    Example

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

    const client = createWalletClient({
      transport: custom(window.ethereum),
    })
    await client.addChain({ chain: optimism })
  • Optional batch?: {
        multicall?: boolean | {
            batchSize?: number;
            wait?: number;
        };
    }

    Flags for batch settings.

    • Optional multicall?: boolean | {
          batchSize?: number;
          wait?: number;
      }

      Toggle to enable eth_call multicall aggregation.

  • cacheTime: number

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

  • chain: Chain

    Chain for the client.

  • deployContract: (<const TAbi, TChainOverride>(args) => Promise<`0x${string}`>)

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

    Param: args

    DeployContractParameters

    Returns

    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...',
    })
  • extend: (<const client>(fn) => Client<Transport, Chain, Account, WalletRpcSchema, {
        [K in string | number | symbol]: client[K]
    } & WalletActions<Chain, Account>>)
  • getAddresses: (() => Promise<GetAddressesReturnType>)

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

    Returns

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

    Returns the chain ID associated with the current network.

    Returns

    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
      • (): Promise<number>

      • Returns the chain ID associated with the current network.

        Returns Promise<number>

        The current chain ID. GetChainIdReturnType

        Example

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

        const client = createWalletClient({
          chain: mainnet,
          transport: custom(window.ethereum),
        })
        const chainId = await client.getChainId()
        // 1
  • getPermissions: (() => Promise<GetPermissionsReturnType>)

    Gets the wallets current permissions.

    Returns

    The wallet permissions. GetPermissionsReturnType

    Example

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

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

    A key for the client.

  • name: string

    A name for the client.

  • pollingInterval: number

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

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

    Prepares a transaction request for signing.

    Param: args

    PrepareTransactionRequestParameters

    Returns

    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,
    })
  • request: EIP1193RequestFn<WalletRpcSchema>

    Request function wrapped with friendly error handling

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

    Requests a list of accounts managed by a wallet.

    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

    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()
      • (): Promise<RequestAddressesReturnType>

      • Requests a list of accounts managed by a wallet.

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

    Requests permissions for a wallet.

    Param: args

    RequestPermissionsParameters

    Returns

    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<`0x${string}`>)

    Sends a signed transaction to the network

    Param: client

    Client to use

    Param: parameters

    SendRawTransactionParameters

    Returns

    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'
    })
      • (args): Promise<`0x${string}`>

      • Sends a signed transaction to the network

        Parameters

        Returns Promise<`0x${string}`>

        The transaction hash. SendRawTransactionReturnType

        Example

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

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

        const hash = await client.sendRawTransaction({
          serializedTransaction: '0x02f850018203118080825208808080c080a04012522854168b27e5dc3d5839bab5e6b39e1a0ffd343901ce1622e3d64b48f1a04e00902ae0502c4728cbf12156290df99c3ed7de85b1dbfe20b5c36931733a33'
        })
  • sendTransaction: (<TChainOverride>(args) => Promise<`0x${string}`>)

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

    Param: args

    SendTransactionParameters

    Returns

    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<`0x${string}`>)

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

    With the calculated signature, you can:

    Param: args

    SignMessageParameters

    Returns

    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',
    })
      • (args): Promise<`0x${string}`>

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

        With the calculated signature, you can:

        Parameters

        Returns Promise<`0x${string}`>

        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<`0x${string}`>)

    Signs a transaction.

    Param: args

    SignTransactionParameters

    Returns

    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)
      • <TChainOverride>(args): Promise<`0x${string}`>

      • Signs a transaction.

        Type Parameters

        • TChainOverride extends undefined | Chain = undefined

        Parameters

        Returns Promise<`0x${string}`>

        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<`0x${string}`>)

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

    Param: client

    Client to use

    Param: args

    SignTypedDataParameters

    Returns

    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!',
      },
    })
      • <const TTypedData, TPrimaryType>(args): Promise<`0x${string}`>

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

        Type Parameters

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

        • TPrimaryType extends string

        Parameters

        Returns Promise<`0x${string}`>

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

    Switch the target chain in a wallet.

    Param: args

    SwitchChainParameters

    Example

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

    const client = createWalletClient({
      chain: mainnet,
      transport: custom(window.ethereum),
    })
    await client.switchChain({ id: optimism.id })
  • transport: TransportConfig<string, EIP1193RequestFn> & Record<string, any>

    The RPC transport

  • type: string

    The type of client.

  • uid: string

    A unique ID for the client.

  • watchAsset: ((args) => Promise<boolean>)

    Adds an EVM chain to the wallet.

    Param: args

    WatchAssetParameters

    Returns

    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',
      },
    })
      • (args): Promise<boolean>

      • Adds an EVM chain to the wallet.

        Parameters

        Returns Promise<boolean>

        Boolean indicating if the token was successfully added. WatchAssetReturnType

        Example

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

        const client = createWalletClient({
          chain: mainnet,
          transport: custom(window.ethereum),
        })
        const success = await client.watchAsset({
          type: 'ERC20',
          options: {
            address: '0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2',
            decimals: 18,
            symbol: 'WETH',
          },
        })
  • writeContract: (<const TAbi, TFunctionName, TChainOverride>(args) => Promise<`0x${string}`>)

    Executes a write function on a contract.

    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.

    Param: args

    WriteContractParameters

    Returns

    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)

Settings

Member Visibility

Theme

On This Page

Generated using TypeDoc