Function setApprovalOfOpenOrdersForAll

setApprovalOfOpenOrdersForAll(__namedParameters): Promise<undefined | `0x${string}`>
Parameters
- __namedParameters: {
      chainId: CHAIN_IDS;
      walletClient: {
          account: undefined | Account;
          batch?: {
              multicall?: boolean | {
                  batchSize?: number;
                  deployless?: boolean;
                  wait?: number;
              };
          };
          cacheTime: number;
          ccipRead?: false | {
              request?: ((parameters) => Promise<`0x${string}`>);
          };
          chain: undefined | Chain;
          experimental_blockTag?: BlockTag;
          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}`>);
          fillTransaction: (<chainOverride, accountOverride>(args) => Promise<FillTransactionReturnType<undefined | Chain, chainOverride>>);
          getAddresses: (() => Promise<GetAddressesReturnType>);
          getCallsStatus: ((parameters) => Promise<{
              id: string;
              chainId: number;
              version: string;
              atomic: boolean;
              capabilities?: {
                  [key: string]: any;
              } | {};
              receipts?: WalletCallReceipt<bigint, "success" | "reverted">[];
              statusCode: number;
              status: undefined | "pending" | "success" | "failure";
          }>);
          getCapabilities: (<chainId>(parameters?) => Promise<{
              [K in string | number | symbol]: (chainId extends number
                  ? {
                      atomic?: {
                          status: (...) | (...) | (...);
                      };
                      unstable_addSubAccount?: {
                          keyTypes: (...)[];
                          supported: boolean;
                      };
                      paymasterService?: {
                          supported: boolean;
                      };
                  }
                  : ChainIdToCapabilities<Capabilities<{
                      atomic?: (...) | (...);
                      unstable_addSubAccount?: (...) | (...);
                      paymasterService?: (...) | (...);
                  }>, number>)[K]
          }>);
          getChainId: (() => Promise<number>);
          getPermissions: (() => Promise<GetPermissionsReturnType>);
          prepareAuthorization: ((parameters) => Promise<PrepareAuthorizationReturnType>);
          prepareTransactionRequest: (<const request, chainOverride, accountOverride>(args) => Promise<{
              [K in string | number | symbol]: (UnionRequiredBy<Extract<(...) & (...) & (...), (...) extends (...)
                  ? (...)
                  : (...)> & {
                  chainId?: (...) | (...);
              }, ParameterTypeToParameters<(...)[(...)] extends readonly (...)[]
                  ? (...)[(...)]
                  : (...) | (...) | (...) | (...) | (...) | (...)>> & (unknown extends request["kzg"]
                  ? {}
                  : Pick<request, "kzg">))[K]
          }>);
          requestAddresses: (() => Promise<RequestAddressesReturnType>);
          requestPermissions: ((args) => Promise<RequestPermissionsReturnType>);
          sendCalls: (<const calls, chainOverride>(parameters) => Promise<{
              capabilities?: {};
              id: string;
          }>);
          sendCallsSync: (<const calls, chainOverride>(parameters) => Promise<{
              id: string;
              chainId: number;
              version: string;
              atomic: boolean;
              capabilities?: {
                  [key: string]: any;
              } | {};
              receipts?: WalletCallReceipt<bigint, "success" | "reverted">[];
              statusCode: number;
              status: undefined | "pending" | "success" | "failure";
          }>);
          sendRawTransaction: ((args) => Promise<`0x${string}`>);
          sendRawTransactionSync: ((args) => Promise<TransactionReceipt>);
          sendTransaction: (<const request, chainOverride>(args) => Promise<`0x${string}`>);
          sendTransactionSync: (<const request, chainOverride>(args) => Promise<TransactionReceipt>);
          showCallsStatus: ((parameters) => Promise<void>);
          signAuthorization: ((parameters) => Promise<SignAuthorizationReturnType>);
          signMessage: ((args) => Promise<`0x${string}`>);
          signTransaction: (<chainOverride, const request>(args) => Promise<TransactionSerialized<GetTransactionType<request, (request extends LegacyProperties
              ? "legacy"
              : never) | (request extends EIP1559Properties
              ? "eip1559"
              : never) | (request extends EIP2930Properties
              ? "eip2930"
              : never) | (request extends EIP4844Properties
              ? "eip4844"
              : never) | (request extends EIP7702Properties
              ? "eip7702"
              : never) | (request["type"] extends undefined | string
              ? Extract<any[any], string>
              : never)>, (GetTransactionType<request, (request extends LegacyProperties
                  ? "legacy"
                  : never) | (request extends EIP1559Properties
                  ? "eip1559"
                  : never) | (request extends EIP2930Properties
                  ? "eip2930"
                  : never) | (request extends EIP4844Properties
                  ? "eip4844"
                  : never) | (request extends EIP7702Properties
                  ? "eip7702"
                  : never) | ((...)[(...)] extends (...) | (...)
                  ? Extract<(...), (...)>
                  : never)> extends "eip1559"
              ? `0x02${string}`
              : never) | (GetTransactionType<request, (request extends LegacyProperties
                  ? "legacy"
                  : never) | (request extends EIP1559Properties
                  ? "eip1559"
                  : never) | (request extends EIP2930Properties
                  ? "eip2930"
                  : never) | (request extends EIP4844Properties
                  ? "eip4844"
                  : never) | (request extends EIP7702Properties
                  ? "eip7702"
                  : never) | ((...)[(...)] extends (...) | (...)
                  ? Extract<(...), (...)>
                  : never)> extends "eip2930"
              ? `0x01${string}`
              : never) | (GetTransactionType<request, (request extends LegacyProperties
                  ? "legacy"
                  : never) | (request extends EIP1559Properties
                  ? "eip1559"
                  : never) | (request extends EIP2930Properties
                  ? "eip2930"
                  : never) | (request extends EIP4844Properties
                  ? "eip4844"
                  : never) | (request extends EIP7702Properties
                  ? "eip7702"
                  : never) | ((...)[(...)] extends (...) | (...)
                  ? Extract<(...), (...)>
                  : never)> extends "eip4844"
              ? `0x03${string}`
              : never) | (GetTransactionType<request, (request extends LegacyProperties
                  ? "legacy"
                  : never) | (request extends EIP1559Properties
                  ? "eip1559"
                  : never) | (request extends EIP2930Properties
                  ? "eip2930"
                  : never) | (request extends EIP4844Properties
                  ? "eip4844"
                  : never) | (request extends EIP7702Properties
                  ? "eip7702"
                  : never) | ((...)[(...)] extends (...) | (...)
                  ? Extract<(...), (...)>
                  : never)> extends "eip7702"
              ? `0x04${string}`
              : never) | (GetTransactionType<request, (request extends LegacyProperties
                  ? "legacy"
                  : never) | (request extends EIP1559Properties
                  ? "eip1559"
                  : never) | (request extends EIP2930Properties
                  ? "eip2930"
                  : never) | (request extends EIP4844Properties
                  ? "eip4844"
                  : never) | (request extends EIP7702Properties
                  ? "eip7702"
                  : never) | ((...)[(...)] extends (...) | (...)
                  ? Extract<(...), (...)>
                  : never)> extends "legacy"
              ? TransactionSerializedLegacy
              : never)>>);
          signTypedData: (<const typedData, primaryType>(args) => Promise<`0x${string}`>);
          switchChain: ((args) => Promise<void>);
          waitForCallsStatus: ((parameters) => Promise<{
              id: string;
              chainId: number;
              version: string;
              atomic: boolean;
              capabilities?: {
                  [key: string]: any;
              } | {};
              receipts?: WalletCallReceipt<bigint, "success" | "reverted">[];
              statusCode: number;
              status: undefined | "pending" | "success" | "failure";
          }>);
          watchAsset: ((args) => Promise<boolean>);
          writeContract: (<const abi, functionName, args, chainOverride>(args) => Promise<`0x${string}`>);
          writeContractSync: (<const abi, functionName, args, chainOverride>(args) => Promise<TransactionReceipt>);
          extend: (<const client>(fn) => Client<Transport, undefined | Chain, undefined | Account, WalletRpcSchema, {
              [K in string | number | symbol]: client[K]
          } & WalletActions<undefined | Chain, undefined | Account>>);
      };
      options?: DefaultWriteContractOptions;
  }
  - chainId: CHAIN_IDS
  - walletClient: {
        account: undefined | Account;
        batch?: {
            multicall?: boolean | {
                batchSize?: number;
                deployless?: boolean;
                wait?: number;
            };
        };
        cacheTime: number;
        ccipRead?: false | {
            request?: ((parameters) => Promise<`0x${string}`>);
        };
        chain: undefined | Chain;
        experimental_blockTag?: BlockTag;
        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}`>);
        fillTransaction: (<chainOverride, accountOverride>(args) => Promise<FillTransactionReturnType<undefined | Chain, chainOverride>>);
        getAddresses: (() => Promise<GetAddressesReturnType>);
        getCallsStatus: ((parameters) => Promise<{
            id: string;
            chainId: number;
            version: string;
            atomic: boolean;
            capabilities?: {
                [key: string]: any;
            } | {};
            receipts?: WalletCallReceipt<bigint, "success" | "reverted">[];
            statusCode: number;
            status: undefined | "pending" | "success" | "failure";
        }>);
        getCapabilities: (<chainId>(parameters?) => Promise<{
            [K in string | number | symbol]: (chainId extends number
                ? {
                    atomic?: {
                        status: (...) | (...) | (...);
                    };
                    unstable_addSubAccount?: {
                        keyTypes: (...)[];
                        supported: boolean;
                    };
                    paymasterService?: {
                        supported: boolean;
                    };
                }
                : ChainIdToCapabilities<Capabilities<{
                    atomic?: (...) | (...);
                    unstable_addSubAccount?: (...) | (...);
                    paymasterService?: (...) | (...);
                }>, number>)[K]
        }>);
        getChainId: (() => Promise<number>);
        getPermissions: (() => Promise<GetPermissionsReturnType>);
        prepareAuthorization: ((parameters) => Promise<PrepareAuthorizationReturnType>);
        prepareTransactionRequest: (<const request, chainOverride, accountOverride>(args) => Promise<{
            [K in string | number | symbol]: (UnionRequiredBy<Extract<(...) & (...) & (...), (...) extends (...)
                ? (...)
                : (...)> & {
                chainId?: (...) | (...);
            }, ParameterTypeToParameters<(...)[(...)] extends readonly (...)[]
                ? (...)[(...)]
                : (...) | (...) | (...) | (...) | (...) | (...)>> & (unknown extends request["kzg"]
                ? {}
                : Pick<request, "kzg">))[K]
        }>);
        requestAddresses: (() => Promise<RequestAddressesReturnType>);
        requestPermissions: ((args) => Promise<RequestPermissionsReturnType>);
        sendCalls: (<const calls, chainOverride>(parameters) => Promise<{
            capabilities?: {};
            id: string;
        }>);
        sendCallsSync: (<const calls, chainOverride>(parameters) => Promise<{
            id: string;
            chainId: number;
            version: string;
            atomic: boolean;
            capabilities?: {
                [key: string]: any;
            } | {};
            receipts?: WalletCallReceipt<bigint, "success" | "reverted">[];
            statusCode: number;
            status: undefined | "pending" | "success" | "failure";
        }>);
        sendRawTransaction: ((args) => Promise<`0x${string}`>);
        sendRawTransactionSync: ((args) => Promise<TransactionReceipt>);
        sendTransaction: (<const request, chainOverride>(args) => Promise<`0x${string}`>);
        sendTransactionSync: (<const request, chainOverride>(args) => Promise<TransactionReceipt>);
        showCallsStatus: ((parameters) => Promise<void>);
        signAuthorization: ((parameters) => Promise<SignAuthorizationReturnType>);
        signMessage: ((args) => Promise<`0x${string}`>);
        signTransaction: (<chainOverride, const request>(args) => Promise<TransactionSerialized<GetTransactionType<request, (request extends LegacyProperties
            ? "legacy"
            : never) | (request extends EIP1559Properties
            ? "eip1559"
            : never) | (request extends EIP2930Properties
            ? "eip2930"
            : never) | (request extends EIP4844Properties
            ? "eip4844"
            : never) | (request extends EIP7702Properties
            ? "eip7702"
            : never) | (request["type"] extends undefined | string
            ? Extract<any[any], string>
            : never)>, (GetTransactionType<request, (request extends LegacyProperties
                ? "legacy"
                : never) | (request extends EIP1559Properties
                ? "eip1559"
                : never) | (request extends EIP2930Properties
                ? "eip2930"
                : never) | (request extends EIP4844Properties
                ? "eip4844"
                : never) | (request extends EIP7702Properties
                ? "eip7702"
                : never) | ((...)[(...)] extends (...) | (...)
                ? Extract<(...), (...)>
                : never)> extends "eip1559"
            ? `0x02${string}`
            : never) | (GetTransactionType<request, (request extends LegacyProperties
                ? "legacy"
                : never) | (request extends EIP1559Properties
                ? "eip1559"
                : never) | (request extends EIP2930Properties
                ? "eip2930"
                : never) | (request extends EIP4844Properties
                ? "eip4844"
                : never) | (request extends EIP7702Properties
                ? "eip7702"
                : never) | ((...)[(...)] extends (...) | (...)
                ? Extract<(...), (...)>
                : never)> extends "eip2930"
            ? `0x01${string}`
            : never) | (GetTransactionType<request, (request extends LegacyProperties
                ? "legacy"
                : never) | (request extends EIP1559Properties
                ? "eip1559"
                : never) | (request extends EIP2930Properties
                ? "eip2930"
                : never) | (request extends EIP4844Properties
                ? "eip4844"
                : never) | (request extends EIP7702Properties
                ? "eip7702"
                : never) | ((...)[(...)] extends (...) | (...)
                ? Extract<(...), (...)>
                : never)> extends "eip4844"
            ? `0x03${string}`
            : never) | (GetTransactionType<request, (request extends LegacyProperties
                ? "legacy"
                : never) | (request extends EIP1559Properties
                ? "eip1559"
                : never) | (request extends EIP2930Properties
                ? "eip2930"
                : never) | (request extends EIP4844Properties
                ? "eip4844"
                : never) | (request extends EIP7702Properties
                ? "eip7702"
                : never) | ((...)[(...)] extends (...) | (...)
                ? Extract<(...), (...)>
                : never)> extends "eip7702"
            ? `0x04${string}`
            : never) | (GetTransactionType<request, (request extends LegacyProperties
                ? "legacy"
                : never) | (request extends EIP1559Properties
                ? "eip1559"
                : never) | (request extends EIP2930Properties
                ? "eip2930"
                : never) | (request extends EIP4844Properties
                ? "eip4844"
                : never) | (request extends EIP7702Properties
                ? "eip7702"
                : never) | ((...)[(...)] extends (...) | (...)
                ? Extract<(...), (...)>
                : never)> extends "legacy"
            ? TransactionSerializedLegacy
            : never)>>);
        signTypedData: (<const typedData, primaryType>(args) => Promise<`0x${string}`>);
        switchChain: ((args) => Promise<void>);
        waitForCallsStatus: ((parameters) => Promise<{
            id: string;
            chainId: number;
            version: string;
            atomic: boolean;
            capabilities?: {
                [key: string]: any;
            } | {};
            receipts?: WalletCallReceipt<bigint, "success" | "reverted">[];
            statusCode: number;
            status: undefined | "pending" | "success" | "failure";
        }>);
        watchAsset: ((args) => Promise<boolean>);
        writeContract: (<const abi, functionName, args, chainOverride>(args) => Promise<`0x${string}`>);
        writeContractSync: (<const abi, functionName, args, chainOverride>(args) => Promise<TransactionReceipt>);
        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;
              deployless?: boolean;
              wait?: number;
          };
      }
      Flags for batch settings.
      
      Optional multicall?: boolean | {
          batchSize?: number;
          deployless?: boolean;
          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.
    - Optional experimental_blockTag?: BlockTag
      Default block tag to use for RPC requests.
    - 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}`>
    - fillTransaction: (<chainOverride, accountOverride>(args) => Promise<FillTransactionReturnType<undefined | Chain, chainOverride>>)
      Fills a transaction request with the necessary fields to be signed over.
      
      Docs: https://viem.sh/docs/actions/public/fillTransaction
      
      Returns
      The filled transaction. FillTransactionReturnType
      
      Example
      import { createWalletClient, custom } from 'viem' import { mainnet } from 'viem/chains' const client = createWalletClient({ chain: mainnet, transport: custom(window.ethereum), }) const result = await client.fillTransaction({ account: '0xA0Cf798816D4b9b9866b5330EEa46a18382f251e', to: '0x70997970c51812dc3a010c7d01b50e0d17dc79c8', value: parseEther('1'), })
      
      <chainOverride, accountOverride>(args): Promise<FillTransactionReturnType<undefined | Chain, chainOverride>>
      Type Parameters
      chainOverride extends undefined | Chain = undefined
      accountOverride extends undefined | `0x${string}` | Account = undefined
      Parameters
      args: FillTransactionParameters<undefined | Chain, undefined | Account, chainOverride, accountOverride>
      Returns Promise<FillTransactionReturnType<undefined | Chain, chainOverride>>
    - 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>
    - getCallsStatus: ((parameters) => Promise<{
          id: string;
          chainId: number;
          version: string;
          atomic: boolean;
          capabilities?: {
              [key: string]: any;
          } | {};
          receipts?: WalletCallReceipt<bigint, "success" | "reverted">[];
          statusCode: number;
          status: undefined | "pending" | "success" | "failure";
      }>)
      Returns the status of a call batch that was sent via sendCalls.
      
      Docs: https://viem.sh/docs/actions/wallet/getCallsStatus
      
      JSON-RPC Methods: wallet_getCallsStatus
      
      Returns
      Status of the calls. GetCallsStatusReturnType
      
      Example
      import { createWalletClient, custom } from 'viem' import { mainnet } from 'viem/chains' const client = createWalletClient({ chain: mainnet, transport: custom(window.ethereum), }) const { receipts, status } = await client.getCallsStatus({ id: '0xdeadbeef' })
      
      (parameters): Promise<{
          id: string;
          chainId: number;
          version: string;
          atomic: boolean;
          capabilities?: {
              [key: string]: any;
          } | {};
          receipts?: WalletCallReceipt<bigint, "success" | "reverted">[];
          statusCode: number;
          status: undefined | "pending" | "success" | "failure";
      }>
      Parameters
      parameters: GetCallsStatusParameters
      Returns Promise<{
          id: string;
          chainId: number;
          version: string;
          atomic: boolean;
          capabilities?: {
              [key: string]: any;
          } | {};
          receipts?: WalletCallReceipt<bigint, "success" | "reverted">[];
          statusCode: number;
          status: undefined | "pending" | "success" | "failure";
      }>
    - getCapabilities: (<chainId>(parameters?) => Promise<{
          [K in string | number | symbol]: (chainId extends number
              ? {
                  atomic?: {
                      status: (...) | (...) | (...);
                  };
                  unstable_addSubAccount?: {
                      keyTypes: (...)[];
                      supported: boolean;
                  };
                  paymasterService?: {
                      supported: boolean;
                  };
              }
              : ChainIdToCapabilities<Capabilities<{
                  atomic?: (...) | (...);
                  unstable_addSubAccount?: (...) | (...);
                  paymasterService?: (...) | (...);
              }>, number>)[K]
      }>)
      Extract capabilities that a connected wallet supports (e.g. paymasters, session keys, etc).
      
      Docs: https://viem.sh/docs/actions/wallet/getCapabilities
      
      JSON-RPC Methods: wallet_getCapabilities
      
      Returns
      The wallet's capabilities. GetCapabilitiesReturnType
      
      Example
      import { createWalletClient, custom } from 'viem' import { mainnet } from 'viem/chains' const client = createWalletClient({ chain: mainnet, transport: custom(window.ethereum), }) const capabilities = await client.getCapabilities({ account: '0xA0Cf798816D4b9b9866b5330EEa46a18382f251e', })
      
      <chainId>(parameters?): Promise<{
          [K in string | number | symbol]: (chainId extends number
              ? {
                  atomic?: {
                      status: (...) | (...) | (...);
                  };
                  unstable_addSubAccount?: {
                      keyTypes: (...)[];
                      supported: boolean;
                  };
                  paymasterService?: {
                      supported: boolean;
                  };
              }
              : ChainIdToCapabilities<Capabilities<{
                  atomic?: (...) | (...);
                  unstable_addSubAccount?: (...) | (...);
                  paymasterService?: (...) | (...);
              }>, number>)[K]
      }>
      Type Parameters
      chainId extends undefined | number
      Parameters
      Optional parameters: GetCapabilitiesParameters<chainId>
      Returns Promise<{
          [K in string | number | symbol]: (chainId extends number
              ? {
                  atomic?: {
                      status: (...) | (...) | (...);
                  };
                  unstable_addSubAccount?: {
                      keyTypes: (...)[];
                      supported: boolean;
                  };
                  paymasterService?: {
                      supported: boolean;
                  };
              }
              : ChainIdToCapabilities<Capabilities<{
                  atomic?: (...) | (...);
                  unstable_addSubAccount?: (...) | (...);
                  paymasterService?: (...) | (...);
              }>, number>)[K]
      }>
    - 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>
    - prepareAuthorization: ((parameters) => Promise<PrepareAuthorizationReturnType>)
      Prepares an EIP-7702 Authorization object for signing. This Action will fill the required fields of the Authorization object if they are not provided (e.g. nonce and chainId).
      
      With the prepared Authorization object, you can use signAuthorization to sign over the Authorization object.
      
      Returns
      The prepared Authorization object. PrepareAuthorizationReturnType
      
      Example
      import { createWalletClient, http } from 'viem' import { privateKeyToAccount } from 'viem/accounts' import { mainnet } from 'viem/chains' const client = createWalletClient({ chain: mainnet, transport: http(), }) const authorization = await client.prepareAuthorization({ account: privateKeyToAccount('0x..'), contractAddress: '0xA0Cf798816D4b9b9866b5330EEa46a18382f251e', })
      
      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 authorization = await client.prepareAuthorization({ contractAddress: '0xA0Cf798816D4b9b9866b5330EEa46a18382f251e', })
      
      (parameters): Promise<PrepareAuthorizationReturnType>
      Parameters
      parameters: PrepareAuthorizationParameters<undefined | Account>
      PrepareAuthorizationParameters
      
      Returns Promise<PrepareAuthorizationReturnType>
    - prepareTransactionRequest: (<const request, chainOverride, accountOverride>(args) => Promise<{
          [K in string | number | symbol]: (UnionRequiredBy<Extract<(...) & (...) & (...), (...) extends (...)
              ? (...)
              : (...)> & {
              chainId?: (...) | (...);
          }, ParameterTypeToParameters<(...)[(...)] extends readonly (...)[]
              ? (...)[(...)]
              : (...) | (...) | (...) | (...) | (...) | (...)>> & (unknown extends request["kzg"]
              ? {}
              : Pick<request, "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 request, chainOverride, accountOverride>(args): Promise<{
          [K in string | number | symbol]: (UnionRequiredBy<Extract<(...) & (...) & (...), (...) extends (...)
              ? (...)
              : (...)> & {
              chainId?: (...) | (...);
          }, ParameterTypeToParameters<(...)[(...)] extends readonly (...)[]
              ? (...)[(...)]
              : (...) | (...) | (...) | (...) | (...) | (...)>> & (unknown extends request["kzg"]
              ? {}
              : Pick<request, "kzg">))[K]
      }>
      Type Parameters
      const request extends (Omit<{
          data?: `0x${string}`;
          from?: `0x${string}`;
          gas?: bigint;
          nonce?: number;
          to?: null | `0x${string}`;
          type?: "legacy";
          value?: bigint;
          gasPrice?: bigint;
          maxFeePerBlobGas?: undefined;
          maxFeePerGas?: undefined;
          maxPriorityFeePerGas?: undefined;
          blobs: undefined;
          blobVersionedHashes: undefined;
          kzg: undefined;
          accessList: undefined;
          sidecars: undefined;
          authorizationList: undefined;
      }, "from"> | Omit<{
          data?: `0x${string}`;
          from?: `0x${string}`;
          gas?: bigint;
          nonce?: number;
          to?: null | `0x${string}`;
          type?: "eip2930";
          value?: bigint;
          gasPrice?: bigint;
          maxFeePerBlobGas?: undefined;
          maxFeePerGas?: undefined;
          maxPriorityFeePerGas?: undefined;
          accessList?: AccessList;
          blobs: undefined;
          blobVersionedHashes: undefined;
          kzg: undefined;
          sidecars: undefined;
          authorizationList: undefined;
      }, "from"> | Omit<{
          data?: `0x${string}`;
          from?: `0x${string}`;
          gas?: bigint;
          nonce?: number;
          to?: null | `0x${string}`;
          type?: "eip1559";
          value?: bigint;
          gasPrice?: undefined;
          maxFeePerBlobGas?: undefined;
          maxFeePerGas?: bigint;
          maxPriorityFeePerGas?: bigint;
          accessList?: AccessList;
          blobs: undefined;
          blobVersionedHashes: undefined;
          kzg: undefined;
          sidecars: undefined;
          authorizationList: undefined;
      }, "from"> | Omit<{
          from?: `0x${string}`;
          data?: `0x${string}`;
          gas?: bigint;
          nonce?: number;
          type?: "eip4844";
          value?: bigint;
          to: null | `0x${string}`;
          gasPrice?: undefined;
          maxFeePerBlobGas?: bigint;
          maxFeePerGas?: bigint;
          maxPriorityFeePerGas?: bigint;
          accessList?: AccessList;
          sidecars?: readonly BlobSidecar<`0x${(...)}`>[];
          blobs?: readonly `0x${string}`[] | readonly Uint8Array[];
          blobVersionedHashes: readonly `0x${string}`[];
          kzg: undefined;
          authorizationList: undefined;
      }, "from"> | Omit<{
          from?: `0x${string}`;
          data?: `0x${string}`;
          gas?: bigint;
          nonce?: number;
          type?: "eip4844";
          value?: bigint;
          to: null | `0x${string}`;
          gasPrice?: undefined;
          maxFeePerBlobGas?: bigint;
          maxFeePerGas?: bigint;
          maxPriorityFeePerGas?: bigint;
          accessList?: AccessList;
          sidecars?: readonly BlobSidecar<`0x${(...)}`>[];
          blobs: readonly `0x${string}`[] | readonly Uint8Array[];
          blobVersionedHashes?: readonly `0x${string}`[];
          kzg?: Kzg;
          authorizationList: undefined;
      }, "from"> | Omit<{
          data?: `0x${string}`;
          from?: `0x${string}`;
          gas?: bigint;
          nonce?: number;
          to?: null | `0x${string}`;
          type?: "eip7702";
          value?: bigint;
          gasPrice?: undefined;
          maxFeePerBlobGas?: undefined;
          maxFeePerGas?: bigint;
          maxPriorityFeePerGas?: bigint;
          accessList?: AccessList;
          authorizationList?: AuthorizationList<number, boolean>;
          blobs: undefined;
          blobVersionedHashes: undefined;
          kzg: undefined;
          sidecars: undefined;
      }, "from">) & {
          kzg?: Kzg;
      } & {
          nonceManager?: NonceManager;
          parameters?: readonly PrepareTransactionRequestParameterType[];
      }
      chainOverride extends undefined | Chain = undefined
      accountOverride extends undefined | `0x${string}` | Account = undefined
      Parameters
      args: PrepareTransactionRequestParameters<undefined | Chain, undefined | Account, chainOverride, accountOverride, request>
      PrepareTransactionRequestParameters
      
      Returns Promise<{
          [K in string | number | symbol]: (UnionRequiredBy<Extract<(...) & (...) & (...), (...) extends (...)
              ? (...)
              : (...)> & {
              chainId?: (...) | (...);
          }, ParameterTypeToParameters<(...)[(...)] extends readonly (...)[]
              ? (...)[(...)]
              : (...) | (...) | (...) | (...) | (...) | (...)>> & (unknown extends request["kzg"]
              ? {}
              : Pick<request, "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>
    - sendCalls: (<const calls, chainOverride>(parameters) => Promise<{
          capabilities?: {};
          id: string;
      }>)
      Requests the connected wallet to send a batch of calls.
      
      Docs: https://viem.sh/docs/actions/wallet/sendCalls
      
      JSON-RPC Methods: wallet_sendCalls
      
      Returns
      Transaction identifier. SendCallsReturnType
      
      Example
      import { createWalletClient, custom } from 'viem' import { mainnet } from 'viem/chains' const client = createWalletClient({ chain: mainnet, transport: custom(window.ethereum), }) const id = await client.sendCalls({ account: '0xA0Cf798816D4b9b9866b5330EEa46a18382f251e', calls: [ { data: '0xdeadbeef', to: '0x70997970c51812dc3a010c7d01b50e0d17dc79c8', }, { to: '0x70997970c51812dc3a010c7d01b50e0d17dc79c8', value: 69420n, }, ], })
      
      <const calls, chainOverride>(parameters): Promise<{
          capabilities?: {};
          id: string;
      }>
      Type Parameters
      const calls extends readonly unknown[]
      chainOverride extends undefined | Chain = undefined
      Parameters
      parameters: SendCallsParameters<undefined | Chain, undefined | Account, chainOverride, calls>
      Returns Promise<{
          capabilities?: {};
          id: string;
      }>
    - sendCallsSync: (<const calls, chainOverride>(parameters) => Promise<{
          id: string;
          chainId: number;
          version: string;
          atomic: boolean;
          capabilities?: {
              [key: string]: any;
          } | {};
          receipts?: WalletCallReceipt<bigint, "success" | "reverted">[];
          statusCode: number;
          status: undefined | "pending" | "success" | "failure";
      }>)
      Requests the connected wallet to send a batch of calls, and waits for the calls to be included in a block.
      
      Docs: https://viem.sh/docs/actions/wallet/sendCallsSync
      
      JSON-RPC Methods: wallet_sendCalls
      
      Returns
      Calls status. SendCallsSyncReturnType
      
      Example
      import { createWalletClient, custom } from 'viem' import { mainnet } from 'viem/chains' const client = createWalletClient({ chain: mainnet, transport: custom(window.ethereum), }) const status = await client.sendCallsSync({ account: '0xA0Cf798816D4b9b9866b5330EEa46a18382f251e', calls: [ { data: '0xdeadbeef', to: '0x70997970c51812dc3a010c7d01b50e0d17dc79c8', }, { to: '0x70997970c51812dc3a010c7d01b50e0d17dc79c8', value: 69420n, }, ], })
      
      <const calls, chainOverride>(parameters): Promise<{
          id: string;
          chainId: number;
          version: string;
          atomic: boolean;
          capabilities?: {
              [key: string]: any;
          } | {};
          receipts?: WalletCallReceipt<bigint, "success" | "reverted">[];
          statusCode: number;
          status: undefined | "pending" | "success" | "failure";
      }>
      Type Parameters
      const calls extends readonly unknown[]
      chainOverride extends undefined | Chain = undefined
      Parameters
      parameters: SendCallsSyncParameters<undefined | Chain, undefined | Account, chainOverride, calls>
      Returns Promise<{
          id: string;
          chainId: number;
          version: string;
          atomic: boolean;
          capabilities?: {
              [key: string]: any;
          } | {};
          receipts?: WalletCallReceipt<bigint, "success" | "reverted">[];
          statusCode: number;
          status: undefined | "pending" | "success" | "failure";
      }>
    - 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}`>
    - sendRawTransactionSync: ((args) => Promise<TransactionReceipt>)
      Sends a signed transaction to the network synchronously, and waits for the transaction to be included in a block.
      
      Docs: https://viem.sh/docs/actions/wallet/sendRawTransactionSync
      
      JSON-RPC Method: eth_sendRawTransactionSync
      
      Returns
      The transaction receipt. SendRawTransactionSyncReturnType
      
      Example
      import { createWalletClient, custom } from 'viem' import { mainnet } from 'viem/chains' import { sendRawTransactionSync } from 'viem/wallet' const client = createWalletClient({ chain: mainnet, transport: custom(window.ethereum), }) const receipt = await client.sendRawTransactionSync({ serializedTransaction: '0x02f850018203118080825208808080c080a04012522854168b27e5dc3d5839bab5e6b39e1a0ffd343901ce1622e3d64b48f1a04e00902ae0502c4728cbf12156290df99c3ed7de85b1dbfe20b5c36931733a33' })
      
      (args): Promise<TransactionReceipt>
      Parameters
      args: SendRawTransactionSyncParameters
      Returns Promise<TransactionReceipt>
    - sendTransaction: (<const request, chainOverride>(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 request, chainOverride>(args): Promise<`0x${string}`>
      Type Parameters
      const request extends (Omit<{
          data?: `0x${string}`;
          from?: `0x${string}`;
          gas?: bigint;
          nonce?: number;
          to?: null | `0x${string}`;
          type?: "legacy";
          value?: bigint;
          gasPrice?: bigint;
          maxFeePerBlobGas?: undefined;
          maxFeePerGas?: undefined;
          maxPriorityFeePerGas?: undefined;
          blobs: undefined;
          blobVersionedHashes: undefined;
          kzg: undefined;
          accessList: undefined;
          sidecars: undefined;
          authorizationList: undefined;
      }, "from"> | Omit<{
          data?: `0x${string}`;
          from?: `0x${string}`;
          gas?: bigint;
          nonce?: number;
          to?: null | `0x${string}`;
          type?: "eip2930";
          value?: bigint;
          gasPrice?: bigint;
          maxFeePerBlobGas?: undefined;
          maxFeePerGas?: undefined;
          maxPriorityFeePerGas?: undefined;
          accessList?: AccessList;
          blobs: undefined;
          blobVersionedHashes: undefined;
          kzg: undefined;
          sidecars: undefined;
          authorizationList: undefined;
      }, "from"> | Omit<{
          data?: `0x${string}`;
          from?: `0x${string}`;
          gas?: bigint;
          nonce?: number;
          to?: null | `0x${string}`;
          type?: "eip1559";
          value?: bigint;
          gasPrice?: undefined;
          maxFeePerBlobGas?: undefined;
          maxFeePerGas?: bigint;
          maxPriorityFeePerGas?: bigint;
          accessList?: AccessList;
          blobs: undefined;
          blobVersionedHashes: undefined;
          kzg: undefined;
          sidecars: undefined;
          authorizationList: undefined;
      }, "from"> | Omit<{
          from?: `0x${string}`;
          data?: `0x${string}`;
          gas?: bigint;
          nonce?: number;
          type?: "eip4844";
          value?: bigint;
          to: null | `0x${string}`;
          gasPrice?: undefined;
          maxFeePerBlobGas?: bigint;
          maxFeePerGas?: bigint;
          maxPriorityFeePerGas?: bigint;
          accessList?: AccessList;
          sidecars?: readonly BlobSidecar<`0x${(...)}`>[];
          blobs?: readonly `0x${string}`[] | readonly Uint8Array[];
          blobVersionedHashes: readonly `0x${string}`[];
          kzg: undefined;
          authorizationList: undefined;
      }, "from"> | Omit<{
          from?: `0x${string}`;
          data?: `0x${string}`;
          gas?: bigint;
          nonce?: number;
          type?: "eip4844";
          value?: bigint;
          to: null | `0x${string}`;
          gasPrice?: undefined;
          maxFeePerBlobGas?: bigint;
          maxFeePerGas?: bigint;
          maxPriorityFeePerGas?: bigint;
          accessList?: AccessList;
          sidecars?: readonly BlobSidecar<`0x${(...)}`>[];
          blobs: readonly `0x${string}`[] | readonly Uint8Array[];
          blobVersionedHashes?: readonly `0x${string}`[];
          kzg?: Kzg;
          authorizationList: undefined;
      }, "from"> | Omit<{
          data?: `0x${string}`;
          from?: `0x${string}`;
          gas?: bigint;
          nonce?: number;
          to?: null | `0x${string}`;
          type?: "eip7702";
          value?: bigint;
          gasPrice?: undefined;
          maxFeePerBlobGas?: undefined;
          maxFeePerGas?: bigint;
          maxPriorityFeePerGas?: bigint;
          accessList?: AccessList;
          authorizationList?: AuthorizationList<number, boolean>;
          blobs: undefined;
          blobVersionedHashes: undefined;
          kzg: undefined;
          sidecars: undefined;
      }, "from">) & {
          kzg?: Kzg;
      }
      chainOverride extends undefined | Chain = undefined
      Parameters
      args: SendTransactionParameters<undefined | Chain, undefined | Account, chainOverride, request>
      SendTransactionParameters
      
      Returns Promise<`0x${string}`>
    - sendTransactionSync: (<const request, chainOverride>(args) => Promise<TransactionReceipt>)
      Creates, signs, and sends a new transaction to the network synchronously. Returns the transaction receipt.
      
      Docs: https://viem.sh/docs/actions/wallet/sendTransactionSync
      
      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 receipt. SendTransactionReturnType
      
      Example
      import { createWalletClient, custom } from 'viem' import { mainnet } from 'viem/chains' const client = createWalletClient({ chain: mainnet, transport: custom(window.ethereum), }) const receipt = await client.sendTransactionSync({ 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 receipt = await client.sendTransactionSync({ to: '0x70997970c51812dc3a010c7d01b50e0d17dc79c8', value: 1000000000000000000n, })
      
      <const request, chainOverride>(args): Promise<TransactionReceipt>
      Type Parameters
      const request extends (Omit<{
          data?: `0x${string}`;
          from?: `0x${string}`;
          gas?: bigint;
          nonce?: number;
          to?: null | `0x${string}`;
          type?: "legacy";
          value?: bigint;
          gasPrice?: bigint;
          maxFeePerBlobGas?: undefined;
          maxFeePerGas?: undefined;
          maxPriorityFeePerGas?: undefined;
          blobs: undefined;
          blobVersionedHashes: undefined;
          kzg: undefined;
          accessList: undefined;
          sidecars: undefined;
          authorizationList: undefined;
      }, "from"> | Omit<{
          data?: `0x${string}`;
          from?: `0x${string}`;
          gas?: bigint;
          nonce?: number;
          to?: null | `0x${string}`;
          type?: "eip2930";
          value?: bigint;
          gasPrice?: bigint;
          maxFeePerBlobGas?: undefined;
          maxFeePerGas?: undefined;
          maxPriorityFeePerGas?: undefined;
          accessList?: AccessList;
          blobs: undefined;
          blobVersionedHashes: undefined;
          kzg: undefined;
          sidecars: undefined;
          authorizationList: undefined;
      }, "from"> | Omit<{
          data?: `0x${string}`;
          from?: `0x${string}`;
          gas?: bigint;
          nonce?: number;
          to?: null | `0x${string}`;
          type?: "eip1559";
          value?: bigint;
          gasPrice?: undefined;
          maxFeePerBlobGas?: undefined;
          maxFeePerGas?: bigint;
          maxPriorityFeePerGas?: bigint;
          accessList?: AccessList;
          blobs: undefined;
          blobVersionedHashes: undefined;
          kzg: undefined;
          sidecars: undefined;
          authorizationList: undefined;
      }, "from"> | Omit<{
          from?: `0x${string}`;
          data?: `0x${string}`;
          gas?: bigint;
          nonce?: number;
          type?: "eip4844";
          value?: bigint;
          to: null | `0x${string}`;
          gasPrice?: undefined;
          maxFeePerBlobGas?: bigint;
          maxFeePerGas?: bigint;
          maxPriorityFeePerGas?: bigint;
          accessList?: AccessList;
          sidecars?: readonly BlobSidecar<`0x${(...)}`>[];
          blobs?: readonly `0x${string}`[] | readonly Uint8Array[];
          blobVersionedHashes: readonly `0x${string}`[];
          kzg: undefined;
          authorizationList: undefined;
      }, "from"> | Omit<{
          from?: `0x${string}`;
          data?: `0x${string}`;
          gas?: bigint;
          nonce?: number;
          type?: "eip4844";
          value?: bigint;
          to: null | `0x${string}`;
          gasPrice?: undefined;
          maxFeePerBlobGas?: bigint;
          maxFeePerGas?: bigint;
          maxPriorityFeePerGas?: bigint;
          accessList?: AccessList;
          sidecars?: readonly BlobSidecar<`0x${(...)}`>[];
          blobs: readonly `0x${string}`[] | readonly Uint8Array[];
          blobVersionedHashes?: readonly `0x${string}`[];
          kzg?: Kzg;
          authorizationList: undefined;
      }, "from"> | Omit<{
          data?: `0x${string}`;
          from?: `0x${string}`;
          gas?: bigint;
          nonce?: number;
          to?: null | `0x${string}`;
          type?: "eip7702";
          value?: bigint;
          gasPrice?: undefined;
          maxFeePerBlobGas?: undefined;
          maxFeePerGas?: bigint;
          maxPriorityFeePerGas?: bigint;
          accessList?: AccessList;
          authorizationList?: AuthorizationList<number, boolean>;
          blobs: undefined;
          blobVersionedHashes: undefined;
          kzg: undefined;
          sidecars: undefined;
      }, "from">) & {
          kzg?: Kzg;
      }
      chainOverride extends undefined | Chain = undefined
      Parameters
      args: SendTransactionSyncParameters<undefined | Chain, undefined | Account, chainOverride, request>
      SendTransactionParameters
      
      Returns Promise<TransactionReceipt>
    - showCallsStatus: ((parameters) => Promise<void>)
      Requests for the wallet to show information about a call batch that was sent via sendCalls.
      
      Docs: https://viem.sh/docs/actions/wallet/showCallsStatus
      
      JSON-RPC Methods: wallet_showCallsStatus
      
      Returns
      Displays status of the calls in wallet. ShowCallsStatusReturnType
      
      Example
      import { createWalletClient, custom } from 'viem' import { mainnet } from 'viem/chains' const client = createWalletClient({ chain: mainnet, transport: custom(window.ethereum), }) await client.showCallsStatus({ id: '0xdeadbeef' })
      
      (parameters): Promise<void>
      Parameters
      parameters: ShowCallsStatusParameters
      Returns Promise<void>
    - signAuthorization: ((parameters) => Promise<SignAuthorizationReturnType>)
      Signs an EIP-7702 Authorization object.
      
      With the calculated signature, you can:
      
      use verifyAuthorization to verify the signed Authorization object,
      
      use recoverAuthorizationAddress to recover the signing address from the signed Authorization object.
      
      Returns
      The signed Authorization object. SignAuthorizationReturnType
      
      Example
      import { createWalletClient, http } from 'viem' import { privateKeyToAccount } from 'viem/accounts' import { mainnet } from 'viem/chains' const client = createWalletClient({ chain: mainnet, transport: http(), }) const signature = await client.signAuthorization({ account: privateKeyToAccount('0x..'), contractAddress: '0xA0Cf798816D4b9b9866b5330EEa46a18382f251e', })
      
      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.signAuthorization({ contractAddress: '0xA0Cf798816D4b9b9866b5330EEa46a18382f251e', })
      
      (parameters): Promise<SignAuthorizationReturnType>
      Parameters
      parameters: SignAuthorizationParameters<undefined | Account>
      SignAuthorizationParameters
      
      Returns Promise<SignAuthorizationReturnType>
    - 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: (<chainOverride, const request>(args) => Promise<TransactionSerialized<GetTransactionType<request, (request extends LegacyProperties
          ? "legacy"
          : never) | (request extends EIP1559Properties
          ? "eip1559"
          : never) | (request extends EIP2930Properties
          ? "eip2930"
          : never) | (request extends EIP4844Properties
          ? "eip4844"
          : never) | (request extends EIP7702Properties
          ? "eip7702"
          : never) | (request["type"] extends undefined | string
          ? Extract<any[any], string>
          : never)>, (GetTransactionType<request, (request extends LegacyProperties
              ? "legacy"
              : never) | (request extends EIP1559Properties
              ? "eip1559"
              : never) | (request extends EIP2930Properties
              ? "eip2930"
              : never) | (request extends EIP4844Properties
              ? "eip4844"
              : never) | (request extends EIP7702Properties
              ? "eip7702"
              : never) | ((...)[(...)] extends (...) | (...)
              ? Extract<(...), (...)>
              : never)> extends "eip1559"
          ? `0x02${string}`
          : never) | (GetTransactionType<request, (request extends LegacyProperties
              ? "legacy"
              : never) | (request extends EIP1559Properties
              ? "eip1559"
              : never) | (request extends EIP2930Properties
              ? "eip2930"
              : never) | (request extends EIP4844Properties
              ? "eip4844"
              : never) | (request extends EIP7702Properties
              ? "eip7702"
              : never) | ((...)[(...)] extends (...) | (...)
              ? Extract<(...), (...)>
              : never)> extends "eip2930"
          ? `0x01${string}`
          : never) | (GetTransactionType<request, (request extends LegacyProperties
              ? "legacy"
              : never) | (request extends EIP1559Properties
              ? "eip1559"
              : never) | (request extends EIP2930Properties
              ? "eip2930"
              : never) | (request extends EIP4844Properties
              ? "eip4844"
              : never) | (request extends EIP7702Properties
              ? "eip7702"
              : never) | ((...)[(...)] extends (...) | (...)
              ? Extract<(...), (...)>
              : never)> extends "eip4844"
          ? `0x03${string}`
          : never) | (GetTransactionType<request, (request extends LegacyProperties
              ? "legacy"
              : never) | (request extends EIP1559Properties
              ? "eip1559"
              : never) | (request extends EIP2930Properties
              ? "eip2930"
              : never) | (request extends EIP4844Properties
              ? "eip4844"
              : never) | (request extends EIP7702Properties
              ? "eip7702"
              : never) | ((...)[(...)] extends (...) | (...)
              ? Extract<(...), (...)>
              : never)> extends "eip7702"
          ? `0x04${string}`
          : never) | (GetTransactionType<request, (request extends LegacyProperties
              ? "legacy"
              : never) | (request extends EIP1559Properties
              ? "eip1559"
              : never) | (request extends EIP2930Properties
              ? "eip2930"
              : never) | (request extends EIP4844Properties
              ? "eip4844"
              : never) | (request extends EIP7702Properties
              ? "eip7702"
              : never) | ((...)[(...)] extends (...) | (...)
              ? Extract<(...), (...)>
              : never)> extends "legacy"
          ? TransactionSerializedLegacy
          : never)>>)
      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)
      
      <chainOverride, const request>(args): Promise<TransactionSerialized<GetTransactionType<request, (request extends LegacyProperties
          ? "legacy"
          : never) | (request extends EIP1559Properties
          ? "eip1559"
          : never) | (request extends EIP2930Properties
          ? "eip2930"
          : never) | (request extends EIP4844Properties
          ? "eip4844"
          : never) | (request extends EIP7702Properties
          ? "eip7702"
          : never) | (request["type"] extends undefined | string
          ? Extract<any[any], string>
          : never)>, (GetTransactionType<request, (request extends LegacyProperties
              ? "legacy"
              : never) | (request extends EIP1559Properties
              ? "eip1559"
              : never) | (request extends EIP2930Properties
              ? "eip2930"
              : never) | (request extends EIP4844Properties
              ? "eip4844"
              : never) | (request extends EIP7702Properties
              ? "eip7702"
              : never) | ((...)[(...)] extends (...) | (...)
              ? Extract<(...), (...)>
              : never)> extends "eip1559"
          ? `0x02${string}`
          : never) | (GetTransactionType<request, (request extends LegacyProperties
              ? "legacy"
              : never) | (request extends EIP1559Properties
              ? "eip1559"
              : never) | (request extends EIP2930Properties
              ? "eip2930"
              : never) | (request extends EIP4844Properties
              ? "eip4844"
              : never) | (request extends EIP7702Properties
              ? "eip7702"
              : never) | ((...)[(...)] extends (...) | (...)
              ? Extract<(...), (...)>
              : never)> extends "eip2930"
          ? `0x01${string}`
          : never) | (GetTransactionType<request, (request extends LegacyProperties
              ? "legacy"
              : never) | (request extends EIP1559Properties
              ? "eip1559"
              : never) | (request extends EIP2930Properties
              ? "eip2930"
              : never) | (request extends EIP4844Properties
              ? "eip4844"
              : never) | (request extends EIP7702Properties
              ? "eip7702"
              : never) | ((...)[(...)] extends (...) | (...)
              ? Extract<(...), (...)>
              : never)> extends "eip4844"
          ? `0x03${string}`
          : never) | (GetTransactionType<request, (request extends LegacyProperties
              ? "legacy"
              : never) | (request extends EIP1559Properties
              ? "eip1559"
              : never) | (request extends EIP2930Properties
              ? "eip2930"
              : never) | (request extends EIP4844Properties
              ? "eip4844"
              : never) | (request extends EIP7702Properties
              ? "eip7702"
              : never) | ((...)[(...)] extends (...) | (...)
              ? Extract<(...), (...)>
              : never)> extends "eip7702"
          ? `0x04${string}`
          : never) | (GetTransactionType<request, (request extends LegacyProperties
              ? "legacy"
              : never) | (request extends EIP1559Properties
              ? "eip1559"
              : never) | (request extends EIP2930Properties
              ? "eip2930"
              : never) | (request extends EIP4844Properties
              ? "eip4844"
              : never) | (request extends EIP7702Properties
              ? "eip7702"
              : never) | ((...)[(...)] extends (...) | (...)
              ? Extract<(...), (...)>
              : never)> extends "legacy"
          ? TransactionSerializedLegacy
          : never)>>
      Type Parameters
      chainOverride extends undefined | Chain
      const request extends Omit<{
          data?: `0x${string}`;
          from?: `0x${string}`;
          gas?: bigint;
          nonce?: number;
          to?: null | `0x${string}`;
          type?: "legacy";
          value?: bigint;
          gasPrice?: bigint;
          maxFeePerBlobGas?: undefined;
          maxFeePerGas?: undefined;
          maxPriorityFeePerGas?: undefined;
          blobs: undefined;
          blobVersionedHashes: undefined;
          kzg: undefined;
          accessList: undefined;
          sidecars: undefined;
          authorizationList: undefined;
      }, "from"> | Omit<{
          data?: `0x${string}`;
          from?: `0x${string}`;
          gas?: bigint;
          nonce?: number;
          to?: null | `0x${string}`;
          type?: "eip2930";
          value?: bigint;
          gasPrice?: bigint;
          maxFeePerBlobGas?: undefined;
          maxFeePerGas?: undefined;
          maxPriorityFeePerGas?: undefined;
          accessList?: AccessList;
          blobs: undefined;
          blobVersionedHashes: undefined;
          kzg: undefined;
          sidecars: undefined;
          authorizationList: undefined;
      }, "from"> | Omit<{
          data?: `0x${string}`;
          from?: `0x${string}`;
          gas?: bigint;
          nonce?: number;
          to?: null | `0x${string}`;
          type?: "eip1559";
          value?: bigint;
          gasPrice?: undefined;
          maxFeePerBlobGas?: undefined;
          maxFeePerGas?: bigint;
          maxPriorityFeePerGas?: bigint;
          accessList?: AccessList;
          blobs: undefined;
          blobVersionedHashes: undefined;
          kzg: undefined;
          sidecars: undefined;
          authorizationList: undefined;
      }, "from"> | Omit<{
          from?: `0x${string}`;
          data?: `0x${string}`;
          gas?: bigint;
          nonce?: number;
          type?: "eip4844";
          value?: bigint;
          to: null | `0x${string}`;
          gasPrice?: undefined;
          maxFeePerBlobGas?: bigint;
          maxFeePerGas?: bigint;
          maxPriorityFeePerGas?: bigint;
          accessList?: AccessList;
          sidecars?: readonly BlobSidecar<`0x${string}`>[];
          blobs?: readonly `0x${string}`[] | readonly Uint8Array[];
          blobVersionedHashes: readonly `0x${string}`[];
          kzg: undefined;
          authorizationList: undefined;
      }, "from"> | Omit<{
          from?: `0x${string}`;
          data?: `0x${string}`;
          gas?: bigint;
          nonce?: number;
          type?: "eip4844";
          value?: bigint;
          to: null | `0x${string}`;
          gasPrice?: undefined;
          maxFeePerBlobGas?: bigint;
          maxFeePerGas?: bigint;
          maxPriorityFeePerGas?: bigint;
          accessList?: AccessList;
          sidecars?: readonly BlobSidecar<`0x${string}`>[];
          blobs: readonly `0x${string}`[] | readonly Uint8Array[];
          blobVersionedHashes?: readonly `0x${string}`[];
          kzg?: Kzg;
          authorizationList: undefined;
      }, "from"> | Omit<{
          data?: `0x${string}`;
          from?: `0x${string}`;
          gas?: bigint;
          nonce?: number;
          to?: null | `0x${string}`;
          type?: "eip7702";
          value?: bigint;
          gasPrice?: undefined;
          maxFeePerBlobGas?: undefined;
          maxFeePerGas?: bigint;
          maxPriorityFeePerGas?: bigint;
          accessList?: AccessList;
          authorizationList?: AuthorizationList<number, boolean>;
          blobs: undefined;
          blobVersionedHashes: undefined;
          kzg: undefined;
          sidecars: undefined;
      }, "from"> = UnionOmit<ExtractChainFormatterParameters<DeriveChain<undefined | Chain, chainOverride>, "transactionRequest", TransactionRequest>, "from">
      Parameters
      args: SignTransactionParameters<undefined | Chain, undefined | Account, chainOverride, request>
      SignTransactionParameters
      
      Returns Promise<TransactionSerialized<GetTransactionType<request, (request extends LegacyProperties
          ? "legacy"
          : never) | (request extends EIP1559Properties
          ? "eip1559"
          : never) | (request extends EIP2930Properties
          ? "eip2930"
          : never) | (request extends EIP4844Properties
          ? "eip4844"
          : never) | (request extends EIP7702Properties
          ? "eip7702"
          : never) | (request["type"] extends undefined | string
          ? Extract<any[any], string>
          : never)>, (GetTransactionType<request, (request extends LegacyProperties
              ? "legacy"
              : never) | (request extends EIP1559Properties
              ? "eip1559"
              : never) | (request extends EIP2930Properties
              ? "eip2930"
              : never) | (request extends EIP4844Properties
              ? "eip4844"
              : never) | (request extends EIP7702Properties
              ? "eip7702"
              : never) | ((...)[(...)] extends (...) | (...)
              ? Extract<(...), (...)>
              : never)> extends "eip1559"
          ? `0x02${string}`
          : never) | (GetTransactionType<request, (request extends LegacyProperties
              ? "legacy"
              : never) | (request extends EIP1559Properties
              ? "eip1559"
              : never) | (request extends EIP2930Properties
              ? "eip2930"
              : never) | (request extends EIP4844Properties
              ? "eip4844"
              : never) | (request extends EIP7702Properties
              ? "eip7702"
              : never) | ((...)[(...)] extends (...) | (...)
              ? Extract<(...), (...)>
              : never)> extends "eip2930"
          ? `0x01${string}`
          : never) | (GetTransactionType<request, (request extends LegacyProperties
              ? "legacy"
              : never) | (request extends EIP1559Properties
              ? "eip1559"
              : never) | (request extends EIP2930Properties
              ? "eip2930"
              : never) | (request extends EIP4844Properties
              ? "eip4844"
              : never) | (request extends EIP7702Properties
              ? "eip7702"
              : never) | ((...)[(...)] extends (...) | (...)
              ? Extract<(...), (...)>
              : never)> extends "eip4844"
          ? `0x03${string}`
          : never) | (GetTransactionType<request, (request extends LegacyProperties
              ? "legacy"
              : never) | (request extends EIP1559Properties
              ? "eip1559"
              : never) | (request extends EIP2930Properties
              ? "eip2930"
              : never) | (request extends EIP4844Properties
              ? "eip4844"
              : never) | (request extends EIP7702Properties
              ? "eip7702"
              : never) | ((...)[(...)] extends (...) | (...)
              ? Extract<(...), (...)>
              : never)> extends "eip7702"
          ? `0x04${string}`
          : never) | (GetTransactionType<request, (request extends LegacyProperties
              ? "legacy"
              : never) | (request extends EIP1559Properties
              ? "eip1559"
              : never) | (request extends EIP2930Properties
              ? "eip2930"
              : never) | (request extends EIP4844Properties
              ? "eip4844"
              : never) | (request extends EIP7702Properties
              ? "eip7702"
              : never) | ((...)[(...)] extends (...) | (...)
              ? Extract<(...), (...)>
              : never)> extends "legacy"
          ? TransactionSerializedLegacy
          : never)>>
    - signTypedData: (<const typedData, primaryType>(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 typedData, primaryType>(args): Promise<`0x${string}`>
      Type Parameters
      const typedData extends {
          string: undefined;
          address: undefined;
          bool: undefined;
          bytes: undefined;
          bytes18: undefined;
          bytes1: undefined;
          bytes2: undefined;
          bytes3: undefined;
          bytes4: undefined;
          bytes5: undefined;
          bytes6: undefined;
          bytes7: undefined;
          bytes8: undefined;
          bytes9: undefined;
          bytes10: undefined;
          bytes11: undefined;
          bytes12: undefined;
          bytes13: undefined;
          bytes14: undefined;
          bytes15: undefined;
          bytes16: undefined;
          bytes17: undefined;
          bytes19: undefined;
          bytes20: undefined;
          bytes21: undefined;
          bytes22: undefined;
          bytes23: undefined;
          bytes24: undefined;
          bytes25: undefined;
          bytes26: undefined;
          bytes27: undefined;
          bytes28: undefined;
          bytes29: undefined;
          bytes30: undefined;
          bytes31: undefined;
          bytes32: undefined;
          int8: undefined;
          int16: undefined;
          int24: undefined;
          int32: undefined;
          int40: 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;
          uint8: undefined;
          uint16: undefined;
          uint24: undefined;
          uint32: undefined;
          uint40: 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;
      }
      primaryType extends string
      Parameters
      args: SignTypedDataParameters<typedData, primaryType, 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>
    - waitForCallsStatus: ((parameters) => Promise<{
          id: string;
          chainId: number;
          version: string;
          atomic: boolean;
          capabilities?: {
              [key: string]: any;
          } | {};
          receipts?: WalletCallReceipt<bigint, "success" | "reverted">[];
          statusCode: number;
          status: undefined | "pending" | "success" | "failure";
      }>)
      Waits for the status & receipts of a call bundle that was sent via sendCalls.
      
      Docs: https://viem.sh/docs/actions/wallet/waitForCallsStatus
      
      JSON-RPC Methods: wallet_getCallsStatus
      
      Returns
      Status & receipts of the call bundle. WaitForCallsStatusReturnType
      
      Example
      import { createWalletClient, custom } from 'viem' import { mainnet } from 'viem/chains' const client = createWalletClient({ chain: mainnet, transport: custom(window.ethereum), }) const { receipts, status } = await waitForCallsStatus(client, { id: '0xdeadbeef' })
      
      (parameters): Promise<{
          id: string;
          chainId: number;
          version: string;
          atomic: boolean;
          capabilities?: {
              [key: string]: any;
          } | {};
          receipts?: WalletCallReceipt<bigint, "success" | "reverted">[];
          statusCode: number;
          status: undefined | "pending" | "success" | "failure";
      }>
      Parameters
      parameters: WaitForCallsStatusParameters
      WaitForCallsStatusParameters
      
      Returns Promise<{
          id: string;
          chainId: number;
          version: string;
          atomic: boolean;
          capabilities?: {
              [key: string]: any;
          } | {};
          receipts?: WalletCallReceipt<bigint, "success" | "reverted">[];
          statusCode: number;
          status: undefined | "pending" | "success" | "failure";
      }>
    - 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, chainOverride>(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, chainOverride>(args): Promise<`0x${string}`>
      Type Parameters
      const abi extends Abi | readonly unknown[]
      functionName extends string
      args extends unknown
      chainOverride extends undefined | Chain = undefined
      Parameters
      args: WriteContractParameters<abi, functionName, args, undefined | Chain, undefined | Account, chainOverride>
      WriteContractParameters
      
      Returns Promise<`0x${string}`>
    - writeContractSync: (<const abi, functionName, args, chainOverride>(args) => Promise<TransactionReceipt>)
      Executes a write function on a contract synchronously. Returns the transaction receipt.
      
      Docs: https://viem.sh/docs/contract/writeContract
      
      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 Receipt. WriteContractSyncReturnType
      
      Example
      import { createWalletClient, custom, parseAbi } from 'viem' import { mainnet } from 'viem/chains' const client = createWalletClient({ chain: mainnet, transport: custom(window.ethereum), }) const receipt = await client.writeContractSync({ address: '0xFBA3912Ca04dd458c843e2EE08967fC04f3579c2', abi: parseAbi(['function mint(uint32 tokenId) nonpayable']), functionName: 'mint', args: [69420], })
      
      <const abi, functionName, args, chainOverride>(args): Promise<TransactionReceipt>
      Type Parameters
      const abi extends Abi | readonly unknown[]
      functionName extends string
      args extends unknown
      chainOverride extends undefined | Chain = undefined
      Parameters
      args: WriteContractSyncParameters<abi, functionName, args, undefined | Chain, undefined | Account, chainOverride>
      WriteContractSyncParameters
      
      Returns Promise<TransactionReceipt>
    - 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;
          experimental_blockTag?: 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>>
  - Optional options?: DefaultWriteContractOptions
Returns Promise<undefined | `0x${string}`>
Promise resolving to the transaction hash. If the account is already approved for all, the promise resolves to undefined.
Dev
This function relates with viem dependency Sets approval of all open orders for the specified account on the given chain.

Example
```
import { setApprovalOfOpenOrdersForAll } from '@clober/v2-sdk'
import { mnemonicToAccount } from 'viem/accounts'

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

const hash = await setApprovalOfOpenOrdersForAll({
  chainId: 421614,
  walletClient
})
```
- Defined in src/calls/approval/open-order.ts:32

Function setApprovalOfOpenOrdersForAll

Parameters

chainId: CHAIN_IDS

account: undefined | Account

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

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

cacheTime: number

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

chain: undefined | Chain

Optional experimental_blockTag?: BlockTag

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}`>

fillTransaction: (<chainOverride, accountOverride>(args) => Promise<FillTransactionReturnType<undefined | Chain, chainOverride>>)

Returns

Example

Type Parameters

Parameters

Returns Promise<FillTransactionReturnType<undefined | Chain, chainOverride>>

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

Returns

Example

Returns Promise<GetAddressesReturnType>

getCallsStatus: ((parameters) => Promise<{ id: string; chainId: number; version: string; atomic: boolean; capabilities?: { [key: string]: any; } | {}; receipts?: WalletCallReceipt<bigint, "success" | "reverted">[]; statusCode: number; status: undefined | "pending" | "success" | "failure"; }>)

Returns

Example

Parameters

Returns Promise<{ id: string; chainId: number; version: string; atomic: boolean; capabilities?: { [key: string]: any; } | {}; receipts?: WalletCallReceipt<bigint, "success" | "reverted">[]; statusCode: number; status: undefined | "pending" | "success" | "failure"; }>

Returns

Example

Type Parameters

Parameters

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

Returns

Example

Returns Promise<number>

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

Returns

Example

Returns Promise<GetPermissionsReturnType>

prepareAuthorization: ((parameters) => Promise<PrepareAuthorizationReturnType>)

Returns

Example

Example

Parameters

Returns Promise<PrepareAuthorizationReturnType>

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>

sendCalls: (<const calls, chainOverride>(parameters) => Promise<{ capabilities?: {}; id: string; }>)

Returns

Example

Type Parameters

Parameters

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

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

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

`Optional` experimental_blockTag?: BlockTag

getCallsStatus: ((parameters) => Promise<{
id: string;
chainId: number;
version: string;
atomic: boolean;
capabilities?: {
[key: string]: any;
} | {};
receipts?: WalletCallReceipt<bigint, "success" | "reverted">[];
statusCode: number;
status: undefined | "pending" | "success" | "failure";
}>)

Returns Promise<{
id: string;
chainId: number;
version: string;
atomic: boolean;
capabilities?: {
[key: string]: any;
} | {};
receipts?: WalletCallReceipt<bigint, "success" | "reverted">[];
statusCode: number;
status: undefined | "pending" | "success" | "failure";
}>

sendCalls: (<const calls, chainOverride>(parameters) => Promise<{
capabilities?: {};
id: string;
}>)

Returns Promise<{
capabilities?: {};
id: string;
}>

Returns Promise<{
id: string;
chainId: number;
version: string;
atomic: boolean;
capabilities?: {
[key: string]: any;
} | {};
receipts?: WalletCallReceipt<bigint, "success" | "reverted">[];
statusCode: number;
status: undefined | "pending" | "success" | "failure";
}>