Function approveERC20

approveERC20(__namedParameters): Promise<undefined | `0x${string}`>
Parameters
- __namedParameters: {
      chainId: CHAIN_IDS;
      walletClient: {
          account: undefined | Account;
          batch?: {
              multicall?: boolean | {
                  batchSize?: number;
                  wait?: number;
              };
          };
          cacheTime: number;
          ccipRead?: false | {
              request?: ((parameters) => Promise<`0x${string}`>);
          };
          chain: undefined | Chain;
          key: string;
          name: string;
          pollingInterval: number;
          request: EIP1193RequestFn<WalletRpcSchema>;
          transport: TransportConfig<string, EIP1193RequestFn> & Record<string, any>;
          type: string;
          uid: string;
          addChain: ((args) => Promise<void>);
          deployContract: (<const abi, chainOverride>(args) => Promise<`0x${string}`>);
          getAddresses: (() => Promise<GetAddressesReturnType>);
          getChainId: (() => Promise<number>);
          getPermissions: (() => Promise<GetPermissionsReturnType>);
          prepareTransactionRequest: (<const TRequest, TChainOverride, TAccountOverride>(args) => Promise<{
              [K in string | number | symbol]: (UnionRequiredBy<Extract<(...) & (...) & (...), (...) extends (...)
                  ? (...)
                  : (...)> & {
                  chainId?: (...) | (...);
              }, ParameterTypeToParameters<(...)[(...)] extends readonly (...)[]
                  ? (...)[(...)]
                  : (...) | (...) | (...) | (...) | (...) | (...)>> & (unknown extends TRequest["kzg"]
                  ? {}
                  : Pick<TRequest, "kzg">))[K]
          }>);
          requestAddresses: (() => Promise<RequestAddressesReturnType>);
          requestPermissions: ((args) => Promise<RequestPermissionsReturnType>);
          sendRawTransaction: ((args) => Promise<`0x${string}`>);
          sendTransaction: (<const TRequest, TChainOverride>(args) => Promise<`0x${string}`>);
          signMessage: ((args) => Promise<`0x${string}`>);
          signTransaction: (<TChainOverride>(args) => Promise<`0x02${string}` | `0x01${string}` | `0x03${string}` | TransactionSerializedLegacy>);
          signTypedData: (<const TTypedData, TPrimaryType>(args) => Promise<`0x${string}`>);
          switchChain: ((args) => Promise<void>);
          watchAsset: ((args) => Promise<boolean>);
          writeContract: (<const abi, functionName, args, TChainOverride>(args) => Promise<`0x${string}`>);
          extend: (<const client>(fn) => Client<Transport, undefined | Chain, undefined | Account, WalletRpcSchema, {
              [K in string | number | symbol]: client[K]
          } & WalletActions<undefined | Chain, undefined | Account>>);
      };
      token: `0x${string}`;
      amount?: string;
      options?: DefaultWriteContractOptions;
  }
  - chainId: CHAIN_IDS
  - walletClient: {
        account: undefined | Account;
        batch?: {
            multicall?: boolean | {
                batchSize?: number;
                wait?: number;
            };
        };
        cacheTime: number;
        ccipRead?: false | {
            request?: ((parameters) => Promise<`0x${string}`>);
        };
        chain: undefined | Chain;
        key: string;
        name: string;
        pollingInterval: number;
        request: EIP1193RequestFn<WalletRpcSchema>;
        transport: TransportConfig<string, EIP1193RequestFn> & Record<string, any>;
        type: string;
        uid: string;
        addChain: ((args) => Promise<void>);
        deployContract: (<const abi, chainOverride>(args) => Promise<`0x${string}`>);
        getAddresses: (() => Promise<GetAddressesReturnType>);
        getChainId: (() => Promise<number>);
        getPermissions: (() => Promise<GetPermissionsReturnType>);
        prepareTransactionRequest: (<const TRequest, TChainOverride, TAccountOverride>(args) => Promise<{
            [K in string | number | symbol]: (UnionRequiredBy<Extract<(...) & (...) & (...), (...) extends (...)
                ? (...)
                : (...)> & {
                chainId?: (...) | (...);
            }, ParameterTypeToParameters<(...)[(...)] extends readonly (...)[]
                ? (...)[(...)]
                : (...) | (...) | (...) | (...) | (...) | (...)>> & (unknown extends TRequest["kzg"]
                ? {}
                : Pick<TRequest, "kzg">))[K]
        }>);
        requestAddresses: (() => Promise<RequestAddressesReturnType>);
        requestPermissions: ((args) => Promise<RequestPermissionsReturnType>);
        sendRawTransaction: ((args) => Promise<`0x${string}`>);
        sendTransaction: (<const TRequest, TChainOverride>(args) => Promise<`0x${string}`>);
        signMessage: ((args) => Promise<`0x${string}`>);
        signTransaction: (<TChainOverride>(args) => Promise<`0x02${string}` | `0x01${string}` | `0x03${string}` | TransactionSerializedLegacy>);
        signTypedData: (<const TTypedData, TPrimaryType>(args) => Promise<`0x${string}`>);
        switchChain: ((args) => Promise<void>);
        watchAsset: ((args) => Promise<boolean>);
        writeContract: (<const abi, functionName, args, TChainOverride>(args) => Promise<`0x${string}`>);
        extend: (<const client>(fn) => Client<Transport, undefined | Chain, undefined | Account, WalletRpcSchema, {
            [K in string | number | symbol]: client[K]
        } & WalletActions<undefined | Chain, undefined | Account>>);
    }
    - account: undefined | Account
      The Account of the Client.
    - 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.
    - Optional ccipRead?: false | {
      request?: ((parameters) => Promise<`0x${string}`>);
      }
      CCIP Read configuration.
    - chain: undefined | Chain
      Chain for the client.
    - 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.
    - request: EIP1193RequestFn<WalletRpcSchema>
      Request function wrapped with friendly error handling
    - transport: TransportConfig<string, EIP1193RequestFn> & Record<string, any>
      The RPC transport
    - type: string
      The type of client.
    - uid: string
      A unique ID for the client.
    - addChain: ((args) => 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) => Promise<`0x${string}`>)
      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
      
      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...', })
      
      <const abi, chainOverride>(args): Promise<`0x${string}`>
      Type Parameters
      const abi extends Abi | readonly unknown[]
      chainOverride extends undefined | Chain
      Parameters
      args: DeployContractParameters<abi, undefined | Chain, undefined | Account, chainOverride>
      DeployContractParameters
      
      Returns Promise<`0x${string}`>
    - 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
      
      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()
      
      (): Promise<GetAddressesReturnType>
      Returns Promise<GetAddressesReturnType>
    - getChainId: (() => Promise<number>)
      Returns the chain ID associated with the current network.
      
      Docs: https://viem.sh/docs/actions/public/getChainId
      
      JSON-RPC Methods: eth_chainId
      
      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 Promise<number>
    - getPermissions: (() => Promise<GetPermissionsReturnType>)
      Gets the wallets current permissions.
      
      Docs: https://viem.sh/docs/actions/wallet/getPermissions
      
      JSON-RPC Methods: wallet_getPermissions
      
      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()
      
      (): Promise<GetPermissionsReturnType>
      Returns Promise<GetPermissionsReturnType>
    - prepareTransactionRequest: (<const TRequest, TChainOverride, TAccountOverride>(args) => Promise<{
          [K in string | number | symbol]: (UnionRequiredBy<Extract<(...) & (...) & (...), (...) extends (...)
              ? (...)
              : (...)> & {
              chainId?: (...) | (...);
          }, ParameterTypeToParameters<(...)[(...)] extends readonly (...)[]
              ? (...)[(...)]
              : (...) | (...) | (...) | (...) | (...) | (...)>> & (unknown extends TRequest["kzg"]
              ? {}
              : Pick<TRequest, "kzg">))[K]
      }>)
      Prepares a transaction request for signing.
      
      Docs: https://viem.sh/docs/actions/wallet/prepareTransactionRequest
      
      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, })
      
      <const TRequest, TChainOverride, TAccountOverride>(args): Promise<{
          [K in string | number | symbol]: (UnionRequiredBy<Extract<(...) & (...) & (...), (...) extends (...)
              ? (...)
              : (...)> & {
              chainId?: (...) | (...);
          }, ParameterTypeToParameters<(...)[(...)] extends readonly (...)[]
              ? (...)[(...)]
              : (...) | (...) | (...) | (...) | (...) | (...)>> & (unknown extends TRequest["kzg"]
              ? {}
              : Pick<TRequest, "kzg">))[K]
      }>
      Type Parameters
      const TRequest extends (Omit<{
          data?: `0x${string}`;
          from: `0x${string}`;
          gas?: bigint;
          nonce?: number;
          to?: null | `0x${string}`;
          value?: bigint;
          gasPrice?: bigint;
          maxFeePerBlobGas?: undefined;
          maxFeePerGas?: undefined;
          maxPriorityFeePerGas?: undefined;
          accessList?: undefined;
          blobs?: undefined;
          type?: "legacy";
          blobVersionedHashes: undefined;
          kzg: undefined;
          sidecars: undefined;
      }, "from"> | Omit<{
          data?: `0x${string}`;
          from: `0x${string}`;
          gas?: bigint;
          nonce?: number;
          to?: null | `0x${string}`;
          value?: bigint;
          gasPrice?: bigint;
          maxFeePerBlobGas?: undefined;
          maxFeePerGas?: undefined;
          maxPriorityFeePerGas?: undefined;
          accessList?: AccessList;
          blobs?: undefined;
          type?: "eip2930";
          blobVersionedHashes: undefined;
          kzg: undefined;
          sidecars: undefined;
      }, "from"> | Omit<{
          data?: `0x${string}`;
          from: `0x${string}`;
          gas?: bigint;
          nonce?: number;
          to?: null | `0x${string}`;
          value?: bigint;
          gasPrice?: undefined;
          maxFeePerBlobGas?: undefined;
          maxFeePerGas?: bigint;
          maxPriorityFeePerGas?: bigint;
          accessList?: AccessList;
          blobs?: undefined;
          type?: "eip1559";
          blobVersionedHashes: undefined;
          kzg: undefined;
          sidecars: undefined;
      }, "from"> | Omit<{
          from: `0x${string}`;
          data?: `0x${string}`;
          gas?: bigint;
          nonce?: number;
          value?: bigint;
          to: null | `0x${string}`;
          gasPrice?: undefined;
          maxFeePerGas?: bigint;
          maxPriorityFeePerGas?: bigint;
          maxFeePerBlobGas: bigint;
          accessList?: AccessList;
          blobs: readonly `0x${string}`[] | readonly Uint8Array[];
          blobVersionedHashes?: readonly `0x${string}`[];
          kzg?: Kzg;
          sidecars?: readonly BlobSidecar<`0x${(...)}`>[];
          type?: "eip4844";
      }, "from">) & {
          kzg?: Kzg;
      } & {
          parameters?: readonly PrepareTransactionRequestParameterType[];
      }
      TChainOverride extends undefined | Chain = undefined
      TAccountOverride extends undefined | `0x${string}` | Account = undefined
      Parameters
      args: PrepareTransactionRequestParameters<undefined | Chain, undefined | Account, TChainOverride, TAccountOverride, TRequest>
      PrepareTransactionRequestParameters
      
      Returns Promise<{
          [K in string | number | symbol]: (UnionRequiredBy<Extract<(...) & (...) & (...), (...) extends (...)
              ? (...)
              : (...)> & {
              chainId?: (...) | (...);
          }, ParameterTypeToParameters<(...)[(...)] extends readonly (...)[]
              ? (...)[(...)]
              : (...) | (...) | (...) | (...) | (...) | (...)>> & (unknown extends TRequest["kzg"]
              ? {}
              : Pick<TRequest, "kzg">))[K]
      }>
    - 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.
      
      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>
      Returns Promise<RequestAddressesReturnType>
    - requestPermissions: ((args) => Promise<RequestPermissionsReturnType>)
      Requests permissions for a wallet.
      
      Docs: https://viem.sh/docs/actions/wallet/requestPermissions
      
      JSON-RPC Methods: wallet_requestPermissions
      
      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: {} })
      
      (args): Promise<RequestPermissionsReturnType>
      Parameters
      args: {
      eth_accounts: Record<string, any>;
      }
      RequestPermissionsParameters
      
      eth_accounts: Record<string, any>
      Returns Promise<RequestPermissionsReturnType>
    - sendRawTransaction: ((args) => Promise<`0x${string}`>)
      Sends a signed transaction to the network
      
      Docs: https://viem.sh/docs/actions/wallet/sendRawTransaction
      
      JSON-RPC Method: eth_sendRawTransaction
      
      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}`>
      Parameters
      args: SendRawTransactionParameters
      Returns Promise<`0x${string}`>
    - sendTransaction: (<const TRequest, TChainOverride>(args) => Promise<`0x${string}`>)
      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
      
      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, })
      
      <const TRequest, TChainOverride>(args): Promise<`0x${string}`>
      Type Parameters
      const TRequest extends (Omit<{
          data?: `0x${string}`;
          from: `0x${string}`;
          gas?: bigint;
          nonce?: number;
          to?: null | `0x${string}`;
          value?: bigint;
          gasPrice?: bigint;
          maxFeePerBlobGas?: undefined;
          maxFeePerGas?: undefined;
          maxPriorityFeePerGas?: undefined;
          accessList?: undefined;
          blobs?: undefined;
          type?: "legacy";
          blobVersionedHashes: undefined;
          kzg: undefined;
          sidecars: undefined;
      }, "from"> | Omit<{
          data?: `0x${string}`;
          from: `0x${string}`;
          gas?: bigint;
          nonce?: number;
          to?: null | `0x${string}`;
          value?: bigint;
          gasPrice?: bigint;
          maxFeePerBlobGas?: undefined;
          maxFeePerGas?: undefined;
          maxPriorityFeePerGas?: undefined;
          accessList?: AccessList;
          blobs?: undefined;
          type?: "eip2930";
          blobVersionedHashes: undefined;
          kzg: undefined;
          sidecars: undefined;
      }, "from"> | Omit<{
          data?: `0x${string}`;
          from: `0x${string}`;
          gas?: bigint;
          nonce?: number;
          to?: null | `0x${string}`;
          value?: bigint;
          gasPrice?: undefined;
          maxFeePerBlobGas?: undefined;
          maxFeePerGas?: bigint;
          maxPriorityFeePerGas?: bigint;
          accessList?: AccessList;
          blobs?: undefined;
          type?: "eip1559";
          blobVersionedHashes: undefined;
          kzg: undefined;
          sidecars: undefined;
      }, "from"> | Omit<{
          from: `0x${string}`;
          data?: `0x${string}`;
          gas?: bigint;
          nonce?: number;
          value?: bigint;
          to: null | `0x${string}`;
          gasPrice?: undefined;
          maxFeePerGas?: bigint;
          maxPriorityFeePerGas?: bigint;
          maxFeePerBlobGas: bigint;
          accessList?: AccessList;
          blobs: readonly `0x${string}`[] | readonly Uint8Array[];
          blobVersionedHashes?: readonly `0x${string}`[];
          kzg?: Kzg;
          sidecars?: readonly BlobSidecar<`0x${(...)}`>[];
          type?: "eip4844";
      }, "from">) & {
          kzg?: Kzg;
      }
      TChainOverride extends undefined | Chain = undefined
      Parameters
      args: SendTransactionParameters<undefined | Chain, undefined | Account, TChainOverride, TRequest>
      SendTransactionParameters
      
      Returns Promise<`0x${string}`>
    - signMessage: ((args) => Promise<`0x${string}`>)
      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.
      
      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}`>
      Parameters
      args: SignMessageParameters<undefined | Account>
      SignMessageParameters
      
      Returns Promise<`0x${string}`>
    - signTransaction: (<TChainOverride>(args) => Promise<`0x02${string}` | `0x01${string}` | `0x03${string}` | TransactionSerializedLegacy>)
      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.
      
      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<`0x02${string}` | `0x01${string}` | `0x03${string}` | TransactionSerializedLegacy>
      Type Parameters
      TChainOverride extends undefined | Chain
      Parameters
      args: SignTransactionParameters<undefined | Chain, undefined | Account, TChainOverride>
      SignTransactionParameters
      
      Returns Promise<`0x02${string}` | `0x01${string}` | `0x03${string}` | TransactionSerializedLegacy>
    - 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)).
      
      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.
      
      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}`>
      Type Parameters
      const TTypedData extends {
          string: undefined;
          address: undefined;
          bool: undefined;
          bytes: undefined;
          bytes18: undefined;
          bytes1: undefined;
          bytes2: undefined;
          bytes32: undefined;
          bytes31: undefined;
          bytes30: undefined;
          bytes29: undefined;
          bytes28: undefined;
          bytes27: undefined;
          bytes26: undefined;
          bytes25: undefined;
          bytes24: undefined;
          bytes23: undefined;
          bytes22: undefined;
          bytes21: undefined;
          bytes20: undefined;
          bytes19: undefined;
          bytes17: undefined;
          bytes16: undefined;
          bytes15: undefined;
          bytes14: undefined;
          bytes13: undefined;
          bytes12: undefined;
          bytes11: undefined;
          bytes10: undefined;
          bytes9: undefined;
          bytes8: undefined;
          bytes7: undefined;
          bytes6: undefined;
          bytes5: undefined;
          bytes4: undefined;
          bytes3: undefined;
          int40: undefined;
          int32: undefined;
          int24: undefined;
          int16: undefined;
          int8: undefined;
          int48: undefined;
          int56: undefined;
          int64: undefined;
          int72: undefined;
          int80: undefined;
          int88: undefined;
          int96: undefined;
          int104: undefined;
          int112: undefined;
          int120: undefined;
          int128: undefined;
          int136: undefined;
          int144: undefined;
          int152: undefined;
          int160: undefined;
          int168: undefined;
          int176: undefined;
          int184: undefined;
          int192: undefined;
          int200: undefined;
          int208: undefined;
          int216: undefined;
          int224: undefined;
          int232: undefined;
          int240: undefined;
          int248: undefined;
          int256: undefined;
          uint40: undefined;
          uint32: undefined;
          uint24: undefined;
          uint16: undefined;
          uint8: undefined;
          uint48: undefined;
          uint56: undefined;
          uint64: undefined;
          uint72: undefined;
          uint80: undefined;
          uint88: undefined;
          uint96: undefined;
          uint104: undefined;
          uint112: undefined;
          uint120: undefined;
          uint128: undefined;
          uint136: undefined;
          uint144: undefined;
          uint152: undefined;
          uint160: undefined;
          uint168: undefined;
          uint176: undefined;
          uint184: undefined;
          uint192: undefined;
          uint200: undefined;
          uint208: undefined;
          uint216: undefined;
          uint224: undefined;
          uint232: undefined;
          uint240: undefined;
          uint248: undefined;
          uint256: undefined;
      } | {
          [key: string]: unknown;
      }
      TPrimaryType extends string
      Parameters
      args: SignTypedDataParameters<TTypedData, TPrimaryType, undefined | Account>
      SignTypedDataParameters
      
      Returns Promise<`0x${string}`>
    - switchChain: ((args) => 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) => Promise<boolean>)
      Adds an EVM chain to the wallet.
      
      Docs: https://viem.sh/docs/actions/wallet/watchAsset
      
      JSON-RPC Methods: eth_switchEthereumChain
      
      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>
      Parameters
      args: WatchAssetParams
      WatchAssetParameters
      
      Returns Promise<boolean>
    - writeContract: (<const abi, functionName, args, TChainOverride>(args) => Promise<`0x${string}`>)
      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.
      
      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)
      
      <const abi, functionName, args, TChainOverride>(args): Promise<`0x${string}`>
      Type Parameters
      const abi extends Abi | readonly unknown[]
      functionName extends string
      args extends unknown
      TChainOverride extends undefined | Chain = undefined
      Parameters
      args: WriteContractParameters<abi, functionName, args, undefined | Chain, undefined | Account, TChainOverride>
      WriteContractParameters
      
      Returns Promise<`0x${string}`>
    - extend: (<const client>(fn) => Client<Transport, undefined | Chain, undefined | Account, WalletRpcSchema, {
          [K in string | number | symbol]: client[K]
      } & WalletActions<undefined | Chain, undefined | Account>>)
      <const client>(fn): Client<Transport, undefined | Chain, undefined | Account, WalletRpcSchema, {
          [K in string | number | symbol]: client[K]
      } & WalletActions<undefined | Chain, undefined | Account>>
      Type Parameters
      const client extends {
          account?: undefined;
          batch?: undefined;
          cacheTime?: undefined;
          ccipRead?: undefined;
          chain?: undefined;
          key?: undefined;
          name?: undefined;
          pollingInterval?: undefined;
          request?: undefined;
          transport?: undefined;
          type?: undefined;
          uid?: undefined;
      } & ExactPartial<ExtendableProtectedActions<Transport, undefined | Chain, undefined | Account>>
      Parameters
      fn: ((client) => client)
      (client): client
      Parameters
      client: Client<Transport, undefined | Chain, undefined | Account, WalletRpcSchema, WalletActions<undefined | Chain, undefined | Account>>
      Returns client
      Returns Client<Transport, undefined | Chain, undefined | Account, WalletRpcSchema, {
          [K in string | number | symbol]: client[K]
      } & WalletActions<undefined | Chain, undefined | Account>>
  - token: `0x${string}`
  - Optional amount?: string
  - Optional options?: DefaultWriteContractOptions
Returns Promise<undefined | `0x${string}`>
Promise resolving to the transaction hash. If the account is already approved, the promise resolves to undefined.
Dev
This function relates with viem dependency Approves the specified amount of tokens for the given account on the specified chain.

Example
```
import { approveERC20 } from '@clober/v2-sdk'

