viem 2.42.1 → 2.43.0

package/tempo/actions/token.ts

@@ -0,0 +1,4456 @@
+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 { multicall } from '../../actions/public/multicall.js'
+import type { ReadContractReturnType } from '../../actions/public/readContract.js'
+import { readContract } from '../../actions/public/readContract.js'
+import type {
+  WatchContractEventParameters,
+  WatchContractEventReturnType,
+} from '../../actions/public/watchContractEvent.js'
+import { watchContractEvent } from '../../actions/public/watchContractEvent.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 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 * as Abis from '../Abis.js'
+import * as Addresses from '../Addresses.js'
+import type {
+  GetAccountParameter,
+  ReadParameters,
+  WriteParameters,
+} from '../internal/types.js'
+import { defineCall } 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 'tempo.ts/chains'
+ * import { Actions } from 'tempo.ts/viem'
+ * import { privateKeyToAccount } from 'viem/accounts'
+ *
+ * const client = createClient({
+ *   account: privateKeyToAccount('0x...'),
+ *   chain: tempo({ 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> {
+  const { token, ...rest } = parameters
+  return approve.inner(writeContract, client, parameters, { ...rest, token })
+}
+
+export namespace approve {
+  export type Parameters<
+    chain extends Chain | undefined = Chain | undefined,
+    account extends Account | undefined = Account | undefined,
+  > = WriteParameters<chain, account> & Args
+
+  export type Args = {
+    /** Amount of tokens to approve. */
+    amount: bigint
+    /** Address of the spender. */
+    spender: Address
+    /** 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: approve.Parameters<chain, account>,
+    args: Args,
+  ): Promise<ReturnType<action>> {
+    const call = approve.call(args)
+    return (await action(client, {
+      ...parameters,
+      ...call,
+    } as never)) as never
+  }
+
+  /**
+   * Defines a call to the `approve` 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 'tempo.ts/chains'
+   * import { Actions } from 'tempo.ts/viem'
+   *
+   * const client = createClient({
+   *   chain: tempo({ feeToken: '0x20c0000000000000000000000000000000000001' })
+   *   transport: http(),
+   * }).extend(walletActions)
+   *
+   * const { result } = await client.sendCalls({
+   *   calls: [
+   *     actions.token.approve.call({
+   *       spender: '0x20c0...beef',
+   *       amount: 100n,
+   *       token: '0x20c0...babe',
+   *     }),
+   *   ]
+   * })
+   * ```
+   *
+   * @param args - Arguments.
+   * @returns The call.
+   */
+  export function call(args: Args) {
+    const { spender, amount, token } = args
+    return defineCall({
+      address: TokenId.toAddress(token),
+      abi: Abis.tip20,
+      functionName: 'approve',
+      args: [spender, amount],
+    })
+  }
+
+  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 'tempo.ts/chains'
+ * import { Actions } from 'tempo.ts/viem'
+ * import { privateKeyToAccount } from 'viem/accounts'
+ *
+ * const client = createClient({
+ *   account: privateKeyToAccount('0x...'),
+ *   chain: tempo({ 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 { throwOnReceiptRevert = true, ...rest } = parameters
+  const receipt = await approve.inner(
+    writeContractSync,
+    client,
+    { ...parameters, throwOnReceiptRevert } as never,
+    rest,
+  )
+  const { args } = approve.extractEvent(receipt.logs)
+  return {
+    ...args,
+    receipt,
+  } as never
+}
+
+export namespace approveSync {
+  export type Parameters<
+    chain extends Chain | undefined = Chain | undefined,
+    account extends Account | undefined = Account | undefined,
+  > = approve.Parameters<chain, account>
+
+  export type Args = approve.Args
+
+  export type ReturnValue = Compute<
+    GetEventArgs<
+      typeof Abis.tip20,
+      'Approval',
+      {
+        IndexedOnly: false
+        Required: true
+      }
+    > & {
+      /** 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 'tempo.ts/chains'
+ * import { Actions } from 'tempo.ts/viem'
+ * import { privateKeyToAccount } from 'viem/accounts'
+ *
+ * const client = createClient({
+ *   account: privateKeyToAccount('0x...'),
+ *   chain: tempo({ 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 Parameters<
+    chain extends Chain | undefined = Chain | undefined,
+    account extends Account | undefined = Account | undefined,
+  > = WriteParameters<chain, account> & Args
+
+  export type Args = {
+    /** Amount of tokens to burn. */
+    amount: bigint
+    /** Address to burn tokens from. */
+    from: Address
+    /** 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: burnBlocked.Parameters<chain, account>,
+  ): Promise<ReturnType<action>> {
+    const { amount, from, token, ...rest } = parameters
+    const call = burnBlocked.call({ amount, from, token })
+    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 'tempo.ts/chains'
+   * import { Actions } from 'tempo.ts/viem'
+   *
+   * const client = createClient({
+   *   chain: tempo({ feeToken: '0x20c0000000000000000000000000000000000001' })
+   *   transport: http(),
+   * }).extend(walletActions)
+   *
+   * const { result } = await client.sendCalls({
+   *   calls: [
+   *     actions.token.burnBlocked.call({
+   *       from: '0x20c0...beef',
+   *       amount: 100n,
+   *       token: '0x20c0...babe',
+   *     }),
+   *   ]
+   * })
+   * ```
+   *
+   * @param args - Arguments.
+   * @returns The call.
+   */
+  export function call(args: Args) {
+    const { from, amount, token } = args
+    return defineCall({
+      address: TokenId.toAddress(token),
+      abi: Abis.tip20,
+      functionName: 'burnBlocked',
+      args: [from, amount],
+    })
+  }
+
+  /**
+   * 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 'tempo.ts/chains'
+ * import { Actions } from 'tempo.ts/viem'
+ * import { privateKeyToAccount } from 'viem/accounts'
+ *
+ * const client = createClient({
+ *   account: privateKeyToAccount('0x...'),
+ *   chain: tempo({ 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)
+  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 'tempo.ts/chains'
+ * import { Actions } from 'tempo.ts/viem'
+ * import { privateKeyToAccount } from 'viem/accounts'
+ *
+ * const client = createClient({
+ *   account: privateKeyToAccount('0x...'),
+ *   chain: tempo({ 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 Parameters<
+    chain extends Chain | undefined = Chain | undefined,
+    account extends Account | undefined = Account | undefined,
+  > = WriteParameters<chain, account> & Args
+
+  export type Args = {
+    /** Amount of tokens to burn. */
+    amount: bigint
+    /** Memo to include in the transfer. */
+    memo?: Hex.Hex | undefined
+    /** 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: burn.Parameters<chain, account>,
+  ): Promise<ReturnType<action>> {
+    const { amount, memo, token, ...rest } = parameters
+    const call = burn.call({ amount, memo, token })
+    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 'tempo.ts/chains'
+   * import { Actions } from 'tempo.ts/viem'
+   *
+   * const client = createClient({
+   *   chain: tempo({ feeToken: '0x20c0000000000000000000000000000000000001' })
+   *   transport: http(),
+   * }).extend(walletActions)
+   *
+   * const { result } = await client.sendCalls({
+   *   calls: [
+   *     actions.token.burn.call({
+   *       amount: 100n,
+   *       token: '0x20c0...babe',
+   *     }),
+   *   ]
+   * })
+   * ```
+   *
+   * @param args - Arguments.
+   * @returns The call.
+   */
+  export function call(args: Args) {
+    const { amount, memo, token } = args
+    const callArgs = memo
+      ? ({
+          functionName: 'burnWithMemo',
+          args: [amount, Hex.padLeft(memo, 32)],
+        } as const)
+      : ({
+          functionName: 'burn',
+          args: [amount],
+        } as const)
+    return defineCall({
+      address: TokenId.toAddress(token),
+      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 'tempo.ts/chains'
+ * import { Actions } from 'tempo.ts/viem'
+ * import { privateKeyToAccount } from 'viem/accounts'
+ *
+ * const client = createClient({
+ *   account: privateKeyToAccount('0x...'),
+ *   chain: tempo({ 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)
+  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 'tempo.ts/chains'
+ * import { Actions } from 'tempo.ts/viem'
+ * import { privateKeyToAccount } from 'viem/accounts'
+ *
+ * const client = createClient({
+ *   account: privateKeyToAccount('0x...'),
+ *   chain: tempo({ 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({ 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 'tempo.ts/chains'
+   * import { Actions } from 'tempo.ts/viem'
+   *
+   * const client = createClient({
+   *   chain: tempo({ feeToken: '0x20c0000000000000000000000000000000000001' })
+   *   transport: http(),
+   * }).extend(walletActions)
+   *
+   * const { result } = await client.sendCalls({
+   *   calls: [
+   *     actions.token.changeTransferPolicy.call({
+   *       token: '0x20c0...babe',
+   *       policyId: 1n,
+   *     }),
+   *   ]
+   * })
+   * ```
+   *
+   * @param args - Arguments.
+   * @returns The call.
+   */
+  export function call(args: Args) {
+    const { token, policyId } = args
+    return defineCall({
+      address: TokenId.toAddress(token),
+      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 'tempo.ts/chains'
+ * import { Actions } from 'tempo.ts/viem'
+ * import { privateKeyToAccount } from 'viem/accounts'
+ *
+ * const client = createClient({
+ *   account: privateKeyToAccount('0x...'),
+ *   chain: tempo({ 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)
+  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 'tempo.ts/chains'
+ * import { Actions } from 'tempo.ts/viem'
+ * import { privateKeyToAccount } from 'viem/accounts'
+ *
+ * const client = createClient({
+ *   account: privateKeyToAccount('0x...'),
+ *   chain: tempo({ feeToken: '0x20c0000000000000000000000000000000000001' })
+ *   transport: http(),
+ * })
+ *
+ * const result = await Actions.token.create(client, {
+ *   name: 'My Token',
+ *   symbol: 'MTK',
+ *   currency: 'USD',
+ * })
+ * ```
+ *
+ * @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
+    /** quote token. */
+    quoteToken?: TokenId.TokenIdOrAddress | 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({ ...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 'tempo.ts/chains'
+   * import { Actions } from 'tempo.ts/viem'
+   *
+   * const client = createClient({
+   *   chain: tempo({ feeToken: '0x20c0000000000000000000000000000000000001' })
+   *   transport: http(),
+   * }).extend(walletActions)
+   *
+   * const { result } = await client.sendCalls({
+   *   calls: [
+   *     actions.token.create.call({
+   *       name: 'My Token',
+   *       symbol: 'MTK',
+   *       currency: 'USD',
+   *       admin: '0xfeed...fede',
+   *     }),
+   *   ]
+   * })
+   * ```
+   *
+   * @param args - Arguments.
+   * @returns The call.
+   */
+  export function call(args: Args) {
+    const {
+      name,
+      symbol,
+      currency,
+      quoteToken = Addresses.pathUsd,
+      admin,
+    } = args
+    return defineCall({
+      address: Addresses.tip20Factory,
+      abi: Abis.tip20Factory,
+      args: [name, symbol, currency, TokenId.toAddress(quoteToken), admin],
+      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 'tempo.ts/chains'
+ * import { Actions } from 'tempo.ts/viem'
+ * import { privateKeyToAccount } from 'viem/accounts'
+ *
+ * const client = createClient({
+ *   account: privateKeyToAccount('0x...'),
+ *   chain: tempo({ feeToken: '0x20c0000000000000000000000000000000000001' })
+ *   transport: http(),
+ * })
+ *
+ * const result = await Actions.token.createSync(client, {
+ *   name: 'My Token',
+ *   symbol: 'MTK',
+ *   currency: 'USD',
+ * })
+ * ```
+ *
+ * @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)
+
+  const { args } = create.extractEvent(receipt.logs)
+
+  return {
+    ...args,
+    receipt,
+  } 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 }
+    > & {
+      /** 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 'tempo.ts/chains'
+ * import { Actions } from 'tempo.ts/viem'
+ * import { privateKeyToAccount } from 'viem/accounts'
+ *
+ * const client = createClient({
+ *   account: privateKeyToAccount('0x...'),
+ *   chain: tempo({ feeToken: '0x20c0000000000000000000000000000000000001' })
+ *   transport: http(),
+ * })
+ *
+ * const allowance = await Actions.token.getAllowance(client, {
+ *   spender: '0x...',
+ * })
+ * ```
+ *
+ * @param client - Client.
+ * @param parameters - Parameters.
+ * @returns The token allowance.
+ */
+export async function getAllowance<
+  chain extends Chain | undefined,
+  account extends Account | undefined,
+>(
+  client: Client<Transport, chain, account>,
+  parameters: getAllowance.Parameters<account>,
+): Promise<getAllowance.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,
+    ...getAllowance.call({ ...parameters, account: address }),
+  })
+}
+
+export namespace getAllowance {
+  export type Parameters<
+    account extends Account | undefined = Account | undefined,
+  > = ReadParameters & GetAccountParameter<account> & Omit<Args, 'account'> & {}
+
+  export type Args = {
+    /** Account address. */
+    account: Address
+    /** Address of the spender. */
+    spender: Address
+    /** Address or ID of the TIP20 token. */
+    token: TokenId.TokenIdOrAddress
+  }
+
+  export type ReturnValue = ReadContractReturnType<
+    typeof Abis.tip20,
+    'allowance',
+    never
+  >
+
+  /**
+   * Defines a call to the `allowance` function.
+   *
+   * @param args - Arguments.
+   * @returns The call.
+   */
+  export function call(args: Args) {
+    const { account, spender, token } = args
+    return defineCall({
+      address: TokenId.toAddress(token),
+      abi: Abis.tip20,
+      functionName: 'allowance',
+      args: [account, spender],
+    })
+  }
+}
+
+/**
+ * Gets TIP20 token balance for an address.
+ *
+ * @example
+ * ```ts
+ * import { createClient, http } from 'viem'
+ * import { tempo } from 'tempo.ts/chains'
+ * import { Actions } from 'tempo.ts/viem'
+ * import { privateKeyToAccount } from 'viem/accounts'
+ *
+ * const client = createClient({
+ *   account: privateKeyToAccount('0x...'),
+ *   chain: tempo({ feeToken: '0x20c0000000000000000000000000000000000001' })
+ *   transport: http(),
+ * })
+ *
+ * const balance = await Actions.token.getBalance(client, {
+ *   token: '0x...',
+ * })
+ * ```
+ *
+ * @param client - Client.
+ * @param parameters - Parameters.
+ * @returns The token balance.
+ */
+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 = client.account, ...rest } = parameters
+  const address = account ? parseAccount(account).address : undefined
+  if (!address) throw new Error('account is required.')
+  return readContract(client, {
+    ...rest,
+    ...getBalance.call({ account: address, ...rest }),
+  })
+}
+
+export namespace getBalance {
+  export type Parameters<
+    account extends Account | undefined = Account | undefined,
+  > = ReadParameters & GetAccountParameter<account> & Omit<Args, 'account'>
+
+  export type Args = {
+    /** Account address. */
+    account: Address
+    /** Address or ID of the TIP20 token. */
+    token: TokenId.TokenIdOrAddress
+  }
+
+  export type ReturnValue = ReadContractReturnType<
+    typeof Abis.tip20,
+    'balanceOf',
+    never
+  >
+
+  /**
+   * Defines a call to the `balanceOf` function.
+   *
+   * @param args - Arguments.
+   * @returns The call.
+   */
+  export function call(args: Args) {
+    const { account, token } = args
+    return defineCall({
+      address: TokenId.toAddress(token),
+      abi: Abis.tip20,
+      functionName: 'balanceOf',
+      args: [account],
+    })
+  }
+}
+
+/**
+ * Gets TIP20 token metadata including name, symbol, currency, decimals, and total supply.
+ *
+ * @example
+ * ```ts
+ * import { createClient, http } from 'viem'
+ * import { tempo } from 'tempo.ts/chains'
+ * import { Actions } from 'tempo.ts/viem'
+ * import { privateKeyToAccount } from 'viem/accounts'
+ *
+ * const client = createClient({
+ *   account: privateKeyToAccount('0x...'),
+ *   chain: tempo({ 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 = TokenId.toAddress(token)
+  const abi = Abis.tip20
+
+  if (TokenId.from(token) === TokenId.fromAddress(Addresses.pathUsd))
+    return multicall(client, {
+      ...rest,
+      contracts: [
+        {
+          address,
+          abi,
+          functionName: 'currency',
+        },
+        {
+          address,
+          abi,
+          functionName: 'decimals',
+        },
+        {
+          address,
+          abi,
+          functionName: 'name',
+        },
+        {
+          address,
+          abi,
+          functionName: 'symbol',
+        },
+        {
+          address,
+          abi,
+          functionName: 'totalSupply',
+        },
+      ] as const,
+      allowFailure: false,
+      deployless: true,
+    }).then(([currency, decimals, name, symbol, totalSupply]) => ({
+      name,
+      symbol,
+      currency,
+      decimals,
+      totalSupply,
+    }))
+
+  return multicall(client, {
+    ...rest,
+    contracts: [
+      {
+        address,
+        abi,
+        functionName: 'currency',
+      },
+      {
+        address,
+        abi,
+        functionName: 'decimals',
+      },
+      {
+        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,
+    allowFailure: false,
+    deployless: true,
+  }).then(
+    ([
+      currency,
+      decimals,
+      quoteToken,
+      name,
+      paused,
+      supplyCap,
+      symbol,
+      totalSupply,
+      transferPolicyId,
+    ]) => ({
+      name,
+      symbol,
+      currency,
+      decimals,
+      quoteToken,
+      totalSupply,
+      paused,
+      supplyCap,
+      transferPolicyId,
+    }),
+  )
+}
+
+export declare namespace getMetadata {
+  export type Parameters = {
+    /** Address or ID of the TIP20 token. */
+    token: TokenId.TokenIdOrAddress
+  }
+
+  export type ReturnValue = Compute<{
+    /**
+     * Currency (e.g. "USD").
+     */
+    currency: string
+    /**
+     * Decimals of the token.
+     */
+    decimals: number
+    /**
+     * 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 admin role for a specific role in a TIP20 token.
+ *
+ * @example
+ * ```ts
+ * import { createClient, http } from 'viem'
+ * import { tempo } from 'tempo.ts/chains'
+ * import { Actions } from 'tempo.ts/viem'
+ *
+ * const client = createClient({
+ *   chain: tempo({ 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(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 args - Arguments.
+   * @returns The call.
+   */
+  export function call(args: Args) {
+    const { role, token } = args
+    return defineCall({
+      address: TokenId.toAddress(token),
+      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 'tempo.ts/chains'
+ * import { Actions } from 'tempo.ts/viem'
+ *
+ * const client = createClient({
+ *   chain: tempo({ 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({ ...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 args - Arguments.
+   * @returns The call.
+   */
+  export function call(args: Args) {
+    const { account, role, token } = args
+    return defineCall({
+      address: TokenId.toAddress(token),
+      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 'tempo.ts/chains'
+ * import { Actions } from 'tempo.ts/viem'
+ * import { privateKeyToAccount } from 'viem/accounts'
+ *
+ * const client = createClient({
+ *   account: privateKeyToAccount('0x...'),
+ *   chain: tempo({ 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({ ...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 'tempo.ts/chains'
+   * import { Actions } from 'tempo.ts/viem'
+   *
+   * const client = createClient({
+   *   chain: tempo({ feeToken: '0x20c0000000000000000000000000000000000001' })
+   *   transport: http(),
+   * }).extend(walletActions)
+   *
+   * const { result } = await client.sendCalls({
+   *   calls: [
+   *     actions.token.grantRoles.call({
+   *       token: '0x20c0...babe',
+   *       to: '0x20c0...beef',
+   *       role: 'issuer',
+   *     }),
+   *   ]
+   * })
+   * ```
+   *
+   * @param args - Arguments.
+   * @returns The call.
+   */
+  export function call(args: Args) {
+    const { token, to, role } = args
+    const roleHash = TokenRole.serialize(role)
+    return defineCall({
+      address: TokenId.toAddress(token),
+      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 'tempo.ts/chains'
+ * import { Actions } from 'tempo.ts/viem'
+ * import { privateKeyToAccount } from 'viem/accounts'
+ *
+ * const client = createClient({
+ *   account: privateKeyToAccount('0x...'),
+ *   chain: tempo({ 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)
+  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 'tempo.ts/chains'
+ * import { Actions } from 'tempo.ts/viem'
+ * import { privateKeyToAccount } from 'viem/accounts'
+ *
+ * const client = createClient({
+ *   account: privateKeyToAccount('0x...'),
+ *   chain: tempo({ 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 Parameters<
+    chain extends Chain | undefined = Chain | undefined,
+    account extends Account | undefined = Account | undefined,
+  > = WriteParameters<chain, account> & Args
+
+  export type Args = {
+    /** Amount of tokens to mint. */
+    amount: bigint
+    /** Memo to include in the mint. */
+    memo?: Hex.Hex | undefined
+    /** Address to mint tokens to. */
+    to: Address
+    /** 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: any,
+  ): Promise<ReturnType<action>> {
+    const call = mint.call(parameters)
+    return (await action(client, {
+      ...parameters,
+      ...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 'tempo.ts/chains'
+   * import { Actions } from 'tempo.ts/viem'
+   *
+   * const client = createClient({
+   *   chain: tempo({ feeToken: '0x20c0000000000000000000000000000000000001' })
+   *   transport: http(),
+   * }).extend(walletActions)
+   *
+   * const { result } = await client.sendCalls({
+   *   calls: [
+   *     actions.token.mint.call({
+   *       to: '0x20c0...beef',
+   *       amount: 100n,
+   *       token: '0x20c0...babe',
+   *     }),
+   *   ]
+   * })
+   * ```
+   *
+   * @param args - Arguments.
+   * @returns The call.
+   */
+  export function call(args: Args) {
+    const { to, amount, memo, token } = args
+    const callArgs = memo
+      ? ({
+          functionName: 'mintWithMemo',
+          args: [to, amount, Hex.padLeft(memo, 32)],
+        } as const)
+      : ({
+          functionName: 'mint',
+          args: [to, amount],
+        } as const)
+    return defineCall({
+      address: TokenId.toAddress(token),
+      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 'tempo.ts/chains'
+ * import { Actions } from 'tempo.ts/viem'
+ * import { privateKeyToAccount } from 'viem/accounts'
+ *
+ * const client = createClient({
+ *   account: privateKeyToAccount('0x...'),
+ *   chain: tempo({ 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)
+  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 'tempo.ts/chains'
+ * import { Actions } from 'tempo.ts/viem'
+ * import { privateKeyToAccount } from 'viem/accounts'
+ *
+ * const client = createClient({
+ *   account: privateKeyToAccount('0x...'),
+ *   chain: tempo({ 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({ 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 'tempo.ts/chains'
+   * import { Actions } from 'tempo.ts/viem'
+   *
+   * const client = createClient({
+   *   chain: tempo({ feeToken: '0x20c0000000000000000000000000000000000001' })
+   *   transport: http(),
+   * }).extend(walletActions)
+   *
+   * const { result } = await client.sendCalls({
+   *   calls: [
+   *     actions.token.pause.call({
+   *       token: '0x20c0...babe',
+   *     }),
+   *   ]
+   * })
+   * ```
+   *
+   * @param args - Arguments.
+   * @returns The call.
+   */
+  export function call(args: Args) {
+    const { token } = args
+    return defineCall({
+      address: TokenId.toAddress(token),
+      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 'tempo.ts/chains'
+ * import { Actions } from 'tempo.ts/viem'
+ * import { privateKeyToAccount } from 'viem/accounts'
+ *
+ * const client = createClient({
+ *   account: privateKeyToAccount('0x...'),
+ *   chain: tempo({ 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)
+  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 'tempo.ts/chains'
+ * import { Actions } from 'tempo.ts/viem'
+ * import { privateKeyToAccount } from 'viem/accounts'
+ *
+ * const client = createClient({
+ *   account: privateKeyToAccount('0x...'),
+ *   chain: tempo({ 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({ ...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 'tempo.ts/chains'
+   * import { Actions } from 'tempo.ts/viem'
+   *
+   * const client = createClient({
+   *   chain: tempo({ feeToken: '0x20c0000000000000000000000000000000000001' })
+   *   transport: http(),
+   * }).extend(walletActions)
+   *
+   * const { result } = await client.sendCalls({
+   *   calls: [
+   *     actions.token.renounceRoles.call({
+   *       token: '0x20c0...babe',
+   *       role: 'issuer',
+   *     }),
+   *   ]
+   * })
+   * ```
+   *
+   * @param args - Arguments.
+   * @returns The call.
+   */
+  export function call(args: Args) {
+    const { token, role } = args
+    const roleHash = TokenRole.serialize(role)
+    return defineCall({
+      address: TokenId.toAddress(token),
+      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 'tempo.ts/chains'
+ * import { Actions } from 'tempo.ts/viem'
+ * import { privateKeyToAccount } from 'viem/accounts'
+ *
+ * const client = createClient({
+ *   account: privateKeyToAccount('0x...'),
+ *   chain: tempo({ 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)
+  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 'tempo.ts/chains'
+ * import { Actions } from 'tempo.ts/viem'
+ * import { privateKeyToAccount } from 'viem/accounts'
+ *
+ * const client = createClient({
+ *   account: privateKeyToAccount('0x...'),
+ *   chain: tempo({ 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>> {
+    return (await action(client, {
+      ...parameters,
+      calls: parameters.roles.map((role) => {
+        const call = revokeRoles.call({ ...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 'tempo.ts/chains'
+   * import { Actions } from 'tempo.ts/viem'
+   *
+   * const client = createClient({
+   *   chain: tempo({ feeToken: '0x20c0000000000000000000000000000000000001' })
+   *   transport: http(),
+   * }).extend(walletActions)
+   *
+   * const { result } = await client.sendCalls({
+   *   calls: [
+   *     actions.token.revokeRoles.call({
+   *       token: '0x20c0...babe',
+   *       from: '0x20c0...beef',
+   *       role: 'issuer',
+   *     }),
+   *   ]
+   * })
+   * ```
+   *
+   * @param args - Arguments.
+   * @returns The call.
+   */
+  export function call(args: Args) {
+    const { token, from, role } = args
+    const roleHash = TokenRole.serialize(role)
+    return defineCall({
+      address: TokenId.toAddress(token),
+      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 'tempo.ts/chains'
+ * import { Actions } from 'tempo.ts/viem'
+ * import { privateKeyToAccount } from 'viem/accounts'
+ *
+ * const client = createClient({
+ *   account: privateKeyToAccount('0x...'),
+ *   chain: tempo({ 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)
+  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 'tempo.ts/chains'
+ * import { Actions } from 'tempo.ts/viem'
+ * import { privateKeyToAccount } from 'viem/accounts'
+ *
+ * const client = createClient({
+ *   account: privateKeyToAccount('0x...'),
+ *   chain: tempo({ 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({ 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 'tempo.ts/chains'
+   * import { Actions } from 'tempo.ts/viem'
+   *
+   * const client = createClient({
+   *   chain: tempo({ feeToken: '0x20c0000000000000000000000000000000000001' })
+   *   transport: http(),
+   * }).extend(walletActions)
+   *
+   * const { result } = await client.sendCalls({
+   *   calls: [
+   *     actions.token.setSupplyCap.call({
+   *       token: '0x20c0...babe',
+   *       supplyCap: 1000000n,
+   *     }),
+   *   ]
+   * })
+   * ```
+   *
+   * @param args - Arguments.
+   * @returns The call.
+   */
+  export function call(args: Args) {
+    const { token, supplyCap } = args
+    return defineCall({
+      address: TokenId.toAddress(token),
+      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 'tempo.ts/chains'
+ * import { Actions } from 'tempo.ts/viem'
+ * import { privateKeyToAccount } from 'viem/accounts'
+ *
+ * const client = createClient({
+ *   account: privateKeyToAccount('0x...'),
+ *   chain: tempo({ 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)
+  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 'tempo.ts/chains'
+ * import { Actions } from 'tempo.ts/viem'
+ * import { privateKeyToAccount } from 'viem/accounts'
+ *
+ * const client = createClient({
+ *   account: privateKeyToAccount('0x...'),
+ *   chain: tempo({ 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({ 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 'tempo.ts/chains'
+   * import { Actions } from 'tempo.ts/viem'
+   *
+   * const client = createClient({
+   *   chain: tempo({ feeToken: '0x20c0000000000000000000000000000000000001' })
+   *   transport: http(),
+   * }).extend(walletActions)
+   *
+   * const { result } = await client.sendCalls({
+   *   calls: [
+   *     actions.token.setRoleAdmin.call({
+   *       token: '0x20c0...babe',
+   *       role: 'issuer',
+   *       adminRole: 'admin',
+   *     }),
+   *   ]
+   * })
+   * ```
+   *
+   * @param args - Arguments.
+   * @returns The call.
+   */
+  export function call(args: Args) {
+    const { token, role, adminRole } = args
+    const roleHash = TokenRole.serialize(role)
+    const adminRoleHash = TokenRole.serialize(adminRole)
+    return defineCall({
+      address: TokenId.toAddress(token),
+      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 'tempo.ts/chains'
+ * import { Actions } from 'tempo.ts/viem'
+ * import { privateKeyToAccount } from 'viem/accounts'
+ *
+ * const client = createClient({
+ *   account: privateKeyToAccount('0x...'),
+ *   chain: tempo({ 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)
+  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 'tempo.ts/chains'
+ * import { Actions } from 'tempo.ts/viem'
+ * import { privateKeyToAccount } from 'viem/accounts'
+ *
+ * const client = createClient({
+ *   account: privateKeyToAccount('0x...'),
+ *   chain: tempo({ 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 Parameters<
+    chain extends Chain | undefined = Chain | undefined,
+    account extends Account | undefined = Account | undefined,
+  > = WriteParameters<chain, account> & Args
+
+  export type Args = {
+    /** Amount of tokens to transfer. */
+    amount: bigint
+    /** Address to transfer tokens from. */
+    from?: Address | undefined
+    /** Memo to include in the transfer. */
+    memo?: Hex.Hex | undefined
+    /** Address or ID of the TIP20 token. */
+    token: TokenId.TokenIdOrAddress
+    /** Address to transfer tokens to. */
+    to: Address
+  }
+
+  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>> {
+    const { amount, from, memo, token, to, ...rest } = parameters
+    const call = transfer.call({ amount, from, memo, token, to })
+    return (await action(client, {
+      ...rest,
+      ...call,
+    } as never)) as never
+  }
+
+  /**
+   * Defines a call to the `transfer`, `transferFrom`, `transferWithMemo`, or `transferFromWithMemo` 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 'tempo.ts/chains'
+   * import { Actions } from 'tempo.ts/viem'
+   *
+   * const client = createClient({
+   *   chain: tempo({ feeToken: '0x20c0000000000000000000000000000000000001' })
+   *   transport: http(),
+   * }).extend(walletActions)
+   *
+   * const { result } = await client.sendCalls({
+   *   calls: [
+   *     actions.token.transfer.call({
+   *       to: '0x20c0...beef',
+   *       amount: 100n,
+   *       token: '0x20c0...babe',
+   *     }),
+   *   ]
+   * })
+   * ```
+   *
+   * @param args - Arguments.
+   * @returns The call.
+   */
+  export function call(args: Args) {
+    const { amount, from, memo, token, to } = args
+    const callArgs = (() => {
+      if (memo && from)
+        return {
+          functionName: 'transferFromWithMemo',
+          args: [from, to, amount, Hex.padLeft(memo, 32)],
+        } as const
+      if (memo)
+        return {
+          functionName: 'transferWithMemo',
+          args: [to, amount, Hex.padLeft(memo, 32)],
+        } as const
+      if (from)
+        return {
+          functionName: 'transferFrom',
+          args: [from, to, amount],
+        } as const
+      return {
+        functionName: 'transfer',
+        args: [to, amount],
+      } as const
+    })()
+    return defineCall({
+      address: TokenId.toAddress(token),
+      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: '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 'tempo.ts/chains'
+ * import { Actions } from 'tempo.ts/viem'
+ * import { privateKeyToAccount } from 'viem/accounts'
+ *
+ * const client = createClient({
+ *   account: privateKeyToAccount('0x...'),
+ *   chain: tempo({ 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 { throwOnReceiptRevert = true, ...rest } = parameters
+  const receipt = await transfer.inner(writeContractSync, client, {
+    ...rest,
+    throwOnReceiptRevert,
+  } as never)
+  const { args } = transfer.extractEvent(receipt.logs)
+  return {
+    ...args,
+    receipt,
+  } as never
+}
+
+export namespace transferSync {
+  export type Parameters<
+    chain extends Chain | undefined = Chain | undefined,
+    account extends Account | undefined = Account | undefined,
+  > = transfer.Parameters<chain, account>
+
+  export type Args = transfer.Args
+
+  export type ReturnValue = GetEventArgs<
+    typeof Abis.tip20,
+    'Transfer',
+    { IndexedOnly: false; Required: true }
+  > & {
+    receipt: TransactionReceipt
+  }
+
+  // TODO: exhaustive error type
+  export type ErrorType = BaseErrorType
+}
+
+/**
+ * Unpauses a TIP20 token.
+ *
+ * @example
+ * ```ts
+ * import { createClient, http } from 'viem'
+ * import { tempo } from 'tempo.ts/chains'
+ * import { Actions } from 'tempo.ts/viem'
+ * import { privateKeyToAccount } from 'viem/accounts'
+ *
+ * const client = createClient({
+ *   account: privateKeyToAccount('0x...'),
+ *   chain: tempo({ 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({ 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 'tempo.ts/chains'
+   * import { Actions } from 'tempo.ts/viem'
+   *
+   * const client = createClient({
+   *   chain: tempo({ feeToken: '0x20c0000000000000000000000000000000000001' })
+   *   transport: http(),
+   * }).extend(walletActions)
+   *
+   * const { result } = await client.sendCalls({
+   *   calls: [
+   *     actions.token.unpause.call({
+   *       token: '0x20c0...babe',
+   *     }),
+   *   ]
+   * })
+   * ```
+   *
+   * @param args - Arguments.
+   * @returns The call.
+   */
+  export function call(args: Args) {
+    const { token } = args
+    return defineCall({
+      address: TokenId.toAddress(token),
+      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 'tempo.ts/chains'
+ * import { Actions } from 'tempo.ts/viem'
+ * import { privateKeyToAccount } from 'viem/accounts'
+ *
+ * const client = createClient({
+ *   account: privateKeyToAccount('0x...'),
+ *   chain: tempo({ 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)
+  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 'tempo.ts/chains'
+ * import { Actions } from 'tempo.ts/viem'
+ * import { privateKeyToAccount } from 'viem/accounts'
+ *
+ * const client = createClient({
+ *   account: privateKeyToAccount('0x...'),
+ *   chain: tempo({ 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({ 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 'tempo.ts/chains'
+   * import { Actions } from 'tempo.ts/viem'
+   *
+   * const client = createClient({
+   *   chain: tempo({ feeToken: '0x20c0000000000000000000000000000000000001' })
+   *   transport: http(),
+   * }).extend(walletActions)
+   *
+   * const { result } = await client.sendCalls({
+   *   calls: [
+   *     actions.token.prepareUpdateQuoteToken.call({
+   *       token: '0x20c0...babe',
+   *       quoteToken: '0x20c0...cafe',
+   *     }),
+   *   ]
+   * })
+   * ```
+   *
+   * @param args - Arguments.
+   * @returns The call.
+   */
+  export function call(args: Args) {
+    const { token, quoteToken } = args
+    return defineCall({
+      address: TokenId.toAddress(token),
+      abi: Abis.tip20,
+      functionName: 'setNextQuoteToken',
+      args: [TokenId.toAddress(quoteToken)],
+    })
+  }
+
+  /**
+   * 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 'tempo.ts/chains'
+ * import { Actions } from 'tempo.ts/viem'
+ * import { privateKeyToAccount } from 'viem/accounts'
+ *
+ * const client = createClient({
+ *   account: privateKeyToAccount('0x...'),
+ *   chain: tempo({ 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,
+  )
+  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 'tempo.ts/chains'
+ * import { Actions } from 'tempo.ts/viem'
+ * import { privateKeyToAccount } from 'viem/accounts'
+ *
+ * const client = createClient({
+ *   account: privateKeyToAccount('0x...'),
+ *   chain: tempo({ 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({ 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 'tempo.ts/chains'
+   * import { Actions } from 'tempo.ts/viem'
+   *
+   * const client = createClient({
+   *   chain: tempo({ feeToken: '0x20c0000000000000000000000000000000000001' })
+   *   transport: http(),
+   * }).extend(walletActions)
+   *
+   * const { result } = await client.sendCalls({
+   *   calls: [
+   *     actions.token.updateQuoteToken.call({
+   *       token: '0x20c0...babe',
+   *     }),
+   *   ]
+   * })
+   * ```
+   *
+   * @param args - Arguments.
+   * @returns The call.
+   */
+  export function call(args: Args) {
+    const { token } = args
+    return defineCall({
+      address: TokenId.toAddress(token),
+      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 'tempo.ts/chains'
+ * import { Actions } from 'tempo.ts/viem'
+ * import { privateKeyToAccount } from 'viem/accounts'
+ *
+ * const client = createClient({
+ *   account: privateKeyToAccount('0x...'),
+ *   chain: tempo({ 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,
+  )
+  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 'tempo.ts/chains'
+ * import { Actions } from 'tempo.ts/viem'
+ *
+ * const client = createClient({
+ *   chain: tempo({ 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: TokenId.toAddress(token),
+    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 'tempo.ts/chains'
+ * import { Actions } from 'tempo.ts/viem'
+ *
+ * const client = createClient({
+ *   chain: tempo({ 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: TokenId.toAddress(token),
+    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 'tempo.ts/chains'
+ * import { Actions } from 'tempo.ts/viem'
+ *
+ * const client = createClient({
+ *   chain: tempo({ 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 'tempo.ts/chains'
+ * import { Actions } from 'tempo.ts/viem'
+ *
+ * const client = createClient({
+ *   chain: tempo({ 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: TokenId.toAddress(token),
+    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 'tempo.ts/chains'
+ * import { Actions } from 'tempo.ts/viem'
+ *
+ * const client = createClient({
+ *   chain: tempo({ 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: TokenId.toAddress(token),
+    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 'tempo.ts/chains'
+ * import { Actions } from 'tempo.ts/viem'
+ *
+ * const client = createClient({
+ *   chain: tempo({ 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: TokenId.toAddress(token),
+    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 'tempo.ts/chains'
+ * import { Actions } from 'tempo.ts/viem'
+ *
+ * const client = createClient({
+ *   account: privateKeyToAccount('0x...'),
+ *   chain: tempo({ 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: TokenId.toAddress(token),
+    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 'tempo.ts/chains'
+ * import { Actions } from 'tempo.ts/viem'
+ *
+ * const client = createClient({
+ *   chain: tempo({ 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 = TokenId.toAddress(token)
+
+  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
+  }
+}