import type { Address } from 'abitype'
import * as Hex from 'ox/Hex'
import { TokenId, TokenRole } from 'ox/tempo'
import type { Account } from '../../accounts/types.js'
import { parseAccount } from '../../accounts/utils/parseAccount.js'
import { estimateContractGas } from '../../actions/public/estimateContractGas.js'
import {
  type MulticallParameters,
  type MulticallReturnType,
  multicall,
} from '../../actions/public/multicall.js'
import {
  type ReadContractReturnType,
  readContract,
} from '../../actions/public/readContract.js'
import {
  type SimulateContractReturnType,
  simulateContract,
} from '../../actions/public/simulateContract.js'
import type {
  WatchContractEventParameters,
  WatchContractEventReturnType,
} from '../../actions/public/watchContractEvent.js'
import { watchContractEvent } from '../../actions/public/watchContractEvent.js'
import * as internal_Token from '../../actions/token/internal.js'
import { sendTransaction } from '../../actions/wallet/sendTransaction.js'
import {
  type SendTransactionSyncParameters,
  sendTransactionSync,
} from '../../actions/wallet/sendTransactionSync.js'
import type { WriteContractReturnType } from '../../actions/wallet/writeContract.js'
import { writeContract } from '../../actions/wallet/writeContract.js'
import { writeContractSync } from '../../actions/wallet/writeContractSync.js'
import type { Client } from '../../clients/createClient.js'
import type { Transport } from '../../clients/transports/createTransport.js'
import { AccountNotFoundError } from '../../errors/account.js'
import type { BaseErrorType } from '../../errors/base.js'
import type { Chain } from '../../types/chain.js'
import type { ExtractAbiItem, GetEventArgs } from '../../types/contract.js'
import type { Log, Log as viem_Log } from '../../types/log.js'
import type { Compute, OneOf, UnionOmit } from '../../types/utils.js'
import { encodeFunctionData } from '../../utils/abi/encodeFunctionData.js'
import { parseEventLogs } from '../../utils/abi/parseEventLogs.js'
import { formatUnits } from '../../utils/unit/formatUnits.js'
import * as Abis from '../Abis.js'
import * as Addresses from '../Addresses.js'
import type {
  GetAccountParameter,
  ReadParameters,
  TokenParameter,
  TokenParameters,
  WriteParameters,
} from '../internal/types.js'
import {
  type CallParameters,
  defineCall,
  findDeclaredToken,
  pickWriteParameters,
  resolveCallParameters,
  resolveToken,
  resolveTokenWithDecimals,
} from '../internal/utils.js'
import type { TransactionReceipt } from '../Transaction.js'

/**
 * Approves a spender to transfer TIP20 tokens on behalf of the caller.
 *
 * @example
 * ```ts
 * import { createClient, http } from 'viem'
 * import { tempo } from 'viem/chains'
 * import { Actions } from 'viem/tempo'
 * import { privateKeyToAccount } from 'viem/accounts'
 *
 * const client = createClient({
 *   account: privateKeyToAccount('0x...'),
 *   chain: tempo.extend({ feeToken: '0x20c0000000000000000000000000000000000001' })
 *   transport: http(),
 * })
 *
 * const result = await Actions.token.approve(client, {
 *   spender: '0x...',
 *   amount: 100n,
 * })
 * ```
 *
 * @param client - Client.
 * @param parameters - Parameters.
 * @returns The transaction hash.
 */
export async function approve<
  chain extends Chain | undefined,
  account extends Account | undefined,
>(
  client: Client<Transport, chain, account>,
  parameters: approve.Parameters<chain, account>,
): Promise<approve.ReturnValue> {
  return approve.inner(writeContract, client, parameters)
}

export namespace approve {
  export type Args = {
    /** Amount of tokens to approve, in base units or formatted decimal form. */
    amount: internal_Token.AmountInput
    /** Address of the spender. */
    spender: Address
  } & TokenParameter
  export type Parameters<
    chain extends Chain | undefined = Chain | undefined,
    account extends Account | undefined = Account | undefined,
  > = WriteParameters<chain, account> & Args
  export type ReturnValue = WriteContractReturnType
  // TODO: exhaustive error type
  export type ErrorType = BaseErrorType

  /** @internal */
  export async function inner<
    action extends typeof writeContract | typeof writeContractSync,
    chain extends Chain | undefined,
    account extends Account | undefined,
  >(
    action: action,
    client: Client<Transport, chain, account>,
    parameters: approve.Parameters<chain, account>,
  ): Promise<ReturnType<action>> {
    return (await action(client, {
      ...parameters,
      ...approve.call(client, parameters as never),
    } as never)) as never
  }

  /**
   * Defines a call to the `approve` function.
   *
   * Can be passed as a parameter to `estimateContractGas`, `simulateContract`,
   * `sendCalls`, `sendTransaction` (`calls`), or `multicall`. The token is
   * selected by `token`, which is either a TIP20 token id or a contract
   * `address`; `amount.decimals` is inferred from the client's declared
   * `tokens` when omitted.
   *
   * @param parameters - Client (optional), followed by the call arguments.
   * @returns The call.
   */
  export function call<chain extends Chain | undefined>(
    ...parameters: CallParameters<Args, Client<Transport, chain>>
  ) {
    const [client, args] = resolveCallParameters(parameters)
    const { amount, spender, token } = args
    const { address, decimals } = resolveToken(client, { token })
    return defineCall({
      address,
      abi: Abis.tip20,
      functionName: 'approve',
      args: [spender, internal_Token.toBaseUnits(amount, decimals)],
    })
  }

  /**
   * Estimates the gas required to approve a spender. `amount.decimals` is
   * inferred from the client's declared `tokens` when omitted.
   *
   * @param client - Client.
   * @param parameters - Parameters.
   * @returns The gas estimate.
   */
  export async function estimateGas<
    chain extends Chain | undefined,
    account extends Account | undefined,
  >(
    client: Client<Transport, chain, account>,
    parameters: approve.Parameters<chain, account>,
  ): Promise<bigint> {
    return estimateContractGas(client, {
      ...pickWriteParameters(parameters as never),
      ...approve.call(client, parameters as never),
    } as never)
  }

  /**
   * Simulates an approval of a spender. `amount.decimals` is inferred from
   * the client's declared `tokens` when omitted.
   *
   * @param client - Client.
   * @param parameters - Parameters.
   * @returns The simulation result and write request.
   */
  export async function simulate<
    chain extends Chain | undefined,
    account extends Account | undefined,
  >(
    client: Client<Transport, chain, account>,
    parameters: approve.Parameters<chain, account>,
  ): Promise<SimulateContractReturnType<typeof Abis.tip20, 'approve'>> {
    return simulateContract(client, {
      ...pickWriteParameters(parameters as never),
      ...approve.call(client, parameters as never),
    } as never) as never
  }

  /**
   * Extracts the `Approval` event from logs.
   *
   * @param logs - The logs.
   * @returns The `Approval` event.
   */
  export function extractEvent(logs: Log[]) {
    const [log] = parseEventLogs({
      abi: Abis.tip20,
      logs,
      eventName: 'Approval',
    })
    if (!log) throw new Error('`Approval` event not found.')
    return log
  }
}

/**
 * Approves a spender to transfer TIP20 tokens on behalf of the caller.
 *
 * @example
 * ```ts
 * import { createClient, http } from 'viem'
 * import { tempo } from 'viem/chains'
 * import { Actions } from 'viem/tempo'
 * import { privateKeyToAccount } from 'viem/accounts'
 *
 * const client = createClient({
 *   account: privateKeyToAccount('0x...'),
 *   chain: tempo.extend({ feeToken: '0x20c0000000000000000000000000000000000001' })
 *   transport: http(),
 * })
 *
 * const result = await Actions.token.approveSync(client, {
 *   spender: '0x...',
 *   amount: 100n,
 * })
 * ```
 *
 * @param client - Client.
 * @param parameters - Parameters.
 * @returns The transaction receipt and event data.
 */
export async function approveSync<
  chain extends Chain | undefined,
  account extends Account | undefined,
>(
  client: Client<Transport, chain, account>,
  parameters: approveSync.Parameters<chain, account>,
): Promise<approveSync.ReturnValue> {
  const { amount, token, throwOnReceiptRevert = true } = parameters
  const { decimals } = resolveToken(client, { token })
  const resolved = internal_Token.resolveAmountDecimals(amount, decimals)
  const receipt = await approve.inner(writeContractSync, client, {
    ...parameters,
    throwOnReceiptRevert,
  } as never)
  if ((receipt as TransactionReceipt).status === 'pending')
    return { receipt } as never
  const { args } = approve.extractEvent(receipt.logs)
  return {
    ...args,
    ...(resolved === undefined
      ? {}
      : { decimals: resolved, formatted: formatUnits(args.amount, resolved) }),
    receipt,
  } as never
}

export namespace approveSync {
  export type Args = approve.Args
  export type Parameters<
    chain extends Chain | undefined = Chain | undefined,
    account extends Account | undefined = Account | undefined,
  > = approve.Parameters<chain, account>
  export type ReturnValue = Compute<
    GetEventArgs<
      typeof Abis.tip20,
      'Approval',
      {
        IndexedOnly: false
        Required: true
      }
    > & {
      /** Token decimals used to derive `formatted`, if known. */
      decimals?: number | undefined
      /** Approved amount formatted with the token's `decimals`, if known. */
      formatted?: string | undefined
      /** Transaction receipt. */
      receipt: TransactionReceipt
    }
  >
  // TODO: exhaustive error type
  export type ErrorType = BaseErrorType
}

/**
 * Burns TIP20 tokens from a blocked address.
 *
 * @example
 * ```ts
 * import { createClient, http } from 'viem'
 * import { tempo } from 'viem/chains'
 * import { Actions } from 'viem/tempo'
 * import { privateKeyToAccount } from 'viem/accounts'
 *
 * const client = createClient({
 *   account: privateKeyToAccount('0x...'),
 *   chain: tempo.extend({ feeToken: '0x20c0000000000000000000000000000000000001' })
 *   transport: http(),
 * })
 *
 * const result = await Actions.token.burnBlocked(client, {
 *   from: '0x...',
 *   amount: 100n,
 *   token: '0x...',
 * })
 * ```
 *
 * @param client - Client.
 * @param parameters - Parameters.
 * @returns The transaction hash.
 */
export async function burnBlocked<
  chain extends Chain | undefined,
  account extends Account | undefined,
>(
  client: Client<Transport, chain, account>,
  parameters: burnBlocked.Parameters<chain, account>,
): Promise<burnBlocked.ReturnValue> {
  return burnBlocked.inner(writeContract, client, parameters)
}

export namespace burnBlocked {
  export type Args = {
    /** Amount of tokens to burn, in base units or formatted decimal form. */
    amount: internal_Token.AmountInput
    /** Address to burn tokens from. */
    from: Address
  } & TokenParameter

  export type Parameters<
    chain extends Chain | undefined = Chain | undefined,
    account extends Account | undefined = Account | undefined,
  > = WriteParameters<chain, account> & Args

  export type ReturnValue = WriteContractReturnType

  // TODO: exhaustive error type
  export type ErrorType = BaseErrorType

  /** @internal */
  export async function inner<
    action extends typeof writeContract | typeof writeContractSync,
    chain extends Chain | undefined,
    account extends Account | undefined,
  >(
    action: action,
    client: Client<Transport, chain, account>,
    parameters: burnBlocked.Parameters<chain, account>,
  ): Promise<ReturnType<action>> {
    const { amount, from, token, ...rest } = parameters
    const call = burnBlocked.call(client, { amount, from, token } as never)
    return (await action(client, {
      ...rest,
      ...call,
    } as never)) as never
  }

  /**
   * Defines a call to the `burnBlocked` function.
   *
   * Can be passed as a parameter to:
   * - [`estimateContractGas`](https://viem.sh/docs/contract/estimateContractGas): estimate the gas cost of the call
   * - [`simulateContract`](https://viem.sh/docs/contract/simulateContract): simulate the call
   * - [`sendCalls`](https://viem.sh/docs/actions/wallet/sendCalls): send multiple calls
   *
   * @example
   * ```ts
   * import { createClient, http, walletActions } from 'viem'
   * import { tempo } from 'viem/chains'
   * import { Actions } from 'viem/tempo'
   *
   * const client = createClient({
   *   chain: tempo.extend({ feeToken: '0x20c0000000000000000000000000000000000001' })
   *   transport: http(),
   * }).extend(walletActions)
   *
   * const { result } = await client.sendCalls({
   *   calls: [
   *     actions.token.burnBlocked.call(client, {
   *       from: '0x20c0...beef',
   *       amount: 100n,
   *       token: '0x20c0...babe',
   *     }),
   *   ]
   * })
   * ```
   *
   * `amount.decimals` is inferred from the client's declared `tokens` when omitted.
   *
   * @param parameters - Client (optional), followed by the call arguments.
   * @returns The call.
   */
  export function call<chain extends Chain | undefined>(
    ...parameters: CallParameters<Args, Client<Transport, chain>>
  ) {
    const [client, args] = resolveCallParameters(parameters)
    const { from, amount, token } = args
    const { address, decimals } = resolveToken(client, { token })
    return defineCall({
      address,
      abi: Abis.tip20,
      functionName: 'burnBlocked',
      args: [from, internal_Token.toBaseUnits(amount, decimals)],
    })
  }

  /**
   * Extracts the event from the logs.
   *
   * @param logs - Logs.
   * @returns The event.
   */
  export function extractEvent(logs: Log[]) {
    const [log] = parseEventLogs({
      abi: Abis.tip20,
      logs,
      eventName: 'BurnBlocked',
    })
    if (!log) throw new Error('`BurnBlocked` event not found.')
    return log
  }
}

/**
 * Burns TIP20 tokens from a blocked address.
 *
 * @example
 * ```ts
 * import { createClient, http } from 'viem'
 * import { tempo } from 'viem/chains'
 * import { Actions } from 'viem/tempo'
 * import { privateKeyToAccount } from 'viem/accounts'
 *
 * const client = createClient({
 *   account: privateKeyToAccount('0x...'),
 *   chain: tempo.extend({ feeToken: '0x20c0000000000000000000000000000000000001' })
 *   transport: http(),
 * })
 *
 * const result = await Actions.token.burnBlockedSync(client, {
 *   from: '0x...',
 *   amount: 100n,
 *   token: '0x...',
 * })
 * ```
 *
 * @param client - Client.
 * @param parameters - Parameters.
 * @returns The transaction receipt and event data.
 */
export async function burnBlockedSync<
  chain extends Chain | undefined,
  account extends Account | undefined,
>(
  client: Client<Transport, chain, account>,
  parameters: burnBlockedSync.Parameters<chain, account>,
): Promise<burnBlockedSync.ReturnValue> {
  const { throwOnReceiptRevert = true, ...rest } = parameters
  const receipt = await burnBlocked.inner(writeContractSync, client, {
    ...rest,
    throwOnReceiptRevert,
  } as never)
  if ((receipt as TransactionReceipt).status === 'pending')
    return { receipt } as never
  const { args } = burnBlocked.extractEvent(receipt.logs)
  return {
    ...args,
    receipt,
  } as never
}

export namespace burnBlockedSync {
  export type Parameters<
    chain extends Chain | undefined = Chain | undefined,
    account extends Account | undefined = Account | undefined,
  > = burnBlocked.Parameters<chain, account>

  export type Args = burnBlocked.Args

  export type ReturnValue = Compute<
    GetEventArgs<
      typeof Abis.tip20,
      'BurnBlocked',
      {
        IndexedOnly: false
        Required: true
      }
    > & {
      /** Transaction receipt. */
      receipt: TransactionReceipt
    }
  >

  // TODO: exhaustive error type
  export type ErrorType = BaseErrorType
}

/**
 * Burns TIP20 tokens from the caller's balance.
 *
 * @example
 * ```ts
 * import { createClient, http } from 'viem'
 * import { tempo } from 'viem/chains'
 * import { Actions } from 'viem/tempo'
 * import { privateKeyToAccount } from 'viem/accounts'
 *
 * const client = createClient({
 *   account: privateKeyToAccount('0x...'),
 *   chain: tempo.extend({ feeToken: '0x20c0000000000000000000000000000000000001' })
 *   transport: http(),
 * })
 *
 * const result = await Actions.token.burn(client, {
 *   amount: 100n,
 *   token: '0x...',
 * })
 * ```
 *
 * @param client - Client.
 * @param parameters - Parameters.
 * @returns The transaction hash.
 */
export async function burn<
  chain extends Chain | undefined,
  account extends Account | undefined,
>(
  client: Client<Transport, chain, account>,
  parameters: burn.Parameters<chain, account>,
): Promise<burn.ReturnValue> {
  return burn.inner(writeContract, client, parameters)
}

export namespace burn {
  export type Args = {
    /** Amount of tokens to burn, in base units or formatted decimal form. */
    amount: internal_Token.AmountInput
    /** Memo to include in the transfer. */
    memo?: Hex.Hex | undefined
  } & TokenParameter

  export type Parameters<
    chain extends Chain | undefined = Chain | undefined,
    account extends Account | undefined = Account | undefined,
  > = WriteParameters<chain, account> & Args

  export type ReturnValue = WriteContractReturnType

  // TODO: exhaustive error type
  export type ErrorType = BaseErrorType