const walletClient = createWalletClient({
  chain: arbitrumSepolia,
  account: mnemonicToAccount('legal ...'),
  transport: http(),
})

const hash = await approveERC20({
  chainId: 421614,
  walletClient
  token: '0x00bfd44e79fb7f6dd5887a9426c8ef85a0cd23e0',
  amount: '1000.123', // approve 1000.123 USDC
})
```
- Defined in src/approval.ts:114

Function approveERC20

Parameters

chainId: CHAIN_IDS

account: undefined | Account

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

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

cacheTime: number

Optional ccipRead?: false | { request?: ((parameters) => Promise<`0x${string}`>); }

chain: undefined | Chain

key: string

name: string

pollingInterval: number

request: EIP1193RequestFn<WalletRpcSchema>

transport: TransportConfig<string, EIP1193RequestFn> & Record<string, any>

type: string

uid: string

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

Example

Parameters

Returns Promise<void>

deployContract: (<const abi, chainOverride>(args) => Promise<`0x${string}`>)

Returns

Example

Type Parameters

Parameters

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

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

Returns

Example

Returns Promise<GetAddressesReturnType>

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

Returns

Example

Returns Promise<number>

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

Returns

Example

Returns Promise<GetPermissionsReturnType>

Returns

Example

Example

Type Parameters

Parameters

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

Returns

Example

Returns Promise<RequestAddressesReturnType>

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

Returns

Example

Parameters

eth_accounts: Record<string, any>

Returns Promise<RequestPermissionsReturnType>

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

Returns

Example

Parameters

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

sendTransaction: (<const TRequest, TChainOverride>(args) => Promise<`0x${string}`>)

Returns

Example

Example

Type Parameters

Parameters

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

signMessage: ((args) => Promise<`0x${string}`>)

Returns

Example

Example

Parameters

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

signTransaction: (<TChainOverride>(args) => Promise<`0x02${string}` | `0x01${string}` | `0x03${string}` | TransactionSerializedLegacy>)

Returns

Example

Example

Type Parameters

Parameters

Returns Promise<`0x02${string}` | `0x01${string}` | `0x03${string}` | TransactionSerializedLegacy>

signTypedData: (<const TTypedData, TPrimaryType>(args) => Promise<`0x${string}`>)

Returns

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

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

`Optional` ccipRead?: false | {
request?: ((parameters) => Promise<`0x${string}`>);
}

extend: (<const client>(fn) => Client<Transport, undefined | Chain, undefined | Account, WalletRpcSchema, {
[K in string | number | symbol]: client[K]
} & WalletActions<undefined | Chain, undefined | Account>>)

Returns Client<Transport, undefined | Chain, undefined | Account, WalletRpcSchema, {
[K in string | number | symbol]: client[K]
} & WalletActions<undefined | Chain, undefined | Account>>

`Optional` amount?: string

`Optional` options?: DefaultWriteContractOptions