  /** @internal */
  export async function inner<
    action extends typeof writeContract | typeof writeContractSync,
    chain extends Chain | undefined,
    account extends Account | undefined,
  >(
    action: action,
    client: Client<Transport, chain, account>,
    parameters: burn.Parameters<chain, account>,
  ): Promise<ReturnType<action>> {
    const { amount, memo, token, ...rest } = parameters
    const call = burn.call(client, { amount, memo, token } as never)
    return (await action(client, {
      ...rest,
      ...call,
    } as never)) as never
  }

  /**
   * Defines a call to the `burn` or `burnWithMemo` function.
   *
   * Can be passed as a parameter to:
   * - [`estimateContractGas`](https://viem.sh/docs/contract/estimateContractGas): estimate the gas cost of the call
   * - [`simulateContract`](https://viem.sh/docs/contract/simulateContract): simulate the call
   * - [`sendCalls`](https://viem.sh/docs/actions/wallet/sendCalls): send multiple calls
   *
   * @example
   * ```ts
   * import { createClient, http, walletActions } from 'viem'
   * import { tempo } from 'viem/chains'
   * import { Actions } from 'viem/tempo'
   *
   * const client = createClient({
   *   chain: tempo.extend({ feeToken: '0x20c0000000000000000000000000000000000001' })
   *   transport: http(),
   * }).extend(walletActions)
   *
   * const { result } = await client.sendCalls({
   *   calls: [
   *     actions.token.burn.call(client, {
   *       amount: 100n,
   *       token: '0x20c0...babe',
   *     }),
   *   ]
   * })
   * ```
   *
   * `amount.decimals` is inferred from the client's declared `tokens` when omitted.
   *
   * @param parameters - Client (optional), followed by the call arguments.
   * @returns The call.
   */
  export function call<chain extends Chain | undefined>(
    ...parameters: CallParameters<Args, Client<Transport, chain>>
  ) {
    const [client, args] = resolveCallParameters(parameters)
    const { amount, memo, token } = args
    const { address, decimals } = resolveToken(client, { token })
    const value = internal_Token.toBaseUnits(amount, decimals)
    const callArgs = memo
      ? ({
          functionName: 'burnWithMemo',
          args: [value, Hex.padLeft(memo, 32)],
        } as const)
      : ({
          functionName: 'burn',
          args: [value],
        } as const)
    return defineCall({
      address,
      abi: Abis.tip20,
      ...callArgs,
    })
  }

  /**
   * Extracts the event from the logs.
   *
   * @param logs - Logs.
   * @returns The event.
   */
  export function extractEvent(logs: Log[]) {
    const [log] = parseEventLogs({
      abi: Abis.tip20,
      logs,
      eventName: 'Burn',
    })
    if (!log) throw new Error('`Burn` event not found.')
    return log
  }
}

/**
 * Burns TIP20 tokens from the caller's balance.
 *
 * @example
 * ```ts
 * import { createClient, http } from 'viem'
 * import { tempo } from 'viem/chains'
 * import { Actions } from 'viem/tempo'
 * import { privateKeyToAccount } from 'viem/accounts'
 *
 * const client = createClient({
 *   account: privateKeyToAccount('0x...'),
 *   chain: tempo.extend({ feeToken: '0x20c0000000000000000000000000000000000001' })
 *   transport: http(),
 * })
 *
 * const result = await Actions.token.burnSync(client, {
 *   amount: 100n,
 *   token: '0x...',
 * })
 * ```
 *
 * @param client - Client.
 * @param parameters - Parameters.
 * @returns The transaction receipt and event data.
 */
export async function burnSync<
  chain extends Chain | undefined,
  account extends Account | undefined,
>(
  client: Client<Transport, chain, account>,
  parameters: burnSync.Parameters<chain, account>,
): Promise<burnSync.ReturnValue> {
  const { throwOnReceiptRevert = true, ...rest } = parameters
  const receipt = await burn.inner(writeContractSync, client, {
    ...rest,
    throwOnReceiptRevert,
  } as never)
  if ((receipt as TransactionReceipt).status === 'pending')
    return { receipt } as never
  const { args } = burn.extractEvent(receipt.logs)
  return {
    ...args,
    receipt,
  } as never
}

export namespace burnSync {
  export type Parameters<
    chain extends Chain | undefined = Chain | undefined,
    account extends Account | undefined = Account | undefined,
  > = burn.Parameters<chain, account>

  export type Args = burn.Args

  export type ReturnValue = Compute<
    GetEventArgs<
      typeof Abis.tip20,
      'Burn',
      {
        IndexedOnly: false
        Required: true
      }
    > & {
      receipt: TransactionReceipt
    }
  >

  // TODO: exhaustive error type
  export type ErrorType = BaseErrorType
}

/**
 * Changes the transfer policy ID for a TIP20 token.
 *
 * @example
 * ```ts
 * import { createClient, http } from 'viem'
 * import { tempo } from 'viem/chains'
 * import { Actions } from 'viem/tempo'
 * import { privateKeyToAccount } from 'viem/accounts'
 *
 * const client = createClient({
 *   account: privateKeyToAccount('0x...'),
 *   chain: tempo.extend({ feeToken: '0x20c0000000000000000000000000000000000001' })
 *   transport: http(),
 * })
 *
 * const result = await Actions.token.changeTransferPolicy(client, {
 *   token: '0x...',
 *   policyId: 1n,
 * })
 * ```
 *
 * @param client - Client.
 * @param parameters - Parameters.
 * @returns The transaction hash.
 */
export async function changeTransferPolicy<
  chain extends Chain | undefined,
  account extends Account | undefined,
>(
  client: Client<Transport, chain, account>,
  parameters: changeTransferPolicy.Parameters<chain, account>,
): Promise<changeTransferPolicy.ReturnValue> {
  return changeTransferPolicy.inner(writeContract, client, parameters)
}

export namespace changeTransferPolicy {
  export type Parameters<
    chain extends Chain | undefined = Chain | undefined,
    account extends Account | undefined = Account | undefined,
  > = WriteParameters<chain, account> & Args

  export type Args = {
    /** New transfer policy ID. */
    policyId: bigint
    /** Address or ID of the TIP20 token. */
    token: TokenId.TokenIdOrAddress
  }

  export type ReturnValue = WriteContractReturnType

  // TODO: exhaustive error type
  export type ErrorType = BaseErrorType

  /** @internal */
  export async function inner<
    action extends typeof writeContract | typeof writeContractSync,
    chain extends Chain | undefined,
    account extends Account | undefined,
  >(
    action: action,
    client: Client<Transport, chain, account>,
    parameters: changeTransferPolicy.Parameters<chain, account>,
  ): Promise<ReturnType<action>> {
    const { policyId, token, ...rest } = parameters
    const call = changeTransferPolicy.call(client, { policyId, token })
    return (await action(client, {
      ...rest,
      ...call,
    } as never)) as never
  }

  /**
   * Defines a call to the `changeTransferPolicyId` function.
   *
   * Can be passed as a parameter to:
   * - [`estimateContractGas`](https://viem.sh/docs/contract/estimateContractGas): estimate the gas cost of the call
   * - [`simulateContract`](https://viem.sh/docs/contract/simulateContract): simulate the call
   * - [`sendCalls`](https://viem.sh/docs/actions/wallet/sendCalls): send multiple calls
   *
   * @example
   * ```ts
   * import { createClient, http, walletActions } from 'viem'
   * import { tempo } from 'viem/chains'
   * import { Actions } from 'viem/tempo'
   *
   * const client = createClient({
   *   chain: tempo.extend({ feeToken: '0x20c0000000000000000000000000000000000001' })
   *   transport: http(),
   * }).extend(walletActions)
   *
   * const { result } = await client.sendCalls({
   *   calls: [
   *     actions.token.changeTransferPolicy.call(client, {
   *       token: '0x20c0...babe',
   *       policyId: 1n,
   *     }),
   *   ]
   * })
   * ```
   *
   * @param parameters - Client (optional), followed by the call arguments.
   * @returns The call.
   */
  export function call<chain extends Chain | undefined>(
    ...parameters: CallParameters<Args, Client<Transport, chain>>
  ) {
    const [client, args] = resolveCallParameters(parameters)
    const { token, policyId } = args
    return defineCall({
      address: resolveToken(client, { token }).address,
      abi: Abis.tip20,
      functionName: 'changeTransferPolicyId',
      args: [policyId],
    })
  }

  /**
   * Extracts the event from the logs.
   *
   * @param logs - Logs.
   * @returns The event.
   */
  export function extractEvent(logs: Log[]) {
    const [log] = parseEventLogs({
      abi: Abis.tip20,
      logs,
      eventName: 'TransferPolicyUpdate',
    })
    if (!log) throw new Error('`TransferPolicyUpdate` event not found.')
    return log
  }
}

/**
 * Changes the transfer policy ID for a TIP20 token.
 *
 * @example
 * ```ts
 * import { createClient, http } from 'viem'
 * import { tempo } from 'viem/chains'
 * import { Actions } from 'viem/tempo'
 * import { privateKeyToAccount } from 'viem/accounts'
 *
 * const client = createClient({
 *   account: privateKeyToAccount('0x...'),
 *   chain: tempo.extend({ feeToken: '0x20c0000000000000000000000000000000000001' })
 *   transport: http(),
 * })
 *
 * const result = await Actions.token.changeTransferPolicySync(client, {
 *   token: '0x...',
 *   policyId: 1n,
 * })
 * ```
 *
 * @param client - Client.
 * @param parameters - Parameters.
 * @returns The transaction receipt and event data.
 */
export async function changeTransferPolicySync<
  chain extends Chain | undefined,
  account extends Account | undefined,
>(
  client: Client<Transport, chain, account>,
  parameters: changeTransferPolicySync.Parameters<chain, account>,
): Promise<changeTransferPolicySync.ReturnValue> {
  const { throwOnReceiptRevert = true, ...rest } = parameters
  const receipt = await changeTransferPolicy.inner(writeContractSync, client, {
    ...rest,
    throwOnReceiptRevert,
  } as never)
  if ((receipt as TransactionReceipt).status === 'pending')
    return { receipt } as never
  const { args } = changeTransferPolicy.extractEvent(receipt.logs)
  return {
    ...args,
    receipt,
  } as never
}

export namespace changeTransferPolicySync {
  export type Parameters<
    chain extends Chain | undefined = Chain | undefined,
    account extends Account | undefined = Account | undefined,
  > = changeTransferPolicy.Parameters<chain, account>

  export type Args = changeTransferPolicy.Args

  export type ReturnValue = Compute<
    GetEventArgs<
      typeof Abis.tip20,
      'TransferPolicyUpdate',
      {
        IndexedOnly: false
        Required: true
      }
    > & {
      receipt: TransactionReceipt
    }
  >

  // TODO: exhaustive error type
  export type ErrorType = BaseErrorType
}

/**
 * Creates a new TIP20 token.
 *
 * @example
 * ```ts
 * import { createClient, http } from 'viem'
 * import { tempo } from 'viem/chains'
 * import { Actions } from 'viem/tempo'
 * import { privateKeyToAccount } from 'viem/accounts'
 *
 * const client = createClient({
 *   account: privateKeyToAccount('0x...'),
 *   chain: tempo.extend({ feeToken: '0x20c0000000000000000000000000000000000001' })
 *   transport: http(),
 * })
 *
 * const result = await Actions.token.create(client, {
 *   name: 'My Token',
 *   symbol: 'MTK',
 *   currency: 'USD',
 *   logoURI: 'https://example.com/token.svg',
 * })
 * ```
 *
 * @param client - Client.
 * @param parameters - Parameters.
 * @returns The transaction hash.
 */
export async function create<
  chain extends Chain | undefined,
  account extends Account | undefined,
>(
  client: Client<Transport, chain, account>,
  parameters: create.Parameters<chain, account>,
): Promise<create.ReturnValue> {
  return create.inner(writeContract, client, parameters)
}

export namespace create {
  export type Parameters<
    chain extends Chain | undefined = Chain | undefined,
    account extends Account | undefined = Account | undefined,
  > = WriteParameters<chain, account> &
    Omit<Args, 'admin'> &
    (account extends Account
      ? { admin?: Account | Address | undefined }
      : { admin: Account | Address })

  export type Args = {
    /** Admin address. */
    admin: Address
    /** Currency (e.g. "USD"). */
    currency: string
    /** Token name. */
    name: string
    /** Logo URI. Requires a T5-enabled Tempo chain. */
    logoURI?: string | undefined
    /** Quote token. */
    quoteToken?: TokenId.TokenIdOrAddress | undefined
    /** Unique salt. @default Hex.random(32) */
    salt?: Hex.Hex | undefined
    /** Token symbol. */
    symbol: string
  }

  export type ReturnValue = WriteContractReturnType

  // TODO: exhaustive error type
  export type ErrorType = BaseErrorType

  /** @internal */
  export async function inner<
    action extends typeof writeContract | typeof writeContractSync,
    chain extends Chain | undefined,
    account extends Account | undefined,
  >(
    action: action,
    client: Client<Transport, chain, account>,
    parameters: any,
  ): Promise<ReturnType<action>> {
    const {
      account = client.account,
      admin: admin_ = client.account,
      chain = client.chain,
      ...rest
    } = parameters
    const admin = admin_ ? parseAccount(admin_) : undefined
    if (!admin) throw new Error('admin is required.')

    const call = create.call(client, { ...rest, admin: admin.address })

    return (await action(
      client as never,
      {
        ...parameters,
        account,
        chain,
        ...call,
      } as never,
    )) as never
  }

  /**
   * Defines a call to the `createToken` function.
   *
   * Can be passed as a parameter to:
   * - [`estimateContractGas`](https://viem.sh/docs/contract/estimateContractGas): estimate the gas cost of the call
   * - [`simulateContract`](https://viem.sh/docs/contract/simulateContract): simulate the call
   * - [`sendCalls`](https://viem.sh/docs/actions/wallet/sendCalls): send multiple calls
   *
   * @example
   * ```ts
   * import { createClient, http, walletActions } from 'viem'
   * import { tempo } from 'viem/chains'
   * import { Actions } from 'viem/tempo'
   *
   * const client = createClient({
   *   chain: tempo.extend({ feeToken: '0x20c0000000000000000000000000000000000001' })
   *   transport: http(),
   * }).extend(walletActions)
   *
   * const { result } = await client.sendCalls({
   *   calls: [
   *     actions.token.create.call(client, {
   *       name: 'My Token',
   *       symbol: 'MTK',
   *       currency: 'USD',
   *       logoURI: 'https://example.com/token.svg',
   *       admin: '0xfeed...fede',
   *     }),
   *   ]
   * })
   * ```
   *
   * @param parameters - Client (optional), followed by the call arguments.
   * @returns The call.
   */
  export function call<chain extends Chain | undefined>(
    ...parameters: CallParameters<Args, Client<Transport, chain>>
  ) {
    const [client, args] = resolveCallParameters(parameters)
    const {
      name,
      symbol,
      currency,
      logoURI,
      quoteToken = Addresses.pathUsd,
      admin,
      salt = Hex.random(32),
    } = args
    return defineCall({
      address: Addresses.tip20Factory,
      abi: Abis.tip20Factory,
      args:
        typeof logoURI === 'string'
          ? [
              name,
              symbol,
              currency,
              resolveToken(client, { token: quoteToken }).address,
              admin,
              salt,
              logoURI,
            ]
          : [
              name,
              symbol,
              currency,
              resolveToken(client, { token: quoteToken }).address,
              admin,
              salt,
            ],
      functionName: 'createToken',
    })
  }

  /**
   * Extracts the `TokenCreated` event from logs.
   *
   * @param logs - The logs.
   * @returns The `TokenCreated` event.
   */
  export function extractEvent(logs: Log[]) {
    const [log] = parseEventLogs({
      abi: Abis.tip20Factory,
      logs,
      eventName: 'TokenCreated',
      strict: true,
    })
    if (!log) throw new Error('`TokenCreated` event not found.')
    return log
  }
}

/**
 * Creates a new TIP20 token.
 *
 * @example
 * ```ts
 * import { createClient, http } from 'viem'
 * import { tempo } from 'viem/chains'
 * import { Actions } from 'viem/tempo'
 * import { privateKeyToAccount } from 'viem/accounts'
 *
 * const client = createClient({
 *   account: privateKeyToAccount('0x...'),
 *   chain: tempo.extend({ feeToken: '0x20c0000000000000000000000000000000000001' })
 *   transport: http(),
 * })
 *
 * const result = await Actions.token.createSync(client, {
 *   name: 'My Token',
 *   symbol: 'MTK',
 *   currency: 'USD',
 *   logoURI: 'https://example.com/token.svg',
 * })
 * ```
 *
 * @param client - Client.
 * @param parameters - Parameters.
 * @returns The transaction receipt and event data.
 */
export async function createSync<
  chain extends Chain | undefined,
  account extends Account | undefined,
>(
  client: Client<Transport, chain, account>,
  parameters: createSync.Parameters<chain, account>,
): Promise<createSync.ReturnValue> {
  const { throwOnReceiptRevert = true, ...rest } = parameters
  const receipt = await create.inner(writeContractSync, client, {
    ...rest,
    throwOnReceiptRevert,
  } as never)

  if ((receipt as TransactionReceipt).status === 'pending')
    return { receipt } as never

  const { args } = create.extractEvent(receipt.logs)
  const tokenId = TokenId.fromAddress(args.token)

  return {
    ...args,
    receipt,
    tokenId,
  } as never
}

export namespace createSync {
  export type Parameters<
    chain extends Chain | undefined = Chain | undefined,
    account extends Account | undefined = Account | undefined,
  > = create.Parameters<chain, account>

  export type Args = create.Args

  export type ReturnValue = Compute<
    GetEventArgs<
      typeof Abis.tip20Factory,
      'TokenCreated',
      { IndexedOnly: false; Required: true }
    > & {
      /** Token ID. */
      tokenId: TokenId.TokenId
      /** Transaction receipt. */
      receipt: TransactionReceipt
    }
  >

  // TODO: exhaustive error type
  export type ErrorType = BaseErrorType
}

/**
 * Gets TIP20 token allowance.
 *
 * @example
 * ```ts
 * import { createClient, http } from 'viem'
 * import { tempo } from 'viem/chains'
 * import { Actions } from 'viem/tempo'
 * import { privateKeyToAccount } from 'viem/accounts'
 *
 * const client = createClient({
 *   account: privateKeyToAccount('0x...'),
 *   chain: tempo.extend({ feeToken: '0x20c0000000000000000000000000000000000001' })
 *   transport: http(),
 * })
 *
 * const allowance = await Actions.token.getAllowance(client, {
 *   account: '0x...',
 *   spender: '0x...',
 *   token: '0x...',
 * })
 * ```
 *
 * @param client - Client.
 * @param parameters - Parameters.
 * @returns The token allowance, in base units and human-readable form.
 */
export async function getAllowance<chain extends Chain | undefined>(
  client: Client<Transport, chain>,
  parameters: getAllowance.Parameters,
): Promise<getAllowance.ReturnValue> {
  const { account, decimals, spender, token, ...rest } = parameters
  const [amount, { decimals: resolved }] = await Promise.all([
    readContract(client, {
      ...rest,
      ...getAllowance.call(client, { account, spender, token } as never),
    }),
    resolveTokenWithDecimals(client, {
      decimals,
      token,
    }),
  ])
  return internal_Token.toAmount(amount, resolved)
}

export namespace getAllowance {
  export type Args = {
    /** Account that owns the tokens. */
    account: Address
    /** Spender of the tokens. */
    spender: Address
  } & TokenParameters
  export type Parameters = ReadParameters & Args
  export type ReturnValue = internal_Token.Amount

  /**
   * Defines a call to the `allowance` function.
   *
   * Can be passed as a parameter to `multicall`, `simulateContract`, or any
   * other action that accepts a contract call. The token is selected by `token`,
   * which is either a TIP20 token id or a contract address.
   *
   * @param parameters - Client (optional), followed by the call arguments.
   * @returns The call.
   */
  export function call<chain extends Chain | undefined>(
    ...parameters: CallParameters<Args, Client<Transport, chain>>
  ) {
    const [client, args] = resolveCallParameters(parameters)
    return defineCall({
      address: resolveToken(client, args).address,
      abi: Abis.tip20,
      functionName: 'allowance',
      args: [args.account, args.spender],
    })
  }
}

/**
 * Gets TIP20 token balance for an address.
 *
 * @example
 * ```ts
 * import { createClient, http } from 'viem'
 * import { tempo } from 'viem/chains'
 * import { Actions } from 'viem/tempo'
 * import { privateKeyToAccount } from 'viem/accounts'
 *
 * const client = createClient({
 *   account: privateKeyToAccount('0x...'),
 *   chain: tempo.extend({ feeToken: '0x20c0000000000000000000000000000000000001' })
 *   transport: http(),
 * })
 *
 * const balance = await Actions.token.getBalance(client, {
 *   account: '0x...',
 *   token: '0x...',
 * })
 * ```
 *
 * @param client - Client.
 * @param parameters - Parameters.
 * @returns The token balance, in base units and human-readable form.
 */
export async function getBalance<
  chain extends Chain | undefined,
  account extends Account | undefined,
>(
  client: Client<Transport, chain, account>,
  parameters: getBalance.Parameters<account>,
): Promise<getBalance.ReturnValue> {
  const {
    account: account_ = client.account,
    decimals,
    token,
    ...rest
  } = parameters
  if (!account_) throw new AccountNotFoundError()
  const account = parseAccount(account_).address
  const [amount, { decimals: resolved }] = await Promise.all([
    readContract(client, {
      ...rest,
      ...getBalance.call(client, { account, token } as never),
    }),
    resolveTokenWithDecimals(client, {
      decimals,
      token,
    }),
  ])
  return internal_Token.toAmount(amount, resolved)
}

export namespace getBalance {
  export type Args<account extends Account | undefined = Account | undefined> =
    GetAccountParameter<account, Account | Address> & TokenParameters
  export type Parameters<
    account extends Account | undefined = Account | undefined,
  > = Omit<ReadParameters, 'account'> & Args<account>
  export type ReturnValue = internal_Token.Amount

  /**
   * Defines a call to the `balanceOf` function.
   *
   * Can be passed as a parameter to `multicall`, `simulateContract`, or any
   * other action that accepts a contract call. The token is selected by `token`,
   * which is either a TIP20 token id or a contract address.
   *
   * @param parameters - Client (optional), followed by the call arguments.
   * @returns The call.
   */
  export function call<
    chain extends Chain | undefined,
    account extends Account | undefined,
  >(
    ...parameters: CallParameters<
      Args<account>,
      Client<Transport, chain, account>
    >
  ) {
    const [client, args] = resolveCallParameters(parameters)
    const account_ = args.account ?? client?.account
    if (!account_) throw new AccountNotFoundError()
    const account = parseAccount(account_).address
    return defineCall({
      address: resolveToken(client, args).address,
      abi: Abis.tip20,
      functionName: 'balanceOf',
      args: [account],
    })
  }
}

/**
 * Gets TIP20 token metadata including name, symbol, logo URI, currency, decimals, and total supply.
 *
 * @example
 * ```ts
 * import { createClient, http } from 'viem'
 * import { tempo } from 'viem/chains'
 * import { Actions } from 'viem/tempo'
 * import { privateKeyToAccount } from 'viem/accounts'
 *
 * const client = createClient({
 *   account: privateKeyToAccount('0x...'),
 *   chain: tempo.extend({ feeToken: '0x20c0000000000000000000000000000000000001' })
 *   transport: http(),
 * })
 *
 * const metadata = await Actions.token.getMetadata(client, {
 *   token: '0x...',
 * })
 * ```
 *
 * @param client - Client.
 * @param parameters - Parameters.
 * @returns The token metadata.
 */
export async function getMetadata<chain extends Chain | undefined>(
  client: Client<Transport, chain>,
  parameters: getMetadata.Parameters,
): Promise<getMetadata.ReturnValue> {
  const { token, ...rest } = parameters
  const { address } = resolveToken(client, { token })
  const abi = Abis.tip20

  const declared = findDeclaredToken(client, token)
  const overrides = {
    ...(declared?.decimals != null ? { decimals: declared.decimals } : {}),
    ...(declared?.name != null ? { name: declared.name } : {}),
    ...(declared?.symbol != null ? { symbol: declared.symbol } : {}),
  }

  if (TokenId.fromAddress(address) === TokenId.fromAddress(Addresses.pathUsd))
    return readMetadataContracts(client, {
      ...rest,
      contracts: [
        {
          address,
          abi,
          functionName: 'currency',
        },
        {
          address,
          abi,
          functionName: 'decimals',
        },
        {
          address,
          abi,
          functionName: 'logoURI',
        },
        {
          address,
          abi,
          functionName: 'name',
        },
        {
          address,
          abi,
          functionName: 'symbol',
        },
        {
          address,
          abi,
          functionName: 'totalSupply',
        },
      ] as const,
    }).then(([currency, decimals, logoURI, name, symbol, totalSupply]) => ({
      name: unwrapMulticallResult(name),
      symbol: unwrapMulticallResult(symbol),
      currency: unwrapMulticallResult(currency),
      decimals: unwrapMulticallResult(decimals),
      logoURI: unwrapMulticallResult(logoURI, ''),
      totalSupply: unwrapMulticallResult(totalSupply),
      ...overrides,
    }))

  return readMetadataContracts(client, {
    ...rest,
    contracts: [
      {
        address,
        abi,
        functionName: 'currency',
      },
      {
        address,
        abi,
        functionName: 'decimals',
      },
      {
        address,
        abi,
        functionName: 'logoURI',
      },
      {
        address,
        abi,
        functionName: 'quoteToken',
      },
      {
        address,
        abi,
        functionName: 'name',
      },
      {
        address,
        abi,
        functionName: 'paused',
      },
      {
        address,
        abi,
        functionName: 'supplyCap',
      },
      {
        address,
        abi,
        functionName: 'symbol',
      },
      {
        address,
        abi,
        functionName: 'totalSupply',
      },
      {
        address,
        abi,
        functionName: 'transferPolicyId',
      },
    ] as const,
  }).then(
    ([
      currency,
      decimals,
      logoURI,
      quoteToken,
      name,
      paused,
      supplyCap,
      symbol,
      totalSupply,
      transferPolicyId,
    ]) => ({
      name: unwrapMulticallResult(name),
      symbol: unwrapMulticallResult(symbol),
      currency: unwrapMulticallResult(currency),
      decimals: unwrapMulticallResult(decimals),
      logoURI: unwrapMulticallResult(logoURI, ''),
      quoteToken: unwrapMulticallResult(quoteToken),
      totalSupply: unwrapMulticallResult(totalSupply),
      paused: unwrapMulticallResult(paused),
      supplyCap: unwrapMulticallResult(supplyCap),
      transferPolicyId: unwrapMulticallResult(transferPolicyId),
      ...overrides,
    }),
  )
}

async function readMetadataContracts<
  chain extends Chain | undefined,
  const contracts extends readonly unknown[],
>(
  client: Client<Transport, chain>,
  parameters: Pick<
    MulticallParameters<contracts>,
    | 'blockNumber'
    | 'blockOverrides'
    | 'blockTag'
    | 'contracts'
    | 'stateOverride'
  >,
): Promise<MulticallReturnType<contracts>>
async function readMetadataContracts<chain extends Chain | undefined>(
  client: Client<Transport, chain>,
  parameters: Pick<
    MulticallParameters,
    | 'blockNumber'
    | 'blockOverrides'
    | 'blockTag'
    | 'contracts'
    | 'stateOverride'
  >,
): Promise<MulticallReturnType> {
  // Preserve the action's deployless default unless the client overrides it.
  if (client.batch?.multicall === undefined)
    return multicall(client, {
      ...parameters,
      allowFailure: true,
      deployless: true,
    })

  const { contracts, ...rest } = parameters
  const results = await Promise.allSettled(
    contracts.map((contract) =>
      readContract(client, {
        ...rest,
        ...contract,
      }),
    ),
  )
  return results.map((result) =>
    result.status === 'fulfilled'
      ? { result: result.value, status: 'success' }
      : { error: result.reason, status: 'failure' },
  )
}

function unwrapMulticallResult<result>(
  response:
    | { result: result; status: 'success' }
    | { error: unknown; status: 'failure' },
): result
function unwrapMulticallResult<result>(
  response:
    | { result: result; status: 'success' }
    | { error: unknown; status: 'failure' },
  fallback: result,
): result
function unwrapMulticallResult<result>(
  response:
    | { result: result; status: 'success' }
    | { error: unknown; status: 'failure' },
  ...fallback: [] | [result]
) {
  if (response.status === 'failure') {
    if (fallback.length > 0) return fallback[0]
    throw response.error
  }
  return response.result
}

export declare namespace getMetadata {
  export type Parameters = Omit<ReadParameters, 'account'> & TokenParameter

  export type ReturnValue = Compute<{
    /**
     * Currency (e.g. "USD").
     */
    currency: string
    /**
     * Decimals of the token.
     */
    decimals: number
    /**
     * Logo URI of the token. Returns an empty string if unset or unsupported
     * by the active Tempo hardfork.
     */
    logoURI: string
    /**
     * Quote token.
     *
     * Returns `undefined` for the default quote token (`0x20c...0000`).
     */
    quoteToken?: Address | undefined
    /**
     * Name of the token.
     */
    name: string
    /**
     * Whether the token is paused.
     *
     * Returns `undefined` for the default quote token (`0x20c...0000`).
     */
    paused?: boolean | undefined
    /**
     * Supply cap.
     *
     * Returns `undefined` for the default quote token (`0x20c...0000`).
     */
    supplyCap?: bigint | undefined
    /**
     * Symbol of the token.
     */
    symbol: string
    /**
     * Total supply of the token.
     */
    totalSupply: bigint
    /**
     * Transfer policy ID.
     * 0="always-reject", 1="always-allow", >2=custom policy
     *
     * Returns `undefined` for the default quote token (`0x20c...0000`).
     */
    transferPolicyId?: bigint | undefined
  }>
}

/**
 * Gets the total supply of a TIP20 token.
 *
 * @example
 * ```ts
 * import { createClient, http } from 'viem'
 * import { tempo } from 'viem/chains'
 * import { Actions } from 'viem/tempo'
 *
 * const client = createClient({
 *   chain: tempo.extend({ feeToken: '0x20c0000000000000000000000000000000000001' })
 *   transport: http(),
 * })
 *
 * const totalSupply = await Actions.token.getTotalSupply(client, {
 *   token: '0x...',
 * })
 * ```
 *
 * @param client - Client.
 * @param parameters - Parameters.
 * @returns The token total supply, in base units and human-readable form.
 */
export async function getTotalSupply<chain extends Chain | undefined>(
  client: Client<Transport, chain>,
  parameters: getTotalSupply.Parameters,
): Promise<getTotalSupply.ReturnValue> {
  const { decimals, token, ...rest } = parameters
  const [amount, { decimals: resolved }] = await Promise.all([
    readContract(client, {
      ...rest,
      ...getTotalSupply.call(client, { token } as never),
    }),
    resolveTokenWithDecimals(client, {
      decimals,
      token,
    }),
  ])
  return internal_Token.toAmount(amount, resolved)
}

export namespace getTotalSupply {
  export type Args = TokenParameters
  export type Parameters = Omit<ReadParameters, 'account'> & Args
  export type ReturnValue = internal_Token.Amount

  /**
   * Defines a call to the `totalSupply` function.
   *
   * Can be passed as a parameter to `multicall`, `simulateContract`, or any
   * other action that accepts a contract call. The token is selected by `token`,
   * which is either a TIP20 token id or a contract address.
   *
   * @param parameters - Client (optional), followed by the call arguments.
   * @returns The call.
   */
  export function call<chain extends Chain | undefined>(
    ...parameters: CallParameters<Args, Client<Transport, chain>>
  ) {
    const [client, args] = resolveCallParameters(parameters)
    return defineCall({
      address: resolveToken(client, args).address,
      abi: Abis.tip20,
      args: [],
      functionName: 'totalSupply',
    })
  }
}

/**
 * Gets the admin role for a specific role in a TIP20 token.
 *
 * @example
 * ```ts
 * import { createClient, http } from 'viem'
 * import { tempo } from 'viem/chains'
 * import { Actions } from 'viem/tempo'
 *
 * const client = createClient({
 *   chain: tempo.extend({ feeToken: '0x20c0000000000000000000000000000000000001' })
 *   transport: http(),
 * })
 *
 * const adminRole = await Actions.token.getRoleAdmin(client, {
 *   role: 'issuer',
 *   token: '0x...',
 * })
 * ```
 *
 * @param client - Client.
 * @param parameters - Parameters.
 * @returns The admin role hash.
 */
export async function getRoleAdmin<chain extends Chain | undefined>(
  client: Client<Transport, chain>,
  parameters: getRoleAdmin.Parameters,
): Promise<getRoleAdmin.ReturnValue> {
  return readContract(client, {
    ...parameters,
    ...getRoleAdmin.call(client, parameters),
  })
}

export namespace getRoleAdmin {
  export type Parameters = ReadParameters & Args

  export type Args = {
    /** Role to get admin for. */
    role: TokenRole.TokenRole
    /** Address or ID of the TIP20 token. */
    token: TokenId.TokenIdOrAddress
  }

  export type ReturnValue = ReadContractReturnType<
    typeof Abis.tip20,
    'getRoleAdmin',
    never
  >

  /**
   * Defines a call to the `getRoleAdmin` function.
   *
   * @param parameters - Client (optional), followed by the call arguments.
   * @returns The call.
   */
  export function call<chain extends Chain | undefined>(
    ...parameters: CallParameters<Args, Client<Transport, chain>>
  ) {
    const [client, args] = resolveCallParameters(parameters)
    const { role, token } = args
    return defineCall({
      address: resolveToken(client, { token }).address,
      abi: Abis.tip20,
      functionName: 'getRoleAdmin',
      args: [TokenRole.serialize(role)],
    })
  }
}

/**
 * Checks if an account has a specific role for a TIP20 token.
 *
 * @example
 * ```ts
 * import { createClient, http } from 'viem'
 * import { tempo } from 'viem/chains'
 * import { Actions } from 'viem/tempo'
 *
 * const client = createClient({
 *   chain: tempo.extend({ feeToken: '0x20c0000000000000000000000000000000000001' })
 *   transport: http(),
 * })
 *
 * const hasRole = await Actions.token.hasRole(client, {
 *   account: '0x...',
 *   role: 'issuer',
 *   token: '0x...',
 * })
 * ```
 *
 * @param client - Client.
 * @param parameters - Parameters.
 * @returns Whether the account has the role.
 */
export async function hasRole<
  chain extends Chain | undefined,
  account extends Account | undefined,
>(
  client: Client<Transport, chain, account>,
  parameters: hasRole.Parameters<account>,
): Promise<hasRole.ReturnValue> {
  const { account = client.account } = parameters
  const address = account ? parseAccount(account).address : undefined
  if (!address) throw new Error('account is required.')
  return readContract(client, {
    ...parameters,
    ...hasRole.call(client, { ...parameters, account: address }),
  })
}

export namespace hasRole {
  export type Parameters<
    account extends Account | undefined = Account | undefined,
  > = ReadParameters & Omit<Args, 'account'> & GetAccountParameter<account>

  export type Args = {
    /** Account address to check. */
    account: Address
    /** Role to check. */
    role: TokenRole.TokenRole
    /** Address or ID of the TIP20 token. */
    token: TokenId.TokenIdOrAddress
  }

  export type ReturnValue = ReadContractReturnType<
    typeof Abis.tip20,
    'hasRole',
    never
  >

  /**
   * Defines a call to the `hasRole` function.
   *
   * @param parameters - Client (optional), followed by the call arguments.
   * @returns The call.
   */
  export function call<chain extends Chain | undefined>(
    ...parameters: CallParameters<Args, Client<Transport, chain>>
  ) {
    const [client, args] = resolveCallParameters(parameters)
    const { account, role, token } = args
    return defineCall({
      address: resolveToken(client, { token }).address,
      abi: Abis.tip20,
      functionName: 'hasRole',
      args: [account, TokenRole.serialize(role)],
    })
  }
}

/**
 * Grants a role for a TIP20 token.
 *
 * @example
 * ```ts
 * import { createClient, http } from 'viem'
 * import { tempo } from 'viem/chains'
 * import { Actions } from 'viem/tempo'
 * import { privateKeyToAccount } from 'viem/accounts'
 *
 * const client = createClient({
 *   account: privateKeyToAccount('0x...'),
 *   chain: tempo.extend({ feeToken: '0x20c0000000000000000000000000000000000001' })
 *   transport: http(),
 * })
 *
 * const result = await Actions.token.grantRoles(client, {
 *   token: '0x...',
 *   to: '0x...',
 *   roles: ['issuer'],
 * })
 * ```
 *
 * @param client - Client.
 * @param parameters - Parameters.
 * @returns The transaction hash.
 */
export async function grantRoles<
  chain extends Chain | undefined,
  account extends Account | undefined,
>(
  client: Client<Transport, chain, account>,
  parameters: grantRoles.Parameters<chain, account>,
): Promise<grantRoles.ReturnValue> {
  return grantRoles.inner(sendTransaction, client, parameters)
}

export namespace grantRoles {
  export type Parameters<
    chain extends Chain | undefined = Chain | undefined,
    account extends Account | undefined = Account | undefined,
  > = WriteParameters<chain, account> &
    Omit<Args, 'role'> & {
      /** Role to grant. */
      roles: readonly TokenRole.TokenRole[]
    }

  export type Args = {
    /** Role to grant. */
    role: TokenRole.TokenRole
    /** Address or ID of the TIP20 token. */
    token: TokenId.TokenIdOrAddress
    /** Address to grant the role to. */
    to: Address
  }

  export type ReturnValue = WriteContractReturnType

  // TODO: exhaustive error type
  export type ErrorType = BaseErrorType

  /** @internal */
  export async function inner<
    action extends typeof sendTransaction | typeof sendTransactionSync,
    chain extends Chain | undefined,
    account extends Account | undefined,
  >(
    action: action,
    client: Client<Transport, chain, account>,
    parameters: grantRoles.Parameters<chain, account>,
  ): Promise<ReturnType<action>> {
    return (await action(client, {
      ...parameters,
      calls: parameters.roles.map((role) => {
        const call = grantRoles.call(client, { ...parameters, role })
        return {
          ...call,
          data: encodeFunctionData(call),
        }
      }),
    } as never)) as never
  }

  /**
   * Defines a call to the `grantRole` function.
   *
   * Can be passed as a parameter to:
   * - [`estimateContractGas`](https://viem.sh/docs/contract/estimateContractGas): estimate the gas cost of the call
   * - [`simulateContract`](https://viem.sh/docs/contract/simulateContract): simulate the call
   * - [`sendCalls`](https://viem.sh/docs/actions/wallet/sendCalls): send multiple calls
   *
   * @example
   * ```ts
   * import { createClient, http, walletActions } from 'viem'
   * import { tempo } from 'viem/chains'
   * import { Actions } from 'viem/tempo'
   *
   * const client = createClient({
   *   chain: tempo.extend({ feeToken: '0x20c0000000000000000000000000000000000001' })
   *   transport: http(),
   * }).extend(walletActions)
   *
   * const { result } = await client.sendCalls({
   *   calls: [
   *     actions.token.grantRoles.call(client, {
   *       token: '0x20c0...babe',
   *       to: '0x20c0...beef',
   *       role: 'issuer',
   *     }),
   *   ]
   * })
   * ```
   *
   * @param parameters - Client (optional), followed by the call arguments.
   * @returns The call.
   */
  export function call<chain extends Chain | undefined>(
    ...parameters: CallParameters<Args, Client<Transport, chain>>
  ) {
    const [client, args] = resolveCallParameters(parameters)
    const { token, to, role } = args
    const roleHash = TokenRole.serialize(role)
    return defineCall({
      address: resolveToken(client, { token }).address,
      abi: Abis.tip20,
      functionName: 'grantRole',
      args: [roleHash, to],
    })
  }

  /**
   * Extracts the events from the logs.
   *
   * @param logs - Logs.
   * @returns The events.
   */
  export function extractEvents(logs: Log[]) {
    const events = parseEventLogs({
      abi: Abis.tip20,
      logs,
      eventName: 'RoleMembershipUpdated',
    })
    if (events.length === 0)
      throw new Error('`RoleMembershipUpdated` events not found.')
    return events
  }
}

/**
 * Grants a role for a TIP20 token.
 *
 * @example
 * ```ts
 * import { createClient, http } from 'viem'
 * import { tempo } from 'viem/chains'
 * import { Actions } from 'viem/tempo'
 * import { privateKeyToAccount } from 'viem/accounts'
 *
 * const client = createClient({
 *   account: privateKeyToAccount('0x...'),
 *   chain: tempo.extend({ feeToken: '0x20c0000000000000000000000000000000000001' })
 *   transport: http(),
 * })
 *
 * const result = await Actions.token.grantRolesSync(client, {
 *   token: '0x...',
 *   to: '0x...',
 *   roles: ['issuer'],
 * })
 * ```
 *
 * @param client - Client.
 * @param parameters - Parameters.
 * @returns The transaction receipt and event data.
 */
export async function grantRolesSync<
  chain extends Chain | undefined,
  account extends Account | undefined,
>(
  client: Client<Transport, chain, account>,
  parameters: grantRolesSync.Parameters<chain, account>,
): Promise<grantRolesSync.ReturnValue> {
  const { throwOnReceiptRevert = true, ...rest } = parameters
  const receipt = await grantRoles.inner(sendTransactionSync, client, {
    ...rest,
    throwOnReceiptRevert,
  } as never)
  if ((receipt as TransactionReceipt).status === 'pending')
    return { receipt } as never
  const events = grantRoles.extractEvents(receipt.logs)
  const value = events.map((event) => event.args)
  return {
    receipt,
    value,
  }
}

export namespace grantRolesSync {
  export type Parameters<
    chain extends Chain | undefined = Chain | undefined,
    account extends Account | undefined = Account | undefined,
  > = grantRoles.Parameters<chain, account>

  export type Args = grantRoles.Args

  export type ReturnValue = {
    receipt: TransactionReceipt
    value: readonly GetEventArgs<
      typeof Abis.tip20,
      'RoleMembershipUpdated',
      { IndexedOnly: false; Required: true }
    >[]
  }

  // TODO: exhaustive error type
  export type ErrorType = BaseErrorType
}

/**
 * Mints TIP20 tokens to an address.
 *
 * @example
 * ```ts
 * import { createClient, http } from 'viem'
 * import { tempo } from 'viem/chains'
 * import { Actions } from 'viem/tempo'
 * import { privateKeyToAccount } from 'viem/accounts'
 *
 * const client = createClient({
 *   account: privateKeyToAccount('0x...'),
 *   chain: tempo.extend({ feeToken: '0x20c0000000000000000000000000000000000001' })
 *   transport: http(),
 * })
 *
 * const result = await Actions.token.mint(client, {
 *   to: '0x...',
 *   amount: 100n,
 *   token: '0x...',
 * })
 * ```
 *
 * @param client - Client.
 * @param parameters - Parameters.
 * @returns The transaction hash.
 */
export async function mint<
  chain extends Chain | undefined,
  account extends Account | undefined,
>(
  client: Client<Transport, chain, account>,
  parameters: mint.Parameters<chain, account>,
): Promise<mint.ReturnValue> {
  return mint.inner(writeContract, client, parameters)
}

export namespace mint {
  export type Args = {
    /** Amount of tokens to mint, in base units or formatted decimal form. */
    amount: internal_Token.AmountInput
    /** Memo to include in the mint. */
    memo?: Hex.Hex | undefined
    /** Address to mint tokens to. */
    to: Address
  } & TokenParameter

  export type Parameters<
    chain extends Chain | undefined = Chain | undefined,
    account extends Account | undefined = Account | undefined,
  > = WriteParameters<chain, account> & Args

  export type ReturnValue = WriteContractReturnType

  // TODO: exhaustive error type
  export type ErrorType = BaseErrorType

  /** @internal */
  export async function inner<
    action extends typeof writeContract | typeof writeContractSync,
    chain extends Chain | undefined,
    account extends Account | undefined,
  >(
    action: action,
    client: Client<Transport, chain, account>,
    parameters: mint.Parameters<chain, account>,
  ): Promise<ReturnType<action>> {
    const { amount, memo, to, token, ...rest } = parameters
    const call = mint.call(client, { amount, memo, to, token } as never)
    return (await action(client, {
      ...rest,
      ...call,
    } as never)) as never
  }

  /**
   * Defines a call to the `mint` or `mintWithMemo` function.
   *
   * Can be passed as a parameter to:
   * - [`estimateContractGas`](https://viem.sh/docs/contract/estimateContractGas): estimate the gas cost of the call
   * - [`simulateContract`](https://viem.sh/docs/contract/simulateContract): simulate the call
   * - [`sendCalls`](https://viem.sh/docs/actions/wallet/sendCalls): send multiple calls
   *
   * @example
   * ```ts
   * import { createClient, http, walletActions } from 'viem'
   * import { tempo } from 'viem/chains'
   * import { Actions } from 'viem/tempo'
   *
   * const client = createClient({
   *   chain: tempo.extend({ feeToken: '0x20c0000000000000000000000000000000000001' })
   *   transport: http(),
   * }).extend(walletActions)
   *
   * const { result } = await client.sendCalls({
   *   calls: [
   *     actions.token.mint.call(client, {
   *       to: '0x20c0...beef',
   *       amount: 100n,
   *       token: '0x20c0...babe',
   *     }),
   *   ]
   * })
   * ```
   *
   * `amount.decimals` is inferred from the client's declared `tokens` when omitted.
   *
   * @param parameters - Client (optional), followed by the call arguments.
   * @returns The call.
   */
  export function call<chain extends Chain | undefined>(
    ...parameters: CallParameters<Args, Client<Transport, chain>>
  ) {
    const [client, args] = resolveCallParameters(parameters)
    const { to, amount, memo, token } = args
    const { address, decimals } = resolveToken(client, { token })
    const value = internal_Token.toBaseUnits(amount, decimals)
    const callArgs = memo
      ? ({
          functionName: 'mintWithMemo',
          args: [to, value, Hex.padLeft(memo, 32)],
        } as const)
      : ({
          functionName: 'mint',
          args: [to, value],
        } as const)
    return defineCall({
      address,
      abi: Abis.tip20,
      ...callArgs,
    })
  }

  /**
   * Extracts the event from the logs.
   *
   * @param logs - Logs.
   * @returns The event.
   */
  export function extractEvent(logs: Log[]) {
    const [log] = parseEventLogs({
      abi: Abis.tip20,
      logs,
      eventName: 'Mint',
    })
    if (!log) throw new Error('`Mint` event not found.')
    return log
  }
}

/**
 * Mints TIP20 tokens to an address.
 *
 * @example
 * ```ts
 * import { createClient, http } from 'viem'
 * import { tempo } from 'viem/chains'
 * import { Actions } from 'viem/tempo'
 * import { privateKeyToAccount } from 'viem/accounts'
 *
 * const client = createClient({
 *   account: privateKeyToAccount('0x...'),
 *   chain: tempo.extend({ feeToken: '0x20c0000000000000000000000000000000000001' })
 *   transport: http(),
 * })
 *
 * const result = await Actions.token.mintSync(client, {
 *   to: '0x...',
 *   amount: 100n,
 *   token: '0x...',
 * })
 * ```
 *
 * @param client - Client.
 * @param parameters - Parameters.
 * @returns The transaction receipt and event data.
 */
export async function mintSync<
  chain extends Chain | undefined,
  account extends Account | undefined,
>(
  client: Client<Transport, chain, account>,
  parameters: mintSync.Parameters<chain, account>,
): Promise<mintSync.ReturnValue> {
  const { throwOnReceiptRevert = true, ...rest } = parameters
  const receipt = await mint.inner(writeContractSync, client, {
    ...rest,
    throwOnReceiptRevert,
  } as never)
  if ((receipt as TransactionReceipt).status === 'pending')
    return { receipt } as never
  const { args } = mint.extractEvent(receipt.logs)
  return {
    ...args,
    receipt,
  } as never
}

export namespace mintSync {
  export type Parameters<
    chain extends Chain | undefined = Chain | undefined,
    account extends Account | undefined = Account | undefined,
  > = mint.Parameters<chain, account>

  export type Args = mint.Args

  export type ReturnValue = Compute<
    GetEventArgs<
      typeof Abis.tip20,
      'Mint',
      {
        IndexedOnly: false
        Required: true
      }
    > & {
      receipt: TransactionReceipt
    }
  >

  // TODO: exhaustive error type
  export type ErrorType = BaseErrorType
}

/**
 * Pauses a TIP20 token.
 *
 * @example
 * ```ts
 * import { createClient, http } from 'viem'
 * import { tempo } from 'viem/chains'
 * import { Actions } from 'viem/tempo'
 * import { privateKeyToAccount } from 'viem/accounts'
 *
 * const client = createClient({
 *   account: privateKeyToAccount('0x...'),
 *   chain: tempo.extend({ feeToken: '0x20c0000000000000000000000000000000000001' })
 *   transport: http(),
 * })
 *
 * const result = await Actions.token.pause(client, {
 *   token: '0x...',
 * })
 * ```
 *
 * @param client - Client.
 * @param parameters - Parameters.
 * @returns The transaction hash.
 */
export async function pause<
  chain extends Chain | undefined,
  account extends Account | undefined,
>(
  client: Client<Transport, chain, account>,
  parameters: pause.Parameters<chain, account>,
): Promise<pause.ReturnValue> {
  return pause.inner(writeContract, client, parameters)
}

export namespace pause {
  export type Parameters<
    chain extends Chain | undefined = Chain | undefined,
    account extends Account | undefined = Account | undefined,
  > = WriteParameters<chain, account> & Args

  export type Args = {
    /** Address or ID of the TIP20 token. */
    token: TokenId.TokenIdOrAddress
  }

  export type ReturnValue = WriteContractReturnType

  // TODO: exhaustive error type
  export type ErrorType = BaseErrorType

  /** @internal */
  export async function inner<
    action extends typeof writeContract | typeof writeContractSync,
    chain extends Chain | undefined,
    account extends Account | undefined,
  >(
    action: action,
    client: Client<Transport, chain, account>,
    parameters: pause.Parameters<chain, account>,
  ): Promise<ReturnType<action>> {
    const { token, ...rest } = parameters
    const call = pause.call(client, { token })
    return (await action(client, {
      ...rest,
      ...call,
    } as never)) as never
  }

  /**
   * Defines a call to the `pause` function.
   *
   * Can be passed as a parameter to:
   * - [`estimateContractGas`](https://viem.sh/docs/contract/estimateContractGas): estimate the gas cost of the call
   * - [`simulateContract`](https://viem.sh/docs/contract/simulateContract): simulate the call
   * - [`sendCalls`](https://viem.sh/docs/actions/wallet/sendCalls): send multiple calls
   *
   * @example
   * ```ts
   * import { createClient, http, walletActions } from 'viem'
   * import { tempo } from 'viem/chains'
   * import { Actions } from 'viem/tempo'
   *
   * const client = createClient({
   *   chain: tempo.extend({ feeToken: '0x20c0000000000000000000000000000000000001' })
   *   transport: http(),
   * }).extend(walletActions)
   *
   * const { result } = await client.sendCalls({
   *   calls: [
   *     actions.token.pause.call(client, {
   *       token: '0x20c0...babe',
   *     }),
   *   ]
   * })
   * ```
   *
   * @param parameters - Client (optional), followed by the call arguments.
   * @returns The call.
   */
  export function call<chain extends Chain | undefined>(
    ...parameters: CallParameters<Args, Client<Transport, chain>>
  ) {
    const [client, args] = resolveCallParameters(parameters)
    const { token } = args
    return defineCall({
      address: resolveToken(client, { token }).address,
      abi: Abis.tip20,
      functionName: 'pause',
      args: [],
    })
  }

  /**
   * Extracts the event from the logs.
   *
   * @param logs - Logs.
   * @returns The event.
   */
  export function extractEvent(logs: Log[]) {
    const [log] = parseEventLogs({
      abi: Abis.tip20,
      logs,
      eventName: 'PauseStateUpdate',
    })
    if (!log) throw new Error('`PauseStateUpdate` event not found.')
    return log
  }
}

/**
 * Pauses a TIP20 token.
 *
 * @example
 * ```ts
 * import { createClient, http } from 'viem'
 * import { tempo } from 'viem/chains'
 * import { Actions } from 'viem/tempo'
 * import { privateKeyToAccount } from 'viem/accounts'
 *
 * const client = createClient({
 *   account: privateKeyToAccount('0x...'),
 *   chain: tempo.extend({ feeToken: '0x20c0000000000000000000000000000000000001' })
 *   transport: http(),
 * })
 *
 * const result = await Actions.token.pauseSync(client, {
 *   token: '0x...',
 * })
 * ```
 *
 * @param client - Client.
 * @param parameters - Parameters.
 * @returns The transaction receipt and event data.
 */
export async function pauseSync<
  chain extends Chain | undefined,
  account extends Account | undefined,
>(
  client: Client<Transport, chain, account>,
  parameters: pauseSync.Parameters<chain, account>,
): Promise<pauseSync.ReturnValue> {
  const { throwOnReceiptRevert = true, ...rest } = parameters
  const receipt = await pause.inner(writeContractSync, client, {
    ...rest,
    throwOnReceiptRevert,
  } as never)
  if ((receipt as TransactionReceipt).status === 'pending')
    return { receipt } as never
  const { args } = pause.extractEvent(receipt.logs)
  return {
    ...args,
    receipt,
  }
}

export namespace pauseSync {
  export type Parameters<
    chain extends Chain | undefined = Chain | undefined,
    account extends Account | undefined = Account | undefined,
  > = pause.Parameters<chain, account>

  export type Args = pause.Args

  export type ReturnValue = GetEventArgs<
    typeof Abis.tip20,
    'PauseStateUpdate',
    { IndexedOnly: false; Required: true }
  > & {
    receipt: TransactionReceipt
  }

  // TODO: exhaustive error type
  export type ErrorType = BaseErrorType
}

/**
 * Renounces a role for a TIP20 token.
 *
 * @example
 * ```ts
 * import { createClient, http } from 'viem'
 * import { tempo } from 'viem/chains'
 * import { Actions } from 'viem/tempo'
 * import { privateKeyToAccount } from 'viem/accounts'
 *
 * const client = createClient({
 *   account: privateKeyToAccount('0x...'),
 *   chain: tempo.extend({ feeToken: '0x20c0000000000000000000000000000000000001' })
 *   transport: http(),
 * })
 *
 * const result = await Actions.token.renounceRoles(client, {
 *   token: '0x...',
 *   roles: ['issuer'],
 * })
 * ```
 *
 * @param client - Client.
 * @param parameters - Parameters.
 * @returns The transaction hash.
 */
export async function renounceRoles<
  chain extends Chain | undefined,
  account extends Account | undefined,
>(
  client: Client<Transport, chain, account>,
  parameters: renounceRoles.Parameters<chain, account>,
): Promise<renounceRoles.ReturnValue> {
  return renounceRoles.inner(sendTransaction, client, parameters)
}

export namespace renounceRoles {
  export type Parameters<
    chain extends Chain | undefined = Chain | undefined,
    account extends Account | undefined = Account | undefined,
  > = WriteParameters<chain, account> &
    Omit<Args, 'role'> & {
      /** Roles to renounce. */
      roles: readonly TokenRole.TokenRole[]
    }

  export type Args = {
    /** Role to renounce. */
    role: TokenRole.TokenRole
    /** Address or ID of the TIP20 token. */
    token: TokenId.TokenIdOrAddress
  }

  export type ReturnValue = WriteContractReturnType

  // TODO: exhaustive error type
  export type ErrorType = BaseErrorType

  /** @internal */
  export async function inner<
    action extends typeof sendTransaction | typeof sendTransactionSync,
    chain extends Chain | undefined,
    account extends Account | undefined,
  >(
    action: action,
    client: Client<Transport, chain, account>,
    parameters: renounceRoles.Parameters<chain, account>,
  ): Promise<ReturnType<action>> {
    return (await action(client, {
      ...parameters,
      calls: parameters.roles.map((role) => {
        const call = renounceRoles.call(client, { ...parameters, role })
        return {
          ...call,
          data: encodeFunctionData(call),
        }
      }),
    } as never)) as never
  }

  /**
   * Defines a call to the `renounceRole` function.
   *
   * Can be passed as a parameter to:
   * - [`estimateContractGas`](https://viem.sh/docs/contract/estimateContractGas): estimate the gas cost of the call
   * - [`simulateContract`](https://viem.sh/docs/contract/simulateContract): simulate the call
   * - [`sendCalls`](https://viem.sh/docs/actions/wallet/sendCalls): send multiple calls
   *
   * @example
   * ```ts
   * import { createClient, http, walletActions } from 'viem'
   * import { tempo } from 'viem/chains'
   * import { Actions } from 'viem/tempo'
   *
   * const client = createClient({
   *   chain: tempo.extend({ feeToken: '0x20c0000000000000000000000000000000000001' })
   *   transport: http(),
   * }).extend(walletActions)
   *
   * const { result } = await client.sendCalls({
   *   calls: [
   *     actions.token.renounceRoles.call(client, {
   *       token: '0x20c0...babe',
   *       role: 'issuer',
   *     }),
   *   ]
   * })
   * ```
   *
   * @param parameters - Client (optional), followed by the call arguments.
   * @returns The call.
   */
  export function call<chain extends Chain | undefined>(
    ...parameters: CallParameters<Args, Client<Transport, chain>>
  ) {
    const [client, args] = resolveCallParameters(parameters)
    const { token, role } = args
    const roleHash = TokenRole.serialize(role)
    return defineCall({
      address: resolveToken(client, { token }).address,
      abi: Abis.tip20,
      functionName: 'renounceRole',
      args: [roleHash],
    })
  }

  /**
   * Extracts the events from the logs.
   *
   * @param logs - Logs.
   * @returns The events.
   */
  export function extractEvents(logs: Log[]) {
    const events = parseEventLogs({
      abi: Abis.tip20,
      logs,
      eventName: 'RoleMembershipUpdated',
    })
    if (events.length === 0)
      throw new Error('`RoleMembershipUpdated` events not found.')
    return events
  }
}

/**
 * Renounces a role for a TIP20 token.
 *
 * @example
 * ```ts
 * import { createClient, http } from 'viem'
 * import { tempo } from 'viem/chains'
 * import { Actions } from 'viem/tempo'
 * import { privateKeyToAccount } from 'viem/accounts'
 *
 * const client = createClient({
 *   account: privateKeyToAccount('0x...'),
 *   chain: tempo.extend({ feeToken: '0x20c0000000000000000000000000000000000001' })
 *   transport: http(),
 * })
 *
 * const result = await Actions.token.renounceRolesSync(client, {
 *   token: '0x...',
 *   roles: ['issuer'],
 * })
 * ```
 *
 * @param client - Client.
 * @param parameters - Parameters.
 * @returns The transaction receipt and event data.
 */
export async function renounceRolesSync<
  chain extends Chain | undefined,
  account extends Account | undefined,
>(
  client: Client<Transport, chain, account>,
  parameters: renounceRolesSync.Parameters<chain, account>,
): Promise<renounceRolesSync.ReturnValue> {
  const { throwOnReceiptRevert = true, ...rest } = parameters
  const receipt = await renounceRoles.inner(sendTransactionSync, client, {
    ...rest,
    throwOnReceiptRevert,
  } as never)
  if ((receipt as TransactionReceipt).status === 'pending')
    return { receipt } as never
  const events = renounceRoles.extractEvents(receipt.logs)
  const value = events.map((event) => event.args)
  return {
    receipt,
    value,
  }
}

export namespace renounceRolesSync {
  export type Parameters<
    chain extends Chain | undefined = Chain | undefined,
    account extends Account | undefined = Account | undefined,
  > = renounceRoles.Parameters<chain, account>

  export type Args = renounceRoles.Args

  export type ReturnValue = {
    receipt: TransactionReceipt
    value: readonly GetEventArgs<
      typeof Abis.tip20,
      'RoleMembershipUpdated',
      { IndexedOnly: false; Required: true }
    >[]
  }

  // TODO: exhaustive error type
  export type ErrorType = BaseErrorType
}

/**
 * Revokes a role for a TIP20 token.
 *
 * @example
 * ```ts
 * import { createClient, http } from 'viem'
 * import { tempo } from 'viem/chains'
 * import { Actions } from 'viem/tempo'
 * import { privateKeyToAccount } from 'viem/accounts'
 *
 * const client = createClient({
 *   account: privateKeyToAccount('0x...'),
 *   chain: tempo.extend({ feeToken: '0x20c0000000000000000000000000000000000001' })
 *   transport: http(),
 * })
 *
 * const result = await Actions.token.revokeRoles(client, {
 *   token: '0x...',
 *   from: '0x...',
 *   roles: ['issuer'],
 * })
 * ```
 *
 * @param client - Client.
 * @param parameters - Parameters.
 * @returns The transaction hash.
 */
export async function revokeRoles<
  chain extends Chain | undefined,
  account extends Account | undefined,
>(
  client: Client<Transport, chain, account>,
  parameters: revokeRoles.Parameters<chain, account>,
): Promise<revokeRoles.ReturnValue> {
  return revokeRoles.inner(sendTransaction, client, parameters)
}

export namespace revokeRoles {
  export type Parameters<
    chain extends Chain | undefined = Chain | undefined,
    account extends Account | undefined = Account | undefined,
  > = SendTransactionSyncParameters<chain, account> &
    Omit<Args, 'role'> & {
      /** Role to revoke. */
      roles: readonly TokenRole.TokenRole[]
    }

  export type Args = {
    /** Address to revoke the role from. */
    from: Address
    /** Role to revoke. */
    role: TokenRole.TokenRole
    /** Address or ID of the TIP20 token. */
    token: TokenId.TokenIdOrAddress
  }

  export type ReturnValue = WriteContractReturnType

  // TODO: exhaustive error type
  export type ErrorType = BaseErrorType

  /** @internal */
  export async function inner<
    action extends typeof sendTransaction | typeof sendTransactionSync,
    chain extends Chain | undefined,
    account extends Account | undefined,
  >(
    action: action,
    client: Client<Transport, chain, account>,
    parameters: revokeRoles.Parameters<chain, account>,
  ): Promise<ReturnType<action>> {
    const { from: _, ...rest } = parameters
    return (await action(client, {
      ...rest,
      calls: parameters.roles.map((role) => {
        const call = revokeRoles.call(client, { ...parameters, role })
        return {
          ...call,
          data: encodeFunctionData(call),
        }
      }),
    } as never)) as never
  }

  /**
   * Defines a call to the `revokeRole` function.
   *
   * Can be passed as a parameter to:
   * - [`estimateContractGas`](https://viem.sh/docs/contract/estimateContractGas): estimate the gas cost of the call
   * - [`simulateContract`](https://viem.sh/docs/contract/simulateContract): simulate the call
   * - [`sendCalls`](https://viem.sh/docs/actions/wallet/sendCalls): send multiple calls
   *
   * @example
   * ```ts
   * import { createClient, http, walletActions } from 'viem'
   * import { tempo } from 'viem/chains'
   * import { Actions } from 'viem/tempo'
   *
   * const client = createClient({
   *   chain: tempo.extend({ feeToken: '0x20c0000000000000000000000000000000000001' })
   *   transport: http(),
   * }).extend(walletActions)
   *
   * const { result } = await client.sendCalls({
   *   calls: [
   *     actions.token.revokeRoles.call(client, {
   *       token: '0x20c0...babe',
   *       from: '0x20c0...beef',
   *       role: 'issuer',
   *     }),
   *   ]
   * })
   * ```
   *
   * @param parameters - Client (optional), followed by the call arguments.
   * @returns The call.
   */
  export function call<chain extends Chain | undefined>(
    ...parameters: CallParameters<Args, Client<Transport, chain>>
  ) {
    const [client, args] = resolveCallParameters(parameters)
    const { token, from, role } = args
    const roleHash = TokenRole.serialize(role)
    return defineCall({
      address: resolveToken(client, { token }).address,
      abi: Abis.tip20,
      functionName: 'revokeRole',
      args: [roleHash, from],
    })
  }

  /**
   * Extracts the events from the logs.
   *
   * @param logs - Logs.
   * @returns The events.
   */
  export function extractEvents(logs: Log[]) {
    const events = parseEventLogs({
      abi: Abis.tip20,
      logs,
      eventName: 'RoleMembershipUpdated',
    })
    if (events.length === 0)
      throw new Error('`RoleMembershipUpdated` events not found.')
    return events
  }
}

/**
 * Revokes a role for a TIP20 token.
 *
 * @example
 * ```ts
 * import { createClient, http } from 'viem'
 * import { tempo } from 'viem/chains'
 * import { Actions } from 'viem/tempo'
 * import { privateKeyToAccount } from 'viem/accounts'
 *
 * const client = createClient({
 *   account: privateKeyToAccount('0x...'),
 *   chain: tempo.extend({ feeToken: '0x20c0000000000000000000000000000000000001' })
 *   transport: http(),
 * })
 *
 * const result = await Actions.token.revokeRolesSync(client, {
 *   token: '0x...',
 *   from: '0x...',
 *   roles: ['issuer'],
 * })
 * ```
 *
 * @param client - Client.
 * @param parameters - Parameters.
 * @returns The transaction receipt and event data.
 */
export async function revokeRolesSync<
  chain extends Chain | undefined,
  account extends Account | undefined,
>(
  client: Client<Transport, chain, account>,
  parameters: revokeRolesSync.Parameters<chain, account>,
): Promise<revokeRolesSync.ReturnValue> {
  const { throwOnReceiptRevert = true, ...rest } = parameters
  const receipt = await revokeRoles.inner(sendTransactionSync, client, {
    ...rest,
    throwOnReceiptRevert,
  } as never)
  if ((receipt as TransactionReceipt).status === 'pending')
    return { receipt } as never
  const events = revokeRoles.extractEvents(receipt.logs)
  const value = events.map((event) => event.args)
  return {
    receipt,
    value,
  }
}

export namespace revokeRolesSync {
  export type Parameters<
    chain extends Chain | undefined = Chain | undefined,
    account extends Account | undefined = Account | undefined,
  > = revokeRoles.Parameters<chain, account>

  export type Args = revokeRoles.Args

  export type ReturnValue = {
    receipt: TransactionReceipt
    value: readonly GetEventArgs<
      typeof Abis.tip20,
      'RoleMembershipUpdated',
      { IndexedOnly: false; Required: true }
    >[]
  }

  // TODO: exhaustive error type
  export type ErrorType = BaseErrorType
}

/**
 * Sets the supply cap for a TIP20 token.
 *
 * @example
 * ```ts
 * import { createClient, http } from 'viem'
 * import { tempo } from 'viem/chains'
 * import { Actions } from 'viem/tempo'
 * import { privateKeyToAccount } from 'viem/accounts'
 *
 * const client = createClient({
 *   account: privateKeyToAccount('0x...'),
 *   chain: tempo.extend({ feeToken: '0x20c0000000000000000000000000000000000001' })
 *   transport: http(),
 * })
 *
 * const result = await Actions.token.setSupplyCap(client, {
 *   token: '0x...',
 *   supplyCap: 1000000n,
 * })
 * ```
 *
 * @param client - Client.
 * @param parameters - Parameters.
 * @returns The transaction hash.
 */
export async function setSupplyCap<
  chain extends Chain | undefined,
  account extends Account | undefined,
>(
  client: Client<Transport, chain, account>,
  parameters: setSupplyCap.Parameters<chain, account>,
): Promise<setSupplyCap.ReturnValue> {
  return setSupplyCap.inner(writeContract, client, parameters)
}

export namespace setSupplyCap {
  export type Parameters<
    chain extends Chain | undefined = Chain | undefined,
    account extends Account | undefined = Account | undefined,
  > = WriteParameters<chain, account> & Args

  export type Args = {
    /** New supply cap. */
    supplyCap: bigint
    /** Address or ID of the TIP20 token. */
    token: TokenId.TokenIdOrAddress
  }

  export type ReturnValue = WriteContractReturnType

  // TODO: exhaustive error type
  export type ErrorType = BaseErrorType

  /** @internal */
  export async function inner<
    action extends typeof writeContract | typeof writeContractSync,
    chain extends Chain | undefined,
    account extends Account | undefined,
  >(
    action: action,
    client: Client<Transport, chain, account>,
    parameters: setSupplyCap.Parameters<chain, account>,
  ): Promise<ReturnType<action>> {
    const { supplyCap, token, ...rest } = parameters
    const call = setSupplyCap.call(client, { supplyCap, token })
    return (await action(client, {
      ...rest,
      ...call,
    } as never)) as never
  }

  /**
   * Defines a call to the `setSupplyCap` function.
   *
   * Can be passed as a parameter to:
   * - [`estimateContractGas`](https://viem.sh/docs/contract/estimateContractGas): estimate the gas cost of the call
   * - [`simulateContract`](https://viem.sh/docs/contract/simulateContract): simulate the call
   * - [`sendCalls`](https://viem.sh/docs/actions/wallet/sendCalls): send multiple calls
   *
   * @example
   * ```ts
   * import { createClient, http, walletActions } from 'viem'
   * import { tempo } from 'viem/chains'
   * import { Actions } from 'viem/tempo'
   *
   * const client = createClient({
   *   chain: tempo.extend({ feeToken: '0x20c0000000000000000000000000000000000001' })
   *   transport: http(),
   * }).extend(walletActions)
   *
   * const { result } = await client.sendCalls({
   *   calls: [
   *     actions.token.setSupplyCap.call(client, {
   *       token: '0x20c0...babe',
   *       supplyCap: 1000000n,
   *     }),
   *   ]
   * })
   * ```
   *
   * @param parameters - Client (optional), followed by the call arguments.
   * @returns The call.
   */
  export function call<chain extends Chain | undefined>(
    ...parameters: CallParameters<Args, Client<Transport, chain>>
  ) {
    const [client, args] = resolveCallParameters(parameters)
    const { token, supplyCap } = args
    return defineCall({
      address: resolveToken(client, { token }).address,
      abi: Abis.tip20,
      functionName: 'setSupplyCap',
      args: [supplyCap],
    })
  }

  /**
   * Extracts the event from the logs.
   *
   * @param logs - Logs.
   * @returns The event.
   */
  export function extractEvent(logs: Log[]) {
    const [log] = parseEventLogs({
      abi: Abis.tip20,
      logs,
      eventName: 'SupplyCapUpdate',
    })
    if (!log) throw new Error('`SupplyCapUpdate` event not found.')
    return log
  }
}

/**
 * Sets the supply cap for a TIP20 token.
 *
 * @example
 * ```ts
 * import { createClient, http } from 'viem'
 * import { tempo } from 'viem/chains'
 * import { Actions } from 'viem/tempo'
 * import { privateKeyToAccount } from 'viem/accounts'
 *
 * const client = createClient({
 *   account: privateKeyToAccount('0x...'),
 *   chain: tempo.extend({ feeToken: '0x20c0000000000000000000000000000000000001' })
 *   transport: http(),
 * })
 *
 * const result = await Actions.token.setSupplyCapSync(client, {
 *   token: '0x...',
 *   supplyCap: 1000000n,
 * })
 * ```
 *
 * @param client - Client.
 * @param parameters - Parameters.
 * @returns The transaction receipt and event data.
 */
export async function setSupplyCapSync<
  chain extends Chain | undefined,
  account extends Account | undefined,
>(
  client: Client<Transport, chain, account>,
  parameters: setSupplyCapSync.Parameters<chain, account>,
): Promise<setSupplyCapSync.ReturnValue> {
  const { throwOnReceiptRevert = true, ...rest } = parameters
  const receipt = await setSupplyCap.inner(writeContractSync, client, {
    ...rest,
    throwOnReceiptRevert,
  } as never)
  if ((receipt as TransactionReceipt).status === 'pending')
    return { receipt } as never
  const { args } = setSupplyCap.extractEvent(receipt.logs)
  return {
    ...args,
    receipt,
  } as never
}

export namespace setSupplyCapSync {
  export type Parameters<
    chain extends Chain | undefined = Chain | undefined,
    account extends Account | undefined = Account | undefined,
  > = setSupplyCap.Parameters<chain, account>

  export type Args = setSupplyCap.Args

  export type ReturnValue = GetEventArgs<
    typeof Abis.tip20,
    'SupplyCapUpdate',
    { IndexedOnly: false; Required: true }
  > & {
    receipt: TransactionReceipt
  }

  // TODO: exhaustive error type
  export type ErrorType = BaseErrorType
}

/**
 * Sets the admin role for a specific role in a TIP20 token.
 *
 * @example
 * ```ts
 * import { createClient, http } from 'viem'
 * import { tempo } from 'viem/chains'
 * import { Actions } from 'viem/tempo'
 * import { privateKeyToAccount } from 'viem/accounts'
 *
 * const client = createClient({
 *   account: privateKeyToAccount('0x...'),
 *   chain: tempo.extend({ feeToken: '0x20c0000000000000000000000000000000000001' })
 *   transport: http(),
 * })
 *
 * const result = await Actions.token.setRoleAdmin(client, {
 *   token: '0x...',
 *   role: 'issuer',
 *   adminRole: 'admin',
 * })
 * ```
 *
 * @param client - Client.
 * @param parameters - Parameters.
 * @returns The transaction hash.
 */
export async function setRoleAdmin<
  chain extends Chain | undefined,
  account extends Account | undefined,
>(
  client: Client<Transport, chain, account>,
  parameters: setRoleAdmin.Parameters<chain, account>,
): Promise<setRoleAdmin.ReturnValue> {
  return setRoleAdmin.inner(writeContract, client, parameters)
}

export namespace setRoleAdmin {
  export type Parameters<
    chain extends Chain | undefined = Chain | undefined,
    account extends Account | undefined = Account | undefined,
  > = WriteParameters<chain, account> & Args

  export type Args = {
    /** New admin role. */
    adminRole: TokenRole.TokenRole
    /** Role to set admin for. */
    role: TokenRole.TokenRole
    /** Address or ID of the TIP20 token. */
    token: TokenId.TokenIdOrAddress
  }

  export type ReturnValue = WriteContractReturnType

  // TODO: exhaustive error type
  export type ErrorType = BaseErrorType

  /** @internal */
  export async function inner<
    action extends typeof writeContract | typeof writeContractSync,
    chain extends Chain | undefined,
    account extends Account | undefined,
  >(
    action: action,
    client: Client<Transport, chain, account>,
    parameters: setRoleAdmin.Parameters<chain, account>,
  ): Promise<ReturnType<action>> {
    const { adminRole, role, token, ...rest } = parameters
    const call = setRoleAdmin.call(client, { adminRole, role, token })
    return (await action(client, {
      ...rest,
      ...call,
    } as never)) as never
  }

  /**
   * Defines a call to the `setRoleAdmin` function.
   *
   * Can be passed as a parameter to:
   * - [`estimateContractGas`](https://viem.sh/docs/contract/estimateContractGas): estimate the gas cost of the call
   * - [`simulateContract`](https://viem.sh/docs/contract/simulateContract): simulate the call
   * - [`sendCalls`](https://viem.sh/docs/actions/wallet/sendCalls): send multiple calls
   *
   * @example
   * ```ts
   * import { createClient, http, walletActions } from 'viem'
   * import { tempo } from 'viem/chains'
   * import { Actions } from 'viem/tempo'
   *
   * const client = createClient({
   *   chain: tempo.extend({ feeToken: '0x20c0000000000000000000000000000000000001' })
   *   transport: http(),
   * }).extend(walletActions)
   *
   * const { result } = await client.sendCalls({
   *   calls: [
   *     actions.token.setRoleAdmin.call(client, {
   *       token: '0x20c0...babe',
   *       role: 'issuer',
   *       adminRole: 'admin',
   *     }),
   *   ]
   * })
   * ```
   *
   * @param parameters - Client (optional), followed by the call arguments.
   * @returns The call.
   */
  export function call<chain extends Chain | undefined>(
    ...parameters: CallParameters<Args, Client<Transport, chain>>
  ) {
    const [client, args] = resolveCallParameters(parameters)
    const { token, role, adminRole } = args
    const roleHash = TokenRole.serialize(role)
    const adminRoleHash = TokenRole.serialize(adminRole)
    return defineCall({
      address: resolveToken(client, { token }).address,
      abi: Abis.tip20,
      functionName: 'setRoleAdmin',
      args: [roleHash, adminRoleHash],
    })
  }

  /**
   * Extracts the event from the logs.
   *
   * @param logs - Logs.
   * @returns The event.
   */
  export function extractEvent(logs: Log[]) {
    const [log] = parseEventLogs({
      abi: Abis.tip20,
      logs,
      eventName: 'RoleAdminUpdated',
    })
    if (!log) throw new Error('`RoleAdminUpdated` event not found.')
    return log
  }
}

/**
 * Sets the admin role for a specific role in a TIP20 token.
 *
 * @example
 * ```ts
 * import { createClient, http } from 'viem'
 * import { tempo } from 'viem/chains'
 * import { Actions } from 'viem/tempo'
 * import { privateKeyToAccount } from 'viem/accounts'
 *
 * const client = createClient({
 *   account: privateKeyToAccount('0x...'),
 *   chain: tempo.extend({ feeToken: '0x20c0000000000000000000000000000000000001' })
 *   transport: http(),
 * })
 *
 * const result = await Actions.token.setRoleAdminSync(client, {
 *   token: '0x...',
 *   role: 'issuer',
 *   adminRole: 'admin',
 * })
 * ```
 *
 * @param client - Client.
 * @param parameters - Parameters.
 * @returns The transaction receipt and event data.
 */
export async function setRoleAdminSync<
  chain extends Chain | undefined,
  account extends Account | undefined,
>(
  client: Client<Transport, chain, account>,
  parameters: setRoleAdminSync.Parameters<chain, account>,
): Promise<setRoleAdminSync.ReturnValue> {
  const { throwOnReceiptRevert = true, ...rest } = parameters
  const receipt = await setRoleAdmin.inner(writeContractSync, client, {
    ...rest,
    throwOnReceiptRevert,
  } as never)
  if ((receipt as TransactionReceipt).status === 'pending')
    return { receipt } as never
  const { args } = setRoleAdmin.extractEvent(receipt.logs)
  return {
    ...args,
    receipt,
  } as never
}

export namespace setRoleAdminSync {
  export type Parameters<
    chain extends Chain | undefined = Chain | undefined,
    account extends Account | undefined = Account | undefined,
  > = setRoleAdmin.Parameters<chain, account>

  export type Args = setRoleAdmin.Args

  export type ReturnValue = GetEventArgs<
    typeof Abis.tip20,
    'RoleAdminUpdated',
    { IndexedOnly: false; Required: true }
  > & {
    receipt: TransactionReceipt
  }

  // TODO: exhaustive error type
  export type ErrorType = BaseErrorType
}

/**
 * Transfers TIP20 tokens to another address.
 *
 * @example
 * ```ts
 * import { createClient, http } from 'viem'
 * import { tempo } from 'viem/chains'
 * import { Actions } from 'viem/tempo'
 * import { privateKeyToAccount } from 'viem/accounts'
 *
 * const client = createClient({
 *   account: privateKeyToAccount('0x...'),
 *   chain: tempo.extend({ feeToken: '0x20c0000000000000000000000000000000000001' })
 *   transport: http(),
 * })
 *
 * const result = await Actions.token.transfer(client, {
 *   to: '0x...',
 *   amount: 100n,
 * })
 * ```
 *
 * @param client - Client.
 * @param parameters - Parameters.
 * @returns The transaction hash.
 */
export async function transfer<
  chain extends Chain | undefined,
  account extends Account | undefined,
>(
  client: Client<Transport, chain, account>,
  parameters: transfer.Parameters<chain, account>,
): Promise<transfer.ReturnValue> {
  return transfer.inner(writeContract, client, parameters)
}

export namespace transfer {
  export type Args = {
    /** Amount of tokens to transfer, in base units or formatted decimal form. */
    amount: internal_Token.AmountInput
    /** Address to transfer tokens from (uses an allowance via `transferFrom`). */
    from?: Address | undefined
    /** Memo to include in the transfer. */
    memo?: Hex.Hex | undefined
    /** Address to transfer tokens to. */
    to: Address
  } & TokenParameter
  export type Parameters<
    chain extends Chain | undefined = Chain | undefined,
    account extends Account | undefined = Account | undefined,
  > = WriteParameters<chain, account> & Args
  export type ReturnValue = WriteContractReturnType
  // TODO: exhaustive error type
  export type ErrorType = BaseErrorType

  /** @internal */
  export async function inner<
    action extends typeof writeContract | typeof writeContractSync,
    chain extends Chain | undefined,
    account extends Account | undefined,
  >(
    action: action,
    client: Client<Transport, chain, account>,
    parameters: transfer.Parameters<chain, account>,
  ): Promise<ReturnType<action>> {
    return (await action(client, {
      ...parameters,
      ...transfer.call(client, parameters as never),
    } as never)) as never
  }

  /**
   * Defines a call to the `transfer`, `transferFrom`, `transferWithMemo`, or
   * `transferFromWithMemo` function.
   *
   * Can be passed as a parameter to `estimateContractGas`, `simulateContract`,
   * `sendCalls`, `sendTransaction` (`calls`), or `multicall`. The token is
   * selected by `token`, which is either a TIP20 token id or a contract
   * `address`; `amount.decimals` is inferred from the client's declared
   * `tokens` when omitted.
   *
   * @param parameters - Client (optional), followed by the call arguments.
   * @returns The call.
   */
  export function call<chain extends Chain | undefined>(
    ...parameters: CallParameters<Args, Client<Transport, chain>>
  ) {
    const [client, args] = resolveCallParameters(parameters)
    const { from, memo, to, token } = args
    const { address, decimals } = resolveToken(client, { token })
    const value = internal_Token.toBaseUnits(args.amount, decimals)
    const callArgs = (() => {
      if (memo && from)
        return {
          functionName: 'transferFromWithMemo',
          args: [from, to, value, Hex.padLeft(memo, 32)],
        } as const
      if (memo)
        return {
          functionName: 'transferWithMemo',
          args: [to, value, Hex.padLeft(memo, 32)],
        } as const
      if (from)
        return {
          functionName: 'transferFrom',
          args: [from, to, value],
        } as const
      return {
        functionName: 'transfer',
        args: [to, value],
      } as const
    })()
    return defineCall({
      address,
      abi: Abis.tip20,
      ...callArgs,
    })
  }

  /**
   * Estimates the gas required to transfer TIP20 tokens. `amount.decimals` is
   * inferred from the client's declared `tokens` when omitted.
   *
   * @param client - Client.
   * @param parameters - Parameters.
   * @returns The gas estimate.
   */
  export async function estimateGas<
    chain extends Chain | undefined,
    account extends Account | undefined,
  >(
    client: Client<Transport, chain, account>,
    parameters: transfer.Parameters<chain, account>,
  ): Promise<bigint> {
    return estimateContractGas(client, {
      ...pickWriteParameters(parameters as never),
      ...transfer.call(client, parameters as never),
    } as never)
  }

  /**
   * Simulates a transfer of TIP20 tokens. `amount.decimals` is inferred from
   * the client's declared `tokens` when omitted.
   *
   * @param client - Client.
   * @param parameters - Parameters.
   * @returns The simulation result and write request.
   */
  export async function simulate<
    chain extends Chain | undefined,
    account extends Account | undefined,
  >(
    client: Client<Transport, chain, account>,
    parameters: transfer.Parameters<chain, account>,
  ): Promise<
    SimulateContractReturnType<
      typeof Abis.tip20,
      'transfer' | 'transferFrom' | 'transferWithMemo' | 'transferFromWithMemo'
    >
  > {
    return simulateContract(client, {
      ...pickWriteParameters(parameters as never),
      ...transfer.call(client, parameters as never),
    } as never) as never
  }

  /**
   * Extracts the `Transfer` event from logs.
   *
   * @param logs - Logs.
   * @returns The `Transfer` event.
   */
  export function extractEvent(logs: Log[]) {
    const [log] = parseEventLogs({
      abi: Abis.tip20,
      logs,
      eventName: 'Transfer',
    })
    if (!log) throw new Error('`Transfer` event not found.')
    return log
  }
}

/**
 * Transfers TIP20 tokens to another address.
 *
 * @example
 * ```ts
 * import { createClient, http } from 'viem'
 * import { tempo } from 'viem/chains'
 * import { Actions } from 'viem/tempo'
 * import { privateKeyToAccount } from 'viem/accounts'
 *
 * const client = createClient({
 *   account: privateKeyToAccount('0x...'),
 *   chain: tempo.extend({ feeToken: '0x20c0000000000000000000000000000000000001' })
 *   transport: http(),
 * })
 *
 * const result = await Actions.token.transferSync(client, {
 *   to: '0x...',
 *   amount: 100n,
 * })
 * ```
 *
 * @param client - Client.
 * @param parameters - Parameters.
 * @returns The transaction receipt and event data.
 */
export async function transferSync<
  chain extends Chain | undefined,
  account extends Account | undefined,
>(
  client: Client<Transport, chain, account>,
  parameters: transferSync.Parameters<chain, account>,
): Promise<transferSync.ReturnValue> {
  const { amount, token, throwOnReceiptRevert = true } = parameters
  const { decimals } = resolveToken(client, { token })
  const resolved = internal_Token.resolveAmountDecimals(amount, decimals)
  const receipt = await transfer.inner(writeContractSync, client, {
    ...parameters,
    throwOnReceiptRevert,
  } as never)
  if ((receipt as TransactionReceipt).status === 'pending')
    return { receipt } as never
  const { args } = transfer.extractEvent(receipt.logs)
  return {
    ...args,
    ...(resolved === undefined
      ? {}
      : { decimals: resolved, formatted: formatUnits(args.amount, resolved) }),
    receipt,
  } as never
}

export namespace transferSync {
  export type Args = transfer.Args
  export type Parameters<
    chain extends Chain | undefined = Chain | undefined,
    account extends Account | undefined = Account | undefined,
  > = transfer.Parameters<chain, account>
  export type ReturnValue = Compute<
    GetEventArgs<
      typeof Abis.tip20,
      'Transfer',
      { IndexedOnly: false; Required: true }
    > & {
      /** Token decimals used to derive `formatted`, if known. */
      decimals?: number | undefined
      /** Transferred amount formatted with the token's `decimals`, if known. */
      formatted?: string | undefined
      /** Transaction receipt. */
      receipt: TransactionReceipt
    }
  >
  // TODO: exhaustive error type
  export type ErrorType = BaseErrorType
}

/**
 * Unpauses a TIP20 token.
 *
 * @example
 * ```ts
 * import { createClient, http } from 'viem'
 * import { tempo } from 'viem/chains'
 * import { Actions } from 'viem/tempo'
 * import { privateKeyToAccount } from 'viem/accounts'
 *
 * const client = createClient({
 *   account: privateKeyToAccount('0x...'),
 *   chain: tempo.extend({ feeToken: '0x20c0000000000000000000000000000000000001' })
 *   transport: http(),
 * })
 *
 * const result = await Actions.token.unpause(client, {
 *   token: '0x...',
 * })
 * ```
 *
 * @param client - Client.
 * @param parameters - Parameters.
 * @returns The transaction hash.
 */
export async function unpause<
  chain extends Chain | undefined,
  account extends Account | undefined,
>(
  client: Client<Transport, chain, account>,
  parameters: unpause.Parameters<chain, account>,
): Promise<unpause.ReturnValue> {
  return unpause.inner(writeContract, client, parameters)
}

export namespace unpause {
  export type Parameters<
    chain extends Chain | undefined = Chain | undefined,
    account extends Account | undefined = Account | undefined,
  > = WriteParameters<chain, account> & Args

  export type Args = {
    /** Address or ID of the TIP20 token. */
    token: TokenId.TokenIdOrAddress
  }

  export type ReturnValue = WriteContractReturnType

  // TODO: exhaustive error type
  export type ErrorType = BaseErrorType

  /** @internal */
  export async function inner<
    action extends typeof writeContract | typeof writeContractSync,
    chain extends Chain | undefined,
    account extends Account | undefined,
  >(
    action: action,
    client: Client<Transport, chain, account>,
    parameters: unpause.Parameters<chain, account>,
  ): Promise<ReturnType<action>> {
    const { token, ...rest } = parameters
    const call = unpause.call(client, { token })
    return (await action(client, {
      ...rest,
      ...call,
    } as never)) as never
  }

  /**
   * Defines a call to the `unpause` function.
   *
   * Can be passed as a parameter to:
   * - [`estimateContractGas`](https://viem.sh/docs/contract/estimateContractGas): estimate the gas cost of the call
   * - [`simulateContract`](https://viem.sh/docs/contract/simulateContract): simulate the call
   * - [`sendCalls`](https://viem.sh/docs/actions/wallet/sendCalls): send multiple calls
   *
   * @example
   * ```ts
   * import { createClient, http, walletActions } from 'viem'
   * import { tempo } from 'viem/chains'
   * import { Actions } from 'viem/tempo'
   *
   * const client = createClient({
   *   chain: tempo.extend({ feeToken: '0x20c0000000000000000000000000000000000001' })
   *   transport: http(),
   * }).extend(walletActions)
   *
   * const { result } = await client.sendCalls({
   *   calls: [
   *     actions.token.unpause.call(client, {
   *       token: '0x20c0...babe',
   *     }),
   *   ]
   * })
   * ```
   *
   * @param parameters - Client (optional), followed by the call arguments.
   * @returns The call.
   */
  export function call<chain extends Chain | undefined>(
    ...parameters: CallParameters<Args, Client<Transport, chain>>
  ) {
    const [client, args] = resolveCallParameters(parameters)
    const { token } = args
    return defineCall({
      address: resolveToken(client, { token }).address,
      abi: Abis.tip20,
      functionName: 'unpause',
      args: [],
    })
  }

  /**
   * Extracts the event from the logs.
   *
   * @param logs - Logs.
   * @returns The event.
   */
  export function extractEvent(logs: Log[]) {
    const [log] = parseEventLogs({
      abi: Abis.tip20,
      logs,
      eventName: 'PauseStateUpdate',
    })
    if (!log) throw new Error('`PauseStateUpdate` event not found.')
    return log
  }
}

/**
 * Unpauses a TIP20 token.
 *
 * @example
 * ```ts
 * import { createClient, http } from 'viem'
 * import { tempo } from 'viem/chains'
 * import { Actions } from 'viem/tempo'
 * import { privateKeyToAccount } from 'viem/accounts'
 *
 * const client = createClient({
 *   account: privateKeyToAccount('0x...'),
 *   chain: tempo.extend({ feeToken: '0x20c0000000000000000000000000000000000001' })
 *   transport: http(),
 * })
 *
 * const result = await Actions.token.unpauseSync(client, {
 *   token: '0x...',
 * })
 * ```
 *
 * @param client - Client.
 * @param parameters - Parameters.
 * @returns The transaction receipt and event data.
 */
export async function unpauseSync<
  chain extends Chain | undefined,
  account extends Account | undefined,
>(
  client: Client<Transport, chain, account>,
  parameters: unpauseSync.Parameters<chain, account>,
): Promise<unpauseSync.ReturnValue> {
  const { throwOnReceiptRevert = true, ...rest } = parameters
  const receipt = await unpause.inner(writeContractSync, client, {
    ...rest,
    throwOnReceiptRevert,
  } as never)
  if ((receipt as TransactionReceipt).status === 'pending')
    return { receipt } as never
  const { args } = unpause.extractEvent(receipt.logs)
  return {
    ...args,
    receipt,
  } as never
}

export namespace unpauseSync {
  export type Parameters<
    chain extends Chain | undefined = Chain | undefined,
    account extends Account | undefined = Account | undefined,
  > = unpause.Parameters<chain, account>

  export type Args = unpause.Args

  export type ReturnValue = GetEventArgs<
    typeof Abis.tip20,
    'PauseStateUpdate',
    { IndexedOnly: false; Required: true }
  > & {
    receipt: TransactionReceipt
  }

  // TODO: exhaustive error type
  export type ErrorType = BaseErrorType
}

/**
 * Updates the quote token for a TIP20 token.
 *
 * @example
 * ```ts
 * import { createClient, http } from 'viem'
 * import { tempo } from 'viem/chains'
 * import { Actions } from 'viem/tempo'
 * import { privateKeyToAccount } from 'viem/accounts'
 *
 * const client = createClient({
 *   account: privateKeyToAccount('0x...'),
 *   chain: tempo.extend({ feeToken: '0x20c0000000000000000000000000000000000001' })
 *   transport: http(),
 * })
 *
 * const result = await Actions.token.prepareUpdateQuoteToken(client, {
 *   token: '0x...',
 *   quoteToken: '0x...',
 * })
 * ```
 *
 * @param client - Client.
 * @param parameters - Parameters.
 * @returns The transaction hash.
 */
export async function prepareUpdateQuoteToken<
  chain extends Chain | undefined,
  account extends Account | undefined,
>(
  client: Client<Transport, chain, account>,
  parameters: prepareUpdateQuoteToken.Parameters<chain, account>,
): Promise<prepareUpdateQuoteToken.ReturnValue> {
  return prepareUpdateQuoteToken.inner(writeContract, client, parameters)
}

export namespace prepareUpdateQuoteToken {
  export type Parameters<
    chain extends Chain | undefined = Chain | undefined,
    account extends Account | undefined = Account | undefined,
  > = WriteParameters<chain, account> & Args

  export type Args = {
    /** New quote token address. */
    quoteToken: TokenId.TokenIdOrAddress
    /** Address or ID of the TIP20 token. */
    token: TokenId.TokenIdOrAddress
  }

  export type ReturnValue = WriteContractReturnType

  // TODO: exhaustive error type
  export type ErrorType = BaseErrorType

  /** @internal */
  export async function inner<
    action extends typeof writeContract | typeof writeContractSync,
    chain extends Chain | undefined,
    account extends Account | undefined,
  >(
    action: action,
    client: Client<Transport, chain, account>,
    parameters: prepareUpdateQuoteToken.Parameters<chain, account>,
  ): Promise<ReturnType<action>> {
    const { quoteToken, token, ...rest } = parameters
    const call = prepareUpdateQuoteToken.call(client, { quoteToken, token })
    return (await action(client, {
      ...rest,
      ...call,
    } as never)) as never
  }

  /**
   * Defines a call to the `prepareUpdateQuoteToken` function.
   *
   * Can be passed as a parameter to:
   * - [`estimateContractGas`](https://viem.sh/docs/contract/estimateContractGas): estimate the gas cost of the call
   * - [`simulateContract`](https://viem.sh/docs/contract/simulateContract): simulate the call
   * - [`sendCalls`](https://viem.sh/docs/actions/wallet/sendCalls): send multiple calls
   *
   * @example
   * ```ts
   * import { createClient, http, walletActions } from 'viem'
   * import { tempo } from 'viem/chains'
   * import { Actions } from 'viem/tempo'
   *
   * const client = createClient({
   *   chain: tempo.extend({ feeToken: '0x20c0000000000000000000000000000000000001' })
   *   transport: http(),
   * }).extend(walletActions)
   *
   * const { result } = await client.sendCalls({
   *   calls: [
   *     actions.token.prepareUpdateQuoteToken.call(client, {
   *       token: '0x20c0...babe',
   *       quoteToken: '0x20c0...cafe',
   *     }),
   *   ]
   * })
   * ```
   *
   * @param parameters - Client (optional), followed by the call arguments.
   * @returns The call.
   */
  export function call<chain extends Chain | undefined>(
    ...parameters: CallParameters<Args, Client<Transport, chain>>
  ) {
    const [client, args] = resolveCallParameters(parameters)
    const { token, quoteToken } = args
    return defineCall({
      address: resolveToken(client, { token }).address,
      abi: Abis.tip20,
      functionName: 'setNextQuoteToken',
      args: [resolveToken(client, { token: quoteToken }).address],
    })
  }

  /**
   * Extracts the event from the logs.
   *
   * @param logs - Logs.
   * @returns The event.
   */
  export function extractEvent(logs: Log[]) {
    const [log] = parseEventLogs({
      abi: Abis.tip20,
      logs,
      eventName: 'NextQuoteTokenSet',
    })
    if (!log) throw new Error('`NextQuoteTokenSet` event not found.')
    return log
  }
}

/**
 * Updates the quote token for a TIP20 token.
 *
 * @example
 * ```ts
 * import { createClient, http } from 'viem'
 * import { tempo } from 'viem/chains'
 * import { Actions } from 'viem/tempo'
 * import { privateKeyToAccount } from 'viem/accounts'
 *
 * const client = createClient({
 *   account: privateKeyToAccount('0x...'),
 *   chain: tempo.extend({ feeToken: '0x20c0000000000000000000000000000000000001' })
 *   transport: http(),
 * })
 *
 * const result = await Actions.token.prepareUpdateQuoteTokenSync(client, {
 *   token: '0x...',
 *   quoteToken: '0x...',
 * })
 * ```
 *
 * @param client - Client.
 * @param parameters - Parameters.
 * @returns The transaction receipt and event data.
 */
export async function prepareUpdateQuoteTokenSync<
  chain extends Chain | undefined,
  account extends Account | undefined,
>(
  client: Client<Transport, chain, account>,
  parameters: prepareUpdateQuoteTokenSync.Parameters<chain, account>,
): Promise<prepareUpdateQuoteTokenSync.ReturnValue> {
  const receipt = await prepareUpdateQuoteToken.inner(
    writeContractSync,
    client,
    parameters,
  )
  if ((receipt as TransactionReceipt).status === 'pending')
    return { receipt } as never
  const { args } = prepareUpdateQuoteToken.extractEvent(receipt.logs)
  return {
    ...args,
    receipt,
  } as never
}

export namespace prepareUpdateQuoteTokenSync {
  export type Parameters<
    chain extends Chain | undefined = Chain | undefined,
    account extends Account | undefined = Account | undefined,
  > = prepareUpdateQuoteToken.Parameters<chain, account>

  export type Args = prepareUpdateQuoteToken.Args

  export type ReturnValue = Compute<
    GetEventArgs<
      typeof Abis.tip20,
      'NextQuoteTokenSet',
      {
        IndexedOnly: false
        Required: true
      }
    > & {
      receipt: TransactionReceipt
    }
  >

  // TODO: exhaustive error type
  export type ErrorType = BaseErrorType
}

/**
 * Updates the quote token for a TIP20 token.
 *
 * @example
 * ```ts
 * import { createClient, http } from 'viem'
 * import { tempo } from 'viem/chains'
 * import { Actions } from 'viem/tempo'
 * import { privateKeyToAccount } from 'viem/accounts'
 *
 * const client = createClient({
 *   account: privateKeyToAccount('0x...'),
 *   chain: tempo.extend({ feeToken: '0x20c0000000000000000000000000000000000001' })
 *   transport: http(),
 * })
 *
 * const result = await Actions.token.updateQuoteToken(client, {
 *   token: '0x...',
 * })
 * ```
 *
 * @param client - Client.
 * @param parameters - Parameters.
 * @returns The transaction hash.
 */
export async function updateQuoteToken<
  chain extends Chain | undefined,
  account extends Account | undefined,
>(
  client: Client<Transport, chain, account>,
  parameters: updateQuoteToken.Parameters<chain, account>,
): Promise<updateQuoteToken.ReturnValue> {
  return updateQuoteToken.inner(writeContract, client, parameters)
}

export namespace updateQuoteToken {
  export type Parameters<
    chain extends Chain | undefined = Chain | undefined,
    account extends Account | undefined = Account | undefined,
  > = WriteParameters<chain, account> & Args

  export type Args = {
    /** Address or ID of the TIP20 token. */
    token: TokenId.TokenIdOrAddress
  }

  export type ReturnValue = WriteContractReturnType

  // TODO: exhaustive error type
  export type ErrorType = BaseErrorType

  /** @internal */
  export async function inner<
    action extends typeof writeContract | typeof writeContractSync,
    chain extends Chain | undefined,
    account extends Account | undefined,
  >(
    action: action,
    client: Client<Transport, chain, account>,
    parameters: updateQuoteToken.Parameters<chain, account>,
  ): Promise<ReturnType<action>> {
    const { token, ...rest } = parameters
    const call = updateQuoteToken.call(client, { token })
    return (await action(client, {
      ...rest,
      ...call,
    } as never)) as never
  }

  /**
   * Defines a call to the `updateQuoteToken` function.
   *
   * Can be passed as a parameter to:
   * - [`estimateContractGas`](https://viem.sh/docs/contract/estimateContractGas): estimate the gas cost of the call
   * - [`simulateContract`](https://viem.sh/docs/contract/simulateContract): simulate the call
   * - [`sendCalls`](https://viem.sh/docs/actions/wallet/sendCalls): send multiple calls
   *
   * @example
   * ```ts
   * import { createClient, http, walletActions } from 'viem'
   * import { tempo } from 'viem/chains'
   * import { Actions } from 'viem/tempo'
   *
   * const client = createClient({
   *   chain: tempo.extend({ feeToken: '0x20c0000000000000000000000000000000000001' })
   *   transport: http(),
   * }).extend(walletActions)
   *
   * const { result } = await client.sendCalls({
   *   calls: [
   *     actions.token.updateQuoteToken.call(client, {
   *       token: '0x20c0...babe',
   *     }),
   *   ]
   * })
   * ```
   *
   * @param parameters - Client (optional), followed by the call arguments.
   * @returns The call.
   */
  export function call<chain extends Chain | undefined>(
    ...parameters: CallParameters<Args, Client<Transport, chain>>
  ) {
    const [client, args] = resolveCallParameters(parameters)
    const { token } = args
    return defineCall({
      address: resolveToken(client, { token }).address,
      abi: Abis.tip20,
      functionName: 'completeQuoteTokenUpdate',
      args: [],
    })
  }

  /**
   * Extracts the event from the logs.
   *
   * @param logs - Logs.
   * @returns The event.
   */
  export function extractEvent(logs: Log[]) {
    const [log] = parseEventLogs({
      abi: Abis.tip20,
      logs,
      eventName: 'QuoteTokenUpdate',
    })
    if (!log) throw new Error('`QuoteTokenUpdateCompleted` event not found.')
    return log
  }
}

/**
 * Updates the quote token for a TIP20 token.
 *
 * @example
 * ```ts
 * import { createClient, http } from 'viem'
 * import { tempo } from 'viem/chains'
 * import { Actions } from 'viem/tempo'
 * import { privateKeyToAccount } from 'viem/accounts'
 *
 * const client = createClient({
 *   account: privateKeyToAccount('0x...'),
 *   chain: tempo.extend({ feeToken: '0x20c0000000000000000000000000000000000001' })
 *   transport: http(),
 * })
 *
 * const result = await Actions.token.updateQuoteTokenSync(client, {
 *   token: '0x...',
 * })
 * ```
 *
 * @param client - Client.
 * @param parameters - Parameters.
 * @returns The transaction receipt and event data.
 */
export async function updateQuoteTokenSync<
  chain extends Chain | undefined,
  account extends Account | undefined,
>(
  client: Client<Transport, chain, account>,
  parameters: updateQuoteTokenSync.Parameters<chain, account>,
): Promise<updateQuoteTokenSync.ReturnValue> {
  const receipt = await updateQuoteToken.inner(
    writeContractSync,
    client,
    parameters,
  )
  if ((receipt as TransactionReceipt).status === 'pending')
    return { receipt } as never
  const { args } = updateQuoteToken.extractEvent(receipt.logs)
  return {
    ...args,
    receipt,
  } as never
}

export namespace updateQuoteTokenSync {
  export type Parameters<
    chain extends Chain | undefined = Chain | undefined,
    account extends Account | undefined = Account | undefined,
  > = updateQuoteToken.Parameters<chain, account>

  export type Args = updateQuoteToken.Args

  export type ReturnValue = Compute<
    GetEventArgs<
      typeof Abis.tip20,
      'QuoteTokenUpdate',
      {
        IndexedOnly: false
        Required: true
      }
    > & {
      receipt: TransactionReceipt
    }
  >

  // TODO: exhaustive error type
  export type ErrorType = BaseErrorType
}

/**
 * Watches for TIP20 token approval events.
 *
 * @example
 * ```ts
 * import { createClient, http } from 'viem'
 * import { tempo } from 'viem/chains'
 * import { Actions } from 'viem/tempo'
 *
 * const client = createClient({
 *   chain: tempo.extend({ feeToken: '0x20c0000000000000000000000000000000000001' })
 *   transport: http(),
 * })
 *
 * const unwatch = actions.token.watchApprove(client, {
 *   onApproval: (args, log) => {
 *     console.log('Approval:', args)
 *   },
 * })
 * ```
 *
 * @param client - Client.
 * @param parameters - Parameters.
 * @returns A function to unsubscribe from the event.
 */
export function watchApprove<
  chain extends Chain | undefined,
  account extends Account | undefined,
>(
  client: Client<Transport, chain, account>,
  parameters: watchApprove.Parameters,
) {
  const { onApproval, token, ...rest } = parameters
  return watchContractEvent(client, {
    ...rest,
    address: resolveToken(client, { token }).address,
    abi: Abis.tip20,
    eventName: 'Approval',
    onLogs: (logs) => {
      for (const log of logs) onApproval(log.args, log)
    },
    strict: true,
  })
}

export declare namespace watchApprove {
  export type Args = GetEventArgs<
    typeof Abis.tip20,
    'Approval',
    { IndexedOnly: false; Required: true }
  >

  export type Log = viem_Log<
    bigint,
    number,
    false,
    ExtractAbiItem<typeof Abis.tip20, 'Approval'>,
    true
  >

  export type Parameters = UnionOmit<
    WatchContractEventParameters<typeof Abis.tip20, 'Approval', true>,
    'abi' | 'address' | 'batch' | 'eventName' | 'onLogs' | 'strict'
  > & {
    /** Callback to invoke when tokens are approved. */
    onApproval: (args: Args, log: Log) => void
    /** Address or ID of the TIP20 token. */
    token: TokenId.TokenIdOrAddress
  }
}

/**
 * Watches for TIP20 token burn events.
 *
 * @example
 * ```ts
 * import { createClient, http } from 'viem'
 * import { tempo } from 'viem/chains'
 * import { Actions } from 'viem/tempo'
 *
 * const client = createClient({
 *   chain: tempo.extend({ feeToken: '0x20c0000000000000000000000000000000000001' })
 *   transport: http(),
 * })
 *
 * const unwatch = actions.token.watchBurn(client, {
 *   onBurn: (args, log) => {
 *     console.log('Burn:', args)
 *   },
 * })
 * ```
 *
 * @param client - Client.
 * @param parameters - Parameters.
 * @returns A function to unsubscribe from the event.
 */
export function watchBurn<
  chain extends Chain | undefined,
  account extends Account | undefined,
>(client: Client<Transport, chain, account>, parameters: watchBurn.Parameters) {
  const { onBurn, token, ...rest } = parameters
  return watchContractEvent(client, {
    ...rest,
    address: resolveToken(client, { token }).address,
    abi: Abis.tip20,
    eventName: 'Burn',
    onLogs: (logs) => {
      for (const log of logs) onBurn(log.args, log)
    },
    strict: true,
  })
}

export declare namespace watchBurn {
  export type Args = GetEventArgs<
    typeof Abis.tip20,
    'Burn',
    { IndexedOnly: false; Required: true }
  >

  export type Log = viem_Log<
    bigint,
    number,
    false,
    ExtractAbiItem<typeof Abis.tip20, 'Burn'>,
    true
  >

  export type Parameters = UnionOmit<
    WatchContractEventParameters<typeof Abis.tip20, 'Burn', true>,
    'abi' | 'address' | 'batch' | 'eventName' | 'onLogs' | 'strict'
  > & {
    /** Callback to invoke when tokens are burned. */
    onBurn: (args: Args, log: Log) => void
    /** Address or ID of the TIP20 token. */
    token: TokenId.TokenIdOrAddress
  }
}

/**
 * Watches for new TIP20 tokens created.
 *
 * @example
 * ```ts
 * import { createClient, http } from 'viem'
 * import { tempo } from 'viem/chains'
 * import { Actions } from 'viem/tempo'
 *
 * const client = createClient({
 *   chain: tempo.extend({ feeToken: '0x20c0000000000000000000000000000000000001' })
 *   transport: http(),
 * })
 *
 * const unwatch = actions.token.watchCreate(client, {
 *   onTokenCreated: (args, log) => {
 *     console.log('Token created:', args)
 *   },
 * })
 * ```
 *
 * @param client - Client.
 * @param parameters - Parameters.
 * @returns A function to unsubscribe from the event.
 */
export function watchCreate<
  chain extends Chain | undefined,
  account extends Account | undefined,
>(
  client: Client<Transport, chain, account>,
  parameters: watchCreate.Parameters,
) {
  const { onTokenCreated, ...rest } = parameters
  return watchContractEvent(client, {
    ...rest,
    address: Addresses.tip20Factory,
    abi: Abis.tip20Factory,
    eventName: 'TokenCreated',
    onLogs: (logs) => {
      for (const log of logs) onTokenCreated(log.args, log)
    },
    strict: true,
  })
}

export declare namespace watchCreate {
  export type Args = GetEventArgs<
    typeof Abis.tip20Factory,
    'TokenCreated',
    { IndexedOnly: false; Required: true }
  >

  export type Log = viem_Log<
    bigint,
    number,
    false,
    ExtractAbiItem<typeof Abis.tip20Factory, 'TokenCreated'>,
    true
  >

  export type Parameters = UnionOmit<
    WatchContractEventParameters<
      typeof Abis.tip20Factory,
      'TokenCreated',
      true
    >,
    'abi' | 'address' | 'batch' | 'eventName' | 'onLogs' | 'strict'
  > & {
    /** Callback to invoke when a new TIP20 token is created. */
    onTokenCreated: (args: Args, log: Log) => void
  }
}

/**
 * Watches for TIP20 token mint events.
 *
 * @example
 * ```ts
 * import { createClient, http } from 'viem'
 * import { tempo } from 'viem/chains'
 * import { Actions } from 'viem/tempo'
 *
 * const client = createClient({
 *   chain: tempo.extend({ feeToken: '0x20c0000000000000000000000000000000000001' })
 *   transport: http(),
 * })
 *
 * const unwatch = actions.token.watchMint(client, {
 *   onMint: (args, log) => {
 *     console.log('Mint:', args)
 *   },
 * })
 * ```
 *
 * @param client - Client.
 * @param parameters - Parameters.
 * @returns A function to unsubscribe from the event.
 */
export function watchMint<
  chain extends Chain | undefined,
  account extends Account | undefined,
>(client: Client<Transport, chain, account>, parameters: watchMint.Parameters) {
  const { onMint, token, ...rest } = parameters
  return watchContractEvent(client, {
    ...rest,
    address: resolveToken(client, { token }).address,
    abi: Abis.tip20,
    eventName: 'Mint',
    onLogs: (logs) => {
      for (const log of logs) onMint(log.args, log)
    },
    strict: true,
  })
}

export declare namespace watchMint {
  export type Args = GetEventArgs<
    typeof Abis.tip20,
    'Mint',
    { IndexedOnly: false; Required: true }
  >

  export type Log = viem_Log<
    bigint,
    number,
    false,
    ExtractAbiItem<typeof Abis.tip20, 'Mint'>,
    true
  >

  export type Parameters = UnionOmit<
    WatchContractEventParameters<typeof Abis.tip20, 'Mint', true>,
    'abi' | 'address' | 'batch' | 'eventName' | 'onLogs' | 'strict'
  > & {
    /** Callback to invoke when tokens are minted. */
    onMint: (args: Args, log: Log) => void
    /** Address or ID of the TIP20 token. */
    token: TokenId.TokenIdOrAddress
  }

  export type ReturnValue = WatchContractEventReturnType
}

/**
 * Watches for TIP20 token role admin updates.
 *
 * @example
 * ```ts
 * import { createClient, http } from 'viem'
 * import { tempo } from 'viem/chains'
 * import { Actions } from 'viem/tempo'
 *
 * const client = createClient({
 *   chain: tempo.extend({ feeToken: '0x20c0000000000000000000000000000000000001' })
 *   transport: http(),
 * })
 *
 * const unwatch = actions.token.watchAdminRole(client, {
 *   onRoleAdminUpdated: (args, log) => {
 *     console.log('Role admin updated:', args)
 *   },
 * })
 * ```
 *
 * @param client - Client.
 * @param parameters - Parameters.
 * @returns A function to unsubscribe from the event.
 */
export function watchAdminRole<
  chain extends Chain | undefined,
  account extends Account | undefined,
>(
  client: Client<Transport, chain, account>,
  parameters: watchAdminRole.Parameters,
) {
  const { onRoleAdminUpdated, token, ...rest } = parameters
  return watchContractEvent(client, {
    ...rest,
    address: resolveToken(client, { token }).address,
    abi: Abis.tip20,
    eventName: 'RoleAdminUpdated',
    onLogs: (logs) => {
      for (const log of logs) onRoleAdminUpdated(log.args, log)
    },
    strict: true,
  })
}

export declare namespace watchAdminRole {
  export type Args = GetEventArgs<
    typeof Abis.tip20,
    'RoleAdminUpdated',
    { IndexedOnly: false; Required: true }
  >

  export type Log = viem_Log<
    bigint,
    number,
    false,
    ExtractAbiItem<typeof Abis.tip20, 'RoleAdminUpdated'>,
    true
  >

  export type Parameters = UnionOmit<
    WatchContractEventParameters<typeof Abis.tip20, 'RoleAdminUpdated', true>,
    'abi' | 'address' | 'batch' | 'eventName' | 'onLogs' | 'strict'
  > & {
    /** Callback to invoke when a role admin is updated. */
    onRoleAdminUpdated: (args: Args, log: Log) => void
    /** Address or ID of the TIP20 token. */
    token: TokenId.TokenIdOrAddress
  }
}

/**
 * Watches for TIP20 token role membership updates.
 *
 * @example
 * ```ts
 * import { createClient, http } from 'viem'
 * import { tempo } from 'viem/chains'
 * import { Actions } from 'viem/tempo'
 *
 * const client = createClient({
 *   chain: tempo.extend({ feeToken: '0x20c0000000000000000000000000000000000001' })
 *   transport: http(),
 * })
 *
 * const unwatch = actions.token.watchRole(client, {
 *   onRoleUpdated: (args, log) => {
 *     console.log('Role updated:', args)
 *   },
 * })
 * ```
 *
 * @param client - Client.
 * @param parameters - Parameters.
 * @returns A function to unsubscribe from the event.
 */
export function watchRole<
  chain extends Chain | undefined,
  account extends Account | undefined,
>(client: Client<Transport, chain, account>, parameters: watchRole.Parameters) {
  const { onRoleUpdated, token, ...rest } = parameters
  return watchContractEvent(client, {
    ...rest,
    address: resolveToken(client, { token }).address,
    abi: Abis.tip20,
    eventName: 'RoleMembershipUpdated',
    onLogs: (logs) => {
      for (const log of logs) {
        const type = log.args.hasRole ? 'granted' : 'revoked'
        onRoleUpdated({ ...log.args, type }, log)
      }
    },
    strict: true,
  })
}

export declare namespace watchRole {
  export type Args = GetEventArgs<
    typeof Abis.tip20,
    'RoleMembershipUpdated',
    { IndexedOnly: false; Required: true }
  > & {
    /** Type of role update. */
    type: 'granted' | 'revoked'
  }

  export type Log = viem_Log<
    bigint,
    number,
    false,
    ExtractAbiItem<typeof Abis.tip20, 'RoleMembershipUpdated'>,
    true
  >

  export type Parameters = UnionOmit<
    WatchContractEventParameters<
      typeof Abis.tip20,
      'RoleMembershipUpdated',
      true
    >,
    'abi' | 'address' | 'batch' | 'eventName' | 'onLogs' | 'strict'
  > & {
    /** Callback to invoke when a role membership is updated. */
    onRoleUpdated: (args: Args, log: Log) => void
    /** Address or ID of the TIP20 token. */
    token: TokenId.TokenIdOrAddress
  }
}

/**
 * Watches for TIP20 token transfer events.
 *
 * @example
 * ```ts
 * import { createClient, http } from 'viem'
 * import { tempo } from 'viem/chains'
 * import { Actions } from 'viem/tempo'
 *
 * const client = createClient({
 *   account: privateKeyToAccount('0x...'),
 *   chain: tempo.extend({ feeToken: '0x20c0000000000000000000000000000000000001' })
 *   transport: http(),
 * })
 *
 * const unwatch = actions.token.watchTransfer(client, {
 *   onTransfer: (args, log) => {
 *     console.log('Transfer:', args)
 *   },
 * })
 * ```
 *
 * @param client - Client.
 * @param parameters - Parameters.
 * @returns A function to unsubscribe from the event.
 */
export function watchTransfer<
  chain extends Chain | undefined,
  account extends Account | undefined,
>(
  client: Client<Transport, chain, account>,
  parameters: watchTransfer.Parameters,
) {
  const { onTransfer, token, ...rest } = parameters
  return watchContractEvent(client, {
    ...rest,
    address: resolveToken(client, { token }).address,
    abi: Abis.tip20,
    eventName: 'Transfer',
    onLogs: (logs) => {
      for (const log of logs) onTransfer(log.args, log)
    },
    strict: true,
  })
}

export declare namespace watchTransfer {
  export type Args = GetEventArgs<
    typeof Abis.tip20,
    'Transfer',
    { IndexedOnly: false; Required: true }
  >

  export type Log = viem_Log<
    bigint,
    number,
    false,
    ExtractAbiItem<typeof Abis.tip20, 'Transfer'>,
    true
  >

  export type Parameters = UnionOmit<
    WatchContractEventParameters<typeof Abis.tip20, 'Transfer', true>,
    'abi' | 'address' | 'batch' | 'eventName' | 'onLogs' | 'strict'
  > & {
    /** Callback to invoke when tokens are transferred. */
    onTransfer: (args: Args, log: Log) => void
    /** Address or ID of the TIP20 token. */
    token: TokenId.TokenIdOrAddress
  }
}

/**
 * Watches for TIP20 token quote token update events.
 *
 * @example
 * ```ts
 * import { createClient, http } from 'viem'
 * import { tempo } from 'viem/chains'
 * import { Actions } from 'viem/tempo'
 *
 * const client = createClient({
 *   chain: tempo.extend({ feeToken: '0x20c0000000000000000000000000000000000001' })
 *   transport: http(),
 * })
 *
 * const unwatch = actions.token.watchUpdateQuoteToken(client, {
 *   onUpdateQuoteToken: (args, log) => {
 *     if (args.completed)
 *       console.log('quote token update completed:', args.newQuoteToken)
 *     else
 *       console.log('quote token update proposed:', args.newQuoteToken)
 *   },
 * })
 * ```
 *
 * @param client - Client.
 * @param parameters - Parameters.
 * @returns A function to unsubscribe from the event.
 */
export function watchUpdateQuoteToken<
  chain extends Chain | undefined,
  account extends Account | undefined,
>(
  client: Client<Transport, chain, account>,
  parameters: watchUpdateQuoteToken.Parameters,
) {
  const { onUpdateQuoteToken, token, ...rest } = parameters
  const address = resolveToken(client, { token }).address

  return watchContractEvent(client, {
    ...rest,
    address,
    abi: Abis.tip20,
    onLogs: (
      logs: viem_Log<
        bigint,
        number,
        false,
        ExtractAbiItem<
          typeof Abis.tip20,
          'NextQuoteTokenSet' | 'QuoteTokenUpdate'
        >,
        true
      >[],
    ) => {
      for (const log of logs) {
        if (
          log.eventName !== 'NextQuoteTokenSet' &&
          log.eventName !== 'QuoteTokenUpdate'
        )
          continue

        onUpdateQuoteToken(
          {
            ...log.args,
            completed: log.eventName === 'QuoteTokenUpdate',
          },
          log,
        )
      }
    },
    strict: true,
  } as never)
}

export declare namespace watchUpdateQuoteToken {
  export type Args = OneOf<
    | GetEventArgs<
        typeof Abis.tip20,
        'NextQuoteTokenSet',
        { IndexedOnly: false; Required: true }
      >
    | GetEventArgs<
        typeof Abis.tip20,
        'QuoteTokenUpdate',
        { IndexedOnly: false; Required: true }
      >
  > & {
    /** Whether the update has been completed. */
    completed: boolean
  }

  export type Log = viem_Log

  export type Parameters = UnionOmit<
    WatchContractEventParameters<typeof Abis.tip20, any, true>,
    'abi' | 'address' | 'batch' | 'eventName' | 'onLogs' | 'strict'
  > & {
    /** Callback to invoke when a quote token update is proposed or completed. */
    onUpdateQuoteToken: (args: Args, log: Log) => void
    /** Address or ID of the TIP20 token. */
    token: TokenId.TokenIdOrAddress
  }
}