tempo.ts 0.1.5 → 0.2.1

package/src/viem/Actions/token.ts

@@ -1,8 +1,8 @@
 import * as Hex from 'ox/Hex'
-import * as Signature from 'ox/Signature'
 import {
   type Account,
   type Address,
+  type BaseErrorType,
   type Chain,
   type Client,
   type ExtractAbiItem,
@@ -16,6 +16,7 @@ import {
   type Transport,
   type Log as viem_Log,
   type WatchContractEventParameters,
+  type WatchContractEventReturnType,
   type WriteContractReturnType,
 } from 'viem'
 import { parseAccount } from 'viem/accounts'
@@ -47,16 +48,16 @@ import { defineCall } from '../internal/utils.js'
  * ```ts
  * import { createClient, http } from 'viem'
  * import { tempo } from 'tempo.ts/chains'
- * import * as actions from 'tempo.ts/viem/actions'
+ * import { Actions } from 'tempo.ts/viem'
  * import { privateKeyToAccount } from 'viem/accounts'
  *
  * const client = createClient({
  *   account: privateKeyToAccount('0x...'),
- *   chain: tempo,
+ *   chain: tempo({ feeToken: '0x20c0000000000000000000000000000000000001' })
  *   transport: http(),
  * })
  *
- * const result = await actions.token.approve(client, {
+ * const result = await Actions.token.approve(client, {
  *   spender: '0x...',
  *   amount: 100n,
  * })
@@ -73,7 +74,7 @@ export async function approve<
   client: Client<Transport, chain, account>,
   parameters: approve.Parameters<chain, account>,
 ): Promise<approve.ReturnValue> {
-  const { token = Addresses.defaultFeeToken, ...rest } = parameters
+  const { token, ...rest } = parameters
   return approve.inner(writeContract, client, parameters, { ...rest, token })
 }
 
@@ -88,12 +89,15 @@ export namespace approve {
     amount: bigint
     /** Address of the spender. */
     spender: Address
-    /** Address or ID of the TIP20 token. @default `Addresses.defaultFeeToken` */
-    token?: TokenId.TokenIdOrAddress | 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,
@@ -124,10 +128,10 @@ export namespace approve {
    * ```ts
    * import { createClient, http, walletActions } from 'viem'
    * import { tempo } from 'tempo.ts/chains'
-   * import * as actions from 'tempo.ts/viem/actions'
+   * import { Actions } from 'tempo.ts/viem'
    *
    * const client = createClient({
-   *   chain: tempo,
+   *   chain: tempo({ feeToken: '0x20c0000000000000000000000000000000000001' })
    *   transport: http(),
    * }).extend(walletActions)
    *
@@ -146,7 +150,7 @@ export namespace approve {
    * @returns The call.
    */
   export function call(args: Args) {
-    const { spender, amount, token = Addresses.defaultFeeToken } = args
+    const { spender, amount, token } = args
     return defineCall({
       address: TokenId.toAddress(token),
       abi: Abis.tip20,
@@ -173,16 +177,16 @@ export namespace approve {
  * ```ts
  * import { createClient, http } from 'viem'
  * import { tempo } from 'tempo.ts/chains'
- * import * as actions from 'tempo.ts/viem/actions'
+ * import { Actions } from 'tempo.ts/viem'
  * import { privateKeyToAccount } from 'viem/accounts'
  *
  * const client = createClient({
  *   account: privateKeyToAccount('0x...'),
- *   chain: tempo,
+ *   chain: tempo({ feeToken: '0x20c0000000000000000000000000000000000001' })
  *   transport: http(),
  * })
  *
- * const result = await actions.token.approveSync(client, {
+ * const result = await Actions.token.approveSync(client, {
  *   spender: '0x...',
  *   amount: 100n,
  * })
@@ -199,19 +203,12 @@ export async function approveSync<
   client: Client<Transport, chain, account>,
   parameters: approveSync.Parameters<chain, account>,
 ): Promise<approveSync.ReturnValue> {
-  const {
-    throwOnReceiptRevert = true,
-    token = Addresses.defaultFeeToken,
-    ...rest
-  } = parameters
+  const { throwOnReceiptRevert = true, ...rest } = parameters
   const receipt = await approve.inner(
     writeContractSync,
     client,
     { ...parameters, throwOnReceiptRevert } as never,
-    {
-      ...rest,
-      token,
-    },
+    rest,
   )
   const { args } = approve.extractEvent(receipt.logs)
   return {
@@ -241,6 +238,9 @@ export namespace approveSync {
       receipt: TransactionReceipt
     }
   >
+
+  // TODO: exhaustive error type
+  export type ErrorType = BaseErrorType
 }
 
 /**
@@ -250,16 +250,16 @@ export namespace approveSync {
  * ```ts
  * import { createClient, http } from 'viem'
  * import { tempo } from 'tempo.ts/chains'
- * import * as actions from 'tempo.ts/viem/actions'
+ * import { Actions } from 'tempo.ts/viem'
  * import { privateKeyToAccount } from 'viem/accounts'
  *
  * const client = createClient({
  *   account: privateKeyToAccount('0x...'),
- *   chain: tempo,
+ *   chain: tempo({ feeToken: '0x20c0000000000000000000000000000000000001' })
  *   transport: http(),
  * })
  *
- * const result = await actions.token.burnBlocked(client, {
+ * const result = await Actions.token.burnBlocked(client, {
  *   from: '0x...',
  *   amount: 100n,
  *   token: '0x...',
@@ -297,6 +297,9 @@ export namespace burnBlocked {
 
   export type ReturnValue = WriteContractReturnType
 
+  // TODO: exhaustive error type
+  export type ErrorType = BaseErrorType
+
   /** @internal */
   export async function inner<
     action extends typeof writeContract | typeof writeContractSync,
@@ -327,10 +330,10 @@ export namespace burnBlocked {
    * ```ts
    * import { createClient, http, walletActions } from 'viem'
    * import { tempo } from 'tempo.ts/chains'
-   * import * as actions from 'tempo.ts/viem/actions'
+   * import { Actions } from 'tempo.ts/viem'
    *
    * const client = createClient({
-   *   chain: tempo,
+   *   chain: tempo({ feeToken: '0x20c0000000000000000000000000000000000001' })
    *   transport: http(),
    * }).extend(walletActions)
    *
@@ -382,16 +385,16 @@ export namespace burnBlocked {
  * ```ts
  * import { createClient, http } from 'viem'
  * import { tempo } from 'tempo.ts/chains'
- * import * as actions from 'tempo.ts/viem/actions'
+ * import { Actions } from 'tempo.ts/viem'
  * import { privateKeyToAccount } from 'viem/accounts'
  *
  * const client = createClient({
  *   account: privateKeyToAccount('0x...'),
- *   chain: tempo,
+ *   chain: tempo({ feeToken: '0x20c0000000000000000000000000000000000001' })
  *   transport: http(),
  * })
  *
- * const result = await actions.token.burnBlockedSync(client, {
+ * const result = await Actions.token.burnBlockedSync(client, {
  *   from: '0x...',
  *   amount: 100n,
  *   token: '0x...',
@@ -442,6 +445,9 @@ export namespace burnBlockedSync {
       receipt: TransactionReceipt
     }
   >
+
+  // TODO: exhaustive error type
+  export type ErrorType = BaseErrorType
 }
 
 /**
@@ -451,16 +457,16 @@ export namespace burnBlockedSync {
  * ```ts
  * import { createClient, http } from 'viem'
  * import { tempo } from 'tempo.ts/chains'
- * import * as actions from 'tempo.ts/viem/actions'
+ * import { Actions } from 'tempo.ts/viem'
  * import { privateKeyToAccount } from 'viem/accounts'
  *
  * const client = createClient({
  *   account: privateKeyToAccount('0x...'),
- *   chain: tempo,
+ *   chain: tempo({ feeToken: '0x20c0000000000000000000000000000000000001' })
  *   transport: http(),
  * })
  *
- * const result = await actions.token.burn(client, {
+ * const result = await Actions.token.burn(client, {
  *   amount: 100n,
  *   token: '0x...',
  * })
@@ -497,6 +503,9 @@ export namespace burn {
 
   export type ReturnValue = WriteContractReturnType
 
+  // TODO: exhaustive error type
+  export type ErrorType = BaseErrorType
+
   /** @internal */
   export async function inner<
     action extends typeof writeContract | typeof writeContractSync,
@@ -527,10 +536,10 @@ export namespace burn {
    * ```ts
    * import { createClient, http, walletActions } from 'viem'
    * import { tempo } from 'tempo.ts/chains'
-   * import * as actions from 'tempo.ts/viem/actions'
+   * import { Actions } from 'tempo.ts/viem'
    *
    * const client = createClient({
-   *   chain: tempo,
+   *   chain: tempo({ feeToken: '0x20c0000000000000000000000000000000000001' })
    *   transport: http(),
    * }).extend(walletActions)
    *
@@ -589,16 +598,16 @@ export namespace burn {
  * ```ts
  * import { createClient, http } from 'viem'
  * import { tempo } from 'tempo.ts/chains'
- * import * as actions from 'tempo.ts/viem/actions'
+ * import { Actions } from 'tempo.ts/viem'
  * import { privateKeyToAccount } from 'viem/accounts'
  *
  * const client = createClient({
  *   account: privateKeyToAccount('0x...'),
- *   chain: tempo,
+ *   chain: tempo({ feeToken: '0x20c0000000000000000000000000000000000001' })
  *   transport: http(),
  * })
  *
- * const result = await actions.token.burnSync(client, {
+ * const result = await Actions.token.burnSync(client, {
  *   amount: 100n,
  *   token: '0x...',
  * })
@@ -647,6 +656,9 @@ export namespace burnSync {
       receipt: TransactionReceipt
     }
   >
+
+  // TODO: exhaustive error type
+  export type ErrorType = BaseErrorType
 }
 
 /**
@@ -656,16 +668,16 @@ export namespace burnSync {
  * ```ts
  * import { createClient, http } from 'viem'
  * import { tempo } from 'tempo.ts/chains'
- * import * as actions from 'tempo.ts/viem/actions'
+ * import { Actions } from 'tempo.ts/viem'
  * import { privateKeyToAccount } from 'viem/accounts'
  *
  * const client = createClient({
  *   account: privateKeyToAccount('0x...'),
- *   chain: tempo,
+ *   chain: tempo({ feeToken: '0x20c0000000000000000000000000000000000001' })
  *   transport: http(),
  * })
  *
- * const result = await actions.token.changeTransferPolicy(client, {
+ * const result = await Actions.token.changeTransferPolicy(client, {
  *   token: '0x...',
  *   policyId: 1n,
  * })
@@ -700,6 +712,9 @@ export namespace changeTransferPolicy {
 
   export type ReturnValue = WriteContractReturnType
 
+  // TODO: exhaustive error type
+  export type ErrorType = BaseErrorType
+
   /** @internal */
   export async function inner<
     action extends typeof writeContract | typeof writeContractSync,
@@ -730,10 +745,10 @@ export namespace changeTransferPolicy {
    * ```ts
    * import { createClient, http, walletActions } from 'viem'
    * import { tempo } from 'tempo.ts/chains'
-   * import * as actions from 'tempo.ts/viem/actions'
+   * import { Actions } from 'tempo.ts/viem'
    *
    * const client = createClient({
-   *   chain: tempo,
+   *   chain: tempo({ feeToken: '0x20c0000000000000000000000000000000000001' })
    *   transport: http(),
    * }).extend(walletActions)
    *
@@ -784,16 +799,16 @@ export namespace changeTransferPolicy {
  * ```ts
  * import { createClient, http } from 'viem'
  * import { tempo } from 'tempo.ts/chains'
- * import * as actions from 'tempo.ts/viem/actions'
+ * import { Actions } from 'tempo.ts/viem'
  * import { privateKeyToAccount } from 'viem/accounts'
  *
  * const client = createClient({
  *   account: privateKeyToAccount('0x...'),
- *   chain: tempo,
+ *   chain: tempo({ feeToken: '0x20c0000000000000000000000000000000000001' })
  *   transport: http(),
  * })
  *
- * const result = await actions.token.changeTransferPolicySync(client, {
+ * const result = await Actions.token.changeTransferPolicySync(client, {
  *   token: '0x...',
  *   policyId: 1n,
  * })
@@ -842,6 +857,9 @@ export namespace changeTransferPolicySync {
       receipt: TransactionReceipt
     }
   >
+
+  // TODO: exhaustive error type
+  export type ErrorType = BaseErrorType
 }
 
 /**
@@ -851,16 +869,16 @@ export namespace changeTransferPolicySync {
  * ```ts
  * import { createClient, http } from 'viem'
  * import { tempo } from 'tempo.ts/chains'
- * import * as actions from 'tempo.ts/viem/actions'
+ * import { Actions } from 'tempo.ts/viem'
  * import { privateKeyToAccount } from 'viem/accounts'
  *
  * const client = createClient({
  *   account: privateKeyToAccount('0x...'),
- *   chain: tempo,
+ *   chain: tempo({ feeToken: '0x20c0000000000000000000000000000000000001' })
  *   transport: http(),
  * })
  *
- * const result = await actions.token.create(client, {
+ * const result = await Actions.token.create(client, {
  *   name: 'My Token',
  *   symbol: 'MTK',
  *   currency: 'USD',
@@ -906,6 +924,9 @@ export namespace create {
 
   export type ReturnValue = WriteContractReturnType
 
+  // TODO: exhaustive error type
+  export type ErrorType = BaseErrorType
+
   /** @internal */
   export async function inner<
     action extends typeof writeContract | typeof writeContractSync,
@@ -950,10 +971,10 @@ export namespace create {
    * ```ts
    * import { createClient, http, walletActions } from 'viem'
    * import { tempo } from 'tempo.ts/chains'
-   * import * as actions from 'tempo.ts/viem/actions'
+   * import { Actions } from 'tempo.ts/viem'
    *
    * const client = createClient({
-   *   chain: tempo,
+   *   chain: tempo({ feeToken: '0x20c0000000000000000000000000000000000001' })
    *   transport: http(),
    * }).extend(walletActions)
    *
@@ -977,7 +998,7 @@ export namespace create {
       name,
       symbol,
       currency,
-      quoteToken = Addresses.defaultQuoteToken,
+      quoteToken = Addresses.linkingUsd,
       admin,
     } = args
     return defineCall({
@@ -1013,16 +1034,16 @@ export namespace create {
  * ```ts
  * import { createClient, http } from 'viem'
  * import { tempo } from 'tempo.ts/chains'
- * import * as actions from 'tempo.ts/viem/actions'
+ * import { Actions } from 'tempo.ts/viem'
  * import { privateKeyToAccount } from 'viem/accounts'
  *
  * const client = createClient({
  *   account: privateKeyToAccount('0x...'),
- *   chain: tempo,
+ *   chain: tempo({ feeToken: '0x20c0000000000000000000000000000000000001' })
  *   transport: http(),
  * })
  *
- * const result = await actions.token.createSync(client, {
+ * const result = await Actions.token.createSync(client, {
  *   name: 'My Token',
  *   symbol: 'MTK',
  *   currency: 'USD',
@@ -1072,196 +1093,9 @@ export namespace createSync {
       receipt: TransactionReceipt
     }
   >
-}
 
-/**
- * Finalizes the quote token update for a TIP20 token.
- *
- * @example
- * ```ts
- * import { createClient, http } from 'viem'
- * import { tempo } from 'tempo.ts/chains'
- * import * as actions from 'tempo.ts/viem/actions'
- * import { privateKeyToAccount } from 'viem/accounts'
- *
- * const client = createClient({
- *   account: privateKeyToAccount('0x...'),
- *   chain: tempo,
- *   transport: http(),
- * })
- *
- * const result = await actions.token.finalizeUpdateQuoteToken(client, {
- *   token: '0x...',
- * })
- * ```
- *
- * @param client - Client.
- * @param parameters - Parameters.
- * @returns The transaction hash.
- */
-export async function finalizeUpdateQuoteToken<
-  chain extends Chain | undefined,
-  account extends Account | undefined,
->(
-  client: Client<Transport, chain, account>,
-  parameters: finalizeUpdateQuoteToken.Parameters<chain, account>,
-): Promise<finalizeUpdateQuoteToken.ReturnValue> {
-  return finalizeUpdateQuoteToken.inner(writeContract, client, parameters)
-}
-
-export namespace finalizeUpdateQuoteToken {
-  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
-
-  /** @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: finalizeUpdateQuoteToken.Parameters<chain, account>,
-  ): Promise<ReturnType<action>> {
-    const { token, ...rest } = parameters
-    const call = finalizeUpdateQuoteToken.call({ token })
-    return (await action(client, {
-      ...rest,
-      ...call,
-    } as never)) as never
-  }
-
-  /**
-   * Defines a call to the `finalizeQuoteTokenUpdate` 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 * as actions from 'tempo.ts/viem/actions'
-   *
-   * const client = createClient({
-   *   chain: tempo,
-   *   transport: http(),
-   * }).extend(walletActions)
-   *
-   * const { result } = await client.sendCalls({
-   *   calls: [
-   *     actions.token.finalizeUpdateQuoteToken.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: 'finalizeQuoteTokenUpdate',
-      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: 'QuoteTokenUpdateFinalized',
-    })
-    if (!log) throw new Error('`QuoteTokenUpdateFinalized` event not found.')
-    return log
-  }
-}
-
-/**
- * Finalizes the quote token update for a TIP20 token.
- *
- * @example
- * ```ts
- * import { createClient, http } from 'viem'
- * import { tempo } from 'tempo.ts/chains'
- * import * as actions from 'tempo.ts/viem/actions'
- * import { privateKeyToAccount } from 'viem/accounts'
- *
- * const client = createClient({
- *   account: privateKeyToAccount('0x...'),
- *   chain: tempo,
- *   transport: http(),
- * })
- *
- * const result = await actions.token.finalizeUpdateQuoteTokenSync(client, {
- *   token: '0x...',
- * })
- * ```
- *
- * @param client - Client.
- * @param parameters - Parameters.
- * @returns The transaction receipt and event data.
- */
-export async function finalizeUpdateQuoteTokenSync<
-  chain extends Chain | undefined,
-  account extends Account | undefined,
->(
-  client: Client<Transport, chain, account>,
-  parameters: finalizeUpdateQuoteTokenSync.Parameters<chain, account>,
-): Promise<finalizeUpdateQuoteTokenSync.ReturnValue> {
-  const receipt = await finalizeUpdateQuoteToken.inner(
-    writeContractSync,
-    client,
-    parameters,
-  )
-  const { args } = finalizeUpdateQuoteToken.extractEvent(receipt.logs)
-  return {
-    ...args,
-    receipt,
-  } as never
-}
-
-export namespace finalizeUpdateQuoteTokenSync {
-  export type Parameters<
-    chain extends Chain | undefined = Chain | undefined,
-    account extends Account | undefined = Account | undefined,
-  > = finalizeUpdateQuoteToken.Parameters<chain, account>
-
-  export type Args = finalizeUpdateQuoteToken.Args
-
-  export type ReturnValue = Compute<
-    GetEventArgs<
-      typeof Abis.tip20,
-      'QuoteTokenUpdateFinalized',
-      {
-        IndexedOnly: false
-        Required: true
-      }
-    > & {
-      receipt: TransactionReceipt
-    }
-  >
+  // TODO: exhaustive error type
+  export type ErrorType = BaseErrorType
 }
 
 /**
@@ -1271,16 +1105,16 @@ export namespace finalizeUpdateQuoteTokenSync {
  * ```ts
  * import { createClient, http } from 'viem'
  * import { tempo } from 'tempo.ts/chains'
- * import * as actions from 'tempo.ts/viem/actions'
+ * import { Actions } from 'tempo.ts/viem'
  * import { privateKeyToAccount } from 'viem/accounts'
  *
  * const client = createClient({
  *   account: privateKeyToAccount('0x...'),
- *   chain: tempo,
+ *   chain: tempo({ feeToken: '0x20c0000000000000000000000000000000000001' })
  *   transport: http(),
  * })
  *
- * const allowance = await actions.token.getAllowance(client, {
+ * const allowance = await Actions.token.getAllowance(client, {
  *   spender: '0x...',
  * })
  * ```
@@ -1315,8 +1149,8 @@ export namespace getAllowance {
     account: Address
     /** Address of the spender. */
     spender: Address
-    /** Address or ID of the TIP20 token. @default `Addresses.defaultFeeToken` */
-    token?: TokenId.TokenIdOrAddress | undefined
+    /** Address or ID of the TIP20 token. */
+    token: TokenId.TokenIdOrAddress
   }
 
   export type ReturnValue = ReadContractReturnType<
@@ -1332,7 +1166,7 @@ export namespace getAllowance {
    * @returns The call.
    */
   export function call(args: Args) {
-    const { account, spender, token = Addresses.defaultFeeToken } = args
+    const { account, spender, token } = args
     return defineCall({
       address: TokenId.toAddress(token),
       abi: Abis.tip20,
@@ -1349,16 +1183,16 @@ export namespace getAllowance {
  * ```ts
  * import { createClient, http } from 'viem'
  * import { tempo } from 'tempo.ts/chains'
- * import * as actions from 'tempo.ts/viem/actions'
+ * import { Actions } from 'tempo.ts/viem'
  * import { privateKeyToAccount } from 'viem/accounts'
  *
  * const client = createClient({
  *   account: privateKeyToAccount('0x...'),
- *   chain: tempo,
+ *   chain: tempo({ feeToken: '0x20c0000000000000000000000000000000000001' })
  *   transport: http(),
  * })
  *
- * const balance = await actions.token.getBalance(client, {
+ * const balance = await Actions.token.getBalance(client, {
  *   token: '0x...',
  * })
  * ```
@@ -1372,11 +1206,9 @@ export async function getBalance<
   account extends Account | undefined,
 >(
   client: Client<Transport, chain, account>,
-  ...parameters: account extends Account
-    ? [getBalance.Parameters<account>] | []
-    : [getBalance.Parameters<account>]
+  parameters: getBalance.Parameters<account>,
 ): Promise<getBalance.ReturnValue> {
-  const { account = client.account, ...rest } = parameters[0] ?? {}
+  const { account = client.account, ...rest } = parameters
   const address = account ? parseAccount(account).address : undefined
   if (!address) throw new Error('account is required.')
   return readContract(client, {
@@ -1393,8 +1225,8 @@ export namespace getBalance {
   export type Args = {
     /** Account address. */
     account: Address
-    /** Address or ID of the TIP20 token. @default `Addresses.defaultFeeToken` */
-    token?: TokenId.TokenIdOrAddress | undefined
+    /** Address or ID of the TIP20 token. */
+    token: TokenId.TokenIdOrAddress
   }
 
   export type ReturnValue = ReadContractReturnType<
@@ -1410,7 +1242,7 @@ export namespace getBalance {
    * @returns The call.
    */
   export function call(args: Args) {
-    const { account, token = Addresses.defaultFeeToken } = args
+    const { account, token } = args
     return defineCall({
       address: TokenId.toAddress(token),
       abi: Abis.tip20,
@@ -1427,16 +1259,16 @@ export namespace getBalance {
  * ```ts
  * import { createClient, http } from 'viem'
  * import { tempo } from 'tempo.ts/chains'
- * import * as actions from 'tempo.ts/viem/actions'
+ * import { Actions } from 'tempo.ts/viem'
  * import { privateKeyToAccount } from 'viem/accounts'
  *
  * const client = createClient({
  *   account: privateKeyToAccount('0x...'),
- *   chain: tempo,
+ *   chain: tempo({ feeToken: '0x20c0000000000000000000000000000000000001' })
  *   transport: http(),
  * })
  *
- * const metadata = await actions.token.getMetadata(client, {
+ * const metadata = await Actions.token.getMetadata(client, {
  *   token: '0x...',
  * })
  * ```
@@ -1447,13 +1279,13 @@ export namespace getBalance {
  */
 export async function getMetadata<chain extends Chain | undefined>(
   client: Client<Transport, chain>,
-  parameters: getMetadata.Parameters = {},
+  parameters: getMetadata.Parameters,
 ): Promise<getMetadata.ReturnValue> {
-  const { token = Addresses.defaultFeeToken, ...rest } = parameters
+  const { token, ...rest } = parameters
   const address = TokenId.toAddress(token)
   const abi = Abis.tip20
 
-  if (TokenId.from(token) === TokenId.fromAddress(Addresses.defaultQuoteToken))
+  if (TokenId.from(token) === TokenId.fromAddress(Addresses.linkingUsd))
     return multicall(client, {
       ...rest,
       contracts: [
@@ -1571,8 +1403,8 @@ export async function getMetadata<chain extends Chain | undefined>(
 
 export declare namespace getMetadata {
   export type Parameters = {
-    /** Address or ID of the TIP20 token. @default `Addresses.defaultFeeToken` */
-    token?: TokenId.TokenIdOrAddress | undefined
+    /** Address or ID of the TIP20 token. */
+    token: TokenId.TokenIdOrAddress
   }
 
   export type ReturnValue = Compute<{
@@ -1624,6 +1456,73 @@ export declare namespace getMetadata {
   }>
 }
 
+/**
+ * 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: 'minter',
+ *   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.
  *
@@ -1631,14 +1530,14 @@ export declare namespace getMetadata {
  * ```ts
  * import { createClient, http } from 'viem'
  * import { tempo } from 'tempo.ts/chains'
- * import * as actions from 'tempo.ts/viem/actions'
+ * import { Actions } from 'tempo.ts/viem'
  *
  * const client = createClient({
- *   chain: tempo,
+ *   chain: tempo({ feeToken: '0x20c0000000000000000000000000000000000001' })
  *   transport: http(),
  * })
  *
- * const hasRole = await actions.token.hasRole(client, {
+ * const hasRole = await Actions.token.hasRole(client, {
  *   account: '0x...',
  *   role: 'issuer',
  *   token: '0x...',
@@ -1709,16 +1608,16 @@ export namespace hasRole {
  * ```ts
  * import { createClient, http } from 'viem'
  * import { tempo } from 'tempo.ts/chains'
- * import * as actions from 'tempo.ts/viem/actions'
+ * import { Actions } from 'tempo.ts/viem'
  * import { privateKeyToAccount } from 'viem/accounts'
  *
  * const client = createClient({
  *   account: privateKeyToAccount('0x...'),
- *   chain: tempo,
+ *   chain: tempo({ feeToken: '0x20c0000000000000000000000000000000000001' })
  *   transport: http(),
  * })
  *
- * const result = await actions.token.grantRoles(client, {
+ * const result = await Actions.token.grantRoles(client, {
  *   token: '0x...',
  *   to: '0x...',
  *   roles: ['issuer'],
@@ -1760,6 +1659,9 @@ export namespace grantRoles {
 
   export type ReturnValue = WriteContractReturnType
 
+  // TODO: exhaustive error type
+  export type ErrorType = BaseErrorType
+
   /** @internal */
   export async function inner<
     action extends typeof sendTransaction | typeof sendTransactionSync,
@@ -1794,10 +1696,10 @@ export namespace grantRoles {
    * ```ts
    * import { createClient, http, walletActions } from 'viem'
    * import { tempo } from 'tempo.ts/chains'
-   * import * as actions from 'tempo.ts/viem/actions'
+   * import { Actions } from 'tempo.ts/viem'
    *
    * const client = createClient({
-   *   chain: tempo,
+   *   chain: tempo({ feeToken: '0x20c0000000000000000000000000000000000001' })
    *   transport: http(),
    * }).extend(walletActions)
    *
@@ -1851,16 +1753,16 @@ export namespace grantRoles {
  * ```ts
  * import { createClient, http } from 'viem'
  * import { tempo } from 'tempo.ts/chains'
- * import * as actions from 'tempo.ts/viem/actions'
+ * import { Actions } from 'tempo.ts/viem'
  * import { privateKeyToAccount } from 'viem/accounts'
  *
  * const client = createClient({
  *   account: privateKeyToAccount('0x...'),
- *   chain: tempo,
+ *   chain: tempo({ feeToken: '0x20c0000000000000000000000000000000000001' })
  *   transport: http(),
  * })
  *
- * const result = await actions.token.grantRolesSync(client, {
+ * const result = await Actions.token.grantRolesSync(client, {
  *   token: '0x...',
  *   to: '0x...',
  *   roles: ['minter'],
@@ -1907,6 +1809,9 @@ export namespace grantRolesSync {
       { IndexedOnly: false; Required: true }
     >[]
   }
+
+  // TODO: exhaustive error type
+  export type ErrorType = BaseErrorType
 }
 
 /**
@@ -1916,16 +1821,16 @@ export namespace grantRolesSync {
  * ```ts
  * import { createClient, http } from 'viem'
  * import { tempo } from 'tempo.ts/chains'
- * import * as actions from 'tempo.ts/viem/actions'
+ * import { Actions } from 'tempo.ts/viem'
  * import { privateKeyToAccount } from 'viem/accounts'
  *
  * const client = createClient({
  *   account: privateKeyToAccount('0x...'),
- *   chain: tempo,
+ *   chain: tempo({ feeToken: '0x20c0000000000000000000000000000000000001' })
  *   transport: http(),
  * })
  *
- * const result = await actions.token.mint(client, {
+ * const result = await Actions.token.mint(client, {
  *   to: '0x...',
  *   amount: 100n,
  *   token: '0x...',
@@ -1965,6 +1870,9 @@ export namespace mint {
 
   export type ReturnValue = WriteContractReturnType
 
+  // TODO: exhaustive error type
+  export type ErrorType = BaseErrorType
+
   /** @internal */
   export async function inner<
     action extends typeof writeContract | typeof writeContractSync,
@@ -1994,10 +1902,10 @@ export namespace mint {
    * ```ts
    * import { createClient, http, walletActions } from 'viem'
    * import { tempo } from 'tempo.ts/chains'
-   * import * as actions from 'tempo.ts/viem/actions'
+   * import { Actions } from 'tempo.ts/viem'
    *
    * const client = createClient({
-   *   chain: tempo,
+   *   chain: tempo({ feeToken: '0x20c0000000000000000000000000000000000001' })
    *   transport: http(),
    * }).extend(walletActions)
    *
@@ -2057,16 +1965,16 @@ export namespace mint {
  * ```ts
  * import { createClient, http } from 'viem'
  * import { tempo } from 'tempo.ts/chains'
- * import * as actions from 'tempo.ts/viem/actions'
+ * import { Actions } from 'tempo.ts/viem'
  * import { privateKeyToAccount } from 'viem/accounts'
  *
  * const client = createClient({
  *   account: privateKeyToAccount('0x...'),
- *   chain: tempo,
+ *   chain: tempo({ feeToken: '0x20c0000000000000000000000000000000000001' })
  *   transport: http(),
  * })
  *
- * const result = await actions.token.mintSync(client, {
+ * const result = await Actions.token.mintSync(client, {
  *   to: '0x...',
  *   amount: 100n,
  *   token: '0x...',
@@ -2114,217 +2022,31 @@ export namespace mintSync {
       }
     > & {
       receipt: TransactionReceipt
-    }
-  >
-}
-
-/**
- * Pauses a TIP20 token.
- *
- * @example
- * ```ts
- * import { createClient, http } from 'viem'
- * import { tempo } from 'tempo.ts/chains'
- * import * as actions from 'tempo.ts/viem/actions'
- * import { privateKeyToAccount } from 'viem/accounts'
- *
- * const client = createClient({
- *   account: privateKeyToAccount('0x...'),
- *   chain: tempo,
- *   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
-
-  /** @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 * as actions from 'tempo.ts/viem/actions'
-   *
-   * const client = createClient({
-   *   chain: tempo,
-   *   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 * as actions from 'tempo.ts/viem/actions'
- * import { privateKeyToAccount } from 'viem/accounts'
- *
- * const client = createClient({
- *   account: privateKeyToAccount('0x...'),
- *   chain: tempo,
- *   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
 }
 
 /**
- * Approves a spender using a signed permit.
+ * Pauses a TIP20 token.
  *
  * @example
  * ```ts
  * import { createClient, http } from 'viem'
  * import { tempo } from 'tempo.ts/chains'
- * import * as actions from 'tempo.ts/viem/actions'
+ * import { Actions } from 'tempo.ts/viem'
  * import { privateKeyToAccount } from 'viem/accounts'
  *
  * const client = createClient({
  *   account: privateKeyToAccount('0x...'),
- *   chain: tempo,
+ *   chain: tempo({ feeToken: '0x20c0000000000000000000000000000000000001' })
  *   transport: http(),
  * })
  *
- * const result = await actions.token.permit(client, {
- *   owner: '0x...',
- *   spender: '0x...',
- *   value: 100n,
- *   deadline: 1234567890n,
- *   signature: { r: 0n, s: 0n, yParity: 0 },
+ * const result = await Actions.token.pause(client, {
+ *   token: '0x...',
  * })
  * ```
  *
@@ -2332,39 +2054,32 @@ export namespace pauseSync {
  * @param parameters - Parameters.
  * @returns The transaction hash.
  */
-export async function permit<
+export async function pause<
   chain extends Chain | undefined,
   account extends Account | undefined,
 >(
   client: Client<Transport, chain, account>,
-  parameters: permit.Parameters<chain, account>,
-): Promise<permit.ReturnValue> {
-  return permit.inner(writeContract, client, parameters)
+  parameters: pause.Parameters<chain, account>,
+): Promise<pause.ReturnValue> {
+  return pause.inner(writeContract, client, parameters)
 }
 
-export namespace permit {
+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 = {
-    /** Deadline for the permit. */
-    deadline: bigint
-    /** Address of the owner. */
-    owner: Address
-    /** Signature. */
-    signature: Signature.Signature
-    /** Address of the spender. */
-    spender: Address
-    /** Address or ID of the TIP20 token. @default `Addresses.defaultFeeToken` */
-    token?: TokenId.TokenIdOrAddress | undefined
-    /** Amount to approve. */
-    value: 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,
@@ -2373,18 +2088,10 @@ export namespace permit {
   >(
     action: action,
     client: Client<Transport, chain, account>,
-    parameters: permit.Parameters<chain, account>,
+    parameters: pause.Parameters<chain, account>,
   ): Promise<ReturnType<action>> {
-    const { owner, spender, value, deadline, signature, token, ...rest } =
-      parameters
-    const call = permit.call({
-      owner,
-      spender,
-      value,
-      deadline,
-      signature,
-      token,
-    })
+    const { token, ...rest } = parameters
+    const call = pause.call({ token })
     return (await action(client, {
       ...rest,
       ...call,
@@ -2392,7 +2099,7 @@ export namespace permit {
   }
 
   /**
-   * Defines a call to the `permit` function.
+   * 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
@@ -2403,22 +2110,17 @@ export namespace permit {
    * ```ts
    * import { createClient, http, walletActions } from 'viem'
    * import { tempo } from 'tempo.ts/chains'
-   * import * as actions from 'tempo.ts/viem/actions'
+   * import { Actions } from 'tempo.ts/viem'
    *
    * const client = createClient({
-   *   chain: tempo,
+   *   chain: tempo({ feeToken: '0x20c0000000000000000000000000000000000001' })
    *   transport: http(),
    * }).extend(walletActions)
    *
    * const { result } = await client.sendCalls({
    *   calls: [
-   *     actions.token.permit.call({
-   *       owner: '0x20c0...beef',
-   *       spender: '0x20c0...babe',
-   *       value: 100n,
-   *       deadline: 1234567890n,
-   *       signature: { r: 0n, s: 0n, yParity: 0 },
-   *       token: '0x20c0...cafe',
+   *     actions.token.pause.call({
+   *       token: '0x20c0...babe',
    *     }),
    *   ]
    * })
@@ -2428,29 +2130,12 @@ export namespace permit {
    * @returns The call.
    */
   export function call(args: Args) {
-    const {
-      owner,
-      spender,
-      value,
-      deadline,
-      signature,
-      token = Addresses.defaultFeeToken,
-    } = args
-    const { r, s, yParity } = Signature.from(signature)
-    const v = Signature.yParityToV(yParity)
+    const { token } = args
     return defineCall({
       address: TokenId.toAddress(token),
       abi: Abis.tip20,
-      functionName: 'permit',
-      args: [
-        owner,
-        spender,
-        value,
-        deadline,
-        v,
-        Hex.trimLeft(Hex.fromNumber(r!)),
-        Hex.trimLeft(Hex.fromNumber(s!)),
-      ],
+      functionName: 'pause',
+      args: [],
     })
   }
 
@@ -2464,35 +2149,31 @@ export namespace permit {
     const [log] = parseEventLogs({
       abi: Abis.tip20,
       logs,
-      eventName: 'Approval',
+      eventName: 'PauseStateUpdate',
     })
-    if (!log) throw new Error('`Approval` event not found.')
+    if (!log) throw new Error('`PauseStateUpdate` event not found.')
     return log
   }
 }
 
 /**
- * Approves a spender using a signed permit.
+ * Pauses a TIP20 token.
  *
  * @example
  * ```ts
  * import { createClient, http } from 'viem'
  * import { tempo } from 'tempo.ts/chains'
- * import * as actions from 'tempo.ts/viem/actions'
+ * import { Actions } from 'tempo.ts/viem'
  * import { privateKeyToAccount } from 'viem/accounts'
  *
  * const client = createClient({
  *   account: privateKeyToAccount('0x...'),
- *   chain: tempo,
+ *   chain: tempo({ feeToken: '0x20c0000000000000000000000000000000000001' })
  *   transport: http(),
  * })
  *
- * const result = await actions.token.permitSync(client, {
- *   owner: '0x...',
- *   spender: '0x...',
- *   value: 100n,
- *   deadline: 1234567890n,
- *   signature: { r: 0n, s: 0n, yParity: 0 },
+ * const result = await Actions.token.pauseSync(client, {
+ *   token: '0x...',
  * })
  * ```
  *
@@ -2500,40 +2181,43 @@ export namespace permit {
  * @param parameters - Parameters.
  * @returns The transaction receipt and event data.
  */
-export async function permitSync<
+export async function pauseSync<
   chain extends Chain | undefined,
   account extends Account | undefined,
 >(
   client: Client<Transport, chain, account>,
-  parameters: permitSync.Parameters<chain, account>,
-): Promise<permitSync.ReturnValue> {
+  parameters: pauseSync.Parameters<chain, account>,
+): Promise<pauseSync.ReturnValue> {
   const { throwOnReceiptRevert = true, ...rest } = parameters
-  const receipt = await permit.inner(writeContractSync, client, {
+  const receipt = await pause.inner(writeContractSync, client, {
     ...rest,
     throwOnReceiptRevert,
   } as never)
-  const { args } = permit.extractEvent(receipt.logs)
+  const { args } = pause.extractEvent(receipt.logs)
   return {
     ...args,
     receipt,
-  } as never
+  }
 }
 
-export namespace permitSync {
+export namespace pauseSync {
   export type Parameters<
     chain extends Chain | undefined = Chain | undefined,
     account extends Account | undefined = Account | undefined,
-  > = permit.Parameters<chain, account>
+  > = pause.Parameters<chain, account>
 
-  export type Args = permit.Args
+  export type Args = pause.Args
 
   export type ReturnValue = GetEventArgs<
     typeof Abis.tip20,
-    'Approval',
+    'PauseStateUpdate',
     { IndexedOnly: false; Required: true }
   > & {
     receipt: TransactionReceipt
   }
+
+  // TODO: exhaustive error type
+  export type ErrorType = BaseErrorType
 }
 
 /**
@@ -2543,16 +2227,16 @@ export namespace permitSync {
  * ```ts
  * import { createClient, http } from 'viem'
  * import { tempo } from 'tempo.ts/chains'
- * import * as actions from 'tempo.ts/viem/actions'
+ * import { Actions } from 'tempo.ts/viem'
  * import { privateKeyToAccount } from 'viem/accounts'
  *
  * const client = createClient({
  *   account: privateKeyToAccount('0x...'),
- *   chain: tempo,
+ *   chain: tempo({ feeToken: '0x20c0000000000000000000000000000000000001' })
  *   transport: http(),
  * })
  *
- * const result = await actions.token.renounceRoles(client, {
+ * const result = await Actions.token.renounceRoles(client, {
  *   token: '0x...',
  *   roles: ['minter'],
  * })
@@ -2591,6 +2275,9 @@ export namespace renounceRoles {
 
   export type ReturnValue = WriteContractReturnType
 
+  // TODO: exhaustive error type
+  export type ErrorType = BaseErrorType
+
   /** @internal */
   export async function inner<
     action extends typeof sendTransaction | typeof sendTransactionSync,
@@ -2625,10 +2312,10 @@ export namespace renounceRoles {
    * ```ts
    * import { createClient, http, walletActions } from 'viem'
    * import { tempo } from 'tempo.ts/chains'
-   * import * as actions from 'tempo.ts/viem/actions'
+   * import { Actions } from 'tempo.ts/viem'
    *
    * const client = createClient({
-   *   chain: tempo,
+   *   chain: tempo({ feeToken: '0x20c0000000000000000000000000000000000001' })
    *   transport: http(),
    * }).extend(walletActions)
    *
@@ -2681,16 +2368,16 @@ export namespace renounceRoles {
  * ```ts
  * import { createClient, http } from 'viem'
  * import { tempo } from 'tempo.ts/chains'
- * import * as actions from 'tempo.ts/viem/actions'
+ * import { Actions } from 'tempo.ts/viem'
  * import { privateKeyToAccount } from 'viem/accounts'
  *
  * const client = createClient({
  *   account: privateKeyToAccount('0x...'),
- *   chain: tempo,
+ *   chain: tempo({ feeToken: '0x20c0000000000000000000000000000000000001' })
  *   transport: http(),
  * })
  *
- * const result = await actions.token.renounceRolesSync(client, {
+ * const result = await Actions.token.renounceRolesSync(client, {
  *   token: '0x...',
  *   roles: ['minter'],
  * })
@@ -2736,6 +2423,9 @@ export namespace renounceRolesSync {
       { IndexedOnly: false; Required: true }
     >[]
   }
+
+  // TODO: exhaustive error type
+  export type ErrorType = BaseErrorType
 }
 
 /**
@@ -2745,16 +2435,16 @@ export namespace renounceRolesSync {
  * ```ts
  * import { createClient, http } from 'viem'
  * import { tempo } from 'tempo.ts/chains'
- * import * as actions from 'tempo.ts/viem/actions'
+ * import { Actions } from 'tempo.ts/viem'
  * import { privateKeyToAccount } from 'viem/accounts'
  *
  * const client = createClient({
  *   account: privateKeyToAccount('0x...'),
- *   chain: tempo,
+ *   chain: tempo({ feeToken: '0x20c0000000000000000000000000000000000001' })
  *   transport: http(),
  * })
  *
- * const result = await actions.token.revokeRoles(client, {
+ * const result = await Actions.token.revokeRoles(client, {
  *   token: '0x...',
  *   from: '0x...',
  *   roles: ['minter'],
@@ -2796,6 +2486,9 @@ export namespace revokeRoles {
 
   export type ReturnValue = WriteContractReturnType
 
+  // TODO: exhaustive error type
+  export type ErrorType = BaseErrorType
+
   /** @internal */
   export async function inner<
     action extends typeof sendTransaction | typeof sendTransactionSync,
@@ -2830,10 +2523,10 @@ export namespace revokeRoles {
    * ```ts
    * import { createClient, http, walletActions } from 'viem'
    * import { tempo } from 'tempo.ts/chains'
-   * import * as actions from 'tempo.ts/viem/actions'
+   * import { Actions } from 'tempo.ts/viem'
    *
    * const client = createClient({
-   *   chain: tempo,
+   *   chain: tempo({ feeToken: '0x20c0000000000000000000000000000000000001' })
    *   transport: http(),
    * }).extend(walletActions)
    *
@@ -2887,16 +2580,16 @@ export namespace revokeRoles {
  * ```ts
  * import { createClient, http } from 'viem'
  * import { tempo } from 'tempo.ts/chains'
- * import * as actions from 'tempo.ts/viem/actions'
+ * import { Actions } from 'tempo.ts/viem'
  * import { privateKeyToAccount } from 'viem/accounts'
  *
  * const client = createClient({
  *   account: privateKeyToAccount('0x...'),
- *   chain: tempo,
+ *   chain: tempo({ feeToken: '0x20c0000000000000000000000000000000000001' })
  *   transport: http(),
  * })
  *
- * const result = await actions.token.revokeRolesSync(client, {
+ * const result = await Actions.token.revokeRolesSync(client, {
  *   token: '0x...',
  *   from: '0x...',
  *   roles: ['minter'],
@@ -2943,6 +2636,9 @@ export namespace revokeRolesSync {
       { IndexedOnly: false; Required: true }
     >[]
   }
+
+  // TODO: exhaustive error type
+  export type ErrorType = BaseErrorType
 }
 
 /**
@@ -2952,16 +2648,16 @@ export namespace revokeRolesSync {
  * ```ts
  * import { createClient, http } from 'viem'
  * import { tempo } from 'tempo.ts/chains'
- * import * as actions from 'tempo.ts/viem/actions'
+ * import { Actions } from 'tempo.ts/viem'
  * import { privateKeyToAccount } from 'viem/accounts'
  *
  * const client = createClient({
  *   account: privateKeyToAccount('0x...'),
- *   chain: tempo,
+ *   chain: tempo({ feeToken: '0x20c0000000000000000000000000000000000001' })
  *   transport: http(),
  * })
  *
- * const result = await actions.token.setSupplyCap(client, {
+ * const result = await Actions.token.setSupplyCap(client, {
  *   token: '0x...',
  *   supplyCap: 1000000n,
  * })
@@ -2996,6 +2692,9 @@ export namespace setSupplyCap {
 
   export type ReturnValue = WriteContractReturnType
 
+  // TODO: exhaustive error type
+  export type ErrorType = BaseErrorType
+
   /** @internal */
   export async function inner<
     action extends typeof writeContract | typeof writeContractSync,
@@ -3026,10 +2725,10 @@ export namespace setSupplyCap {
    * ```ts
    * import { createClient, http, walletActions } from 'viem'
    * import { tempo } from 'tempo.ts/chains'
-   * import * as actions from 'tempo.ts/viem/actions'
+   * import { Actions } from 'tempo.ts/viem'
    *
    * const client = createClient({
-   *   chain: tempo,
+   *   chain: tempo({ feeToken: '0x20c0000000000000000000000000000000000001' })
    *   transport: http(),
    * }).extend(walletActions)
    *
@@ -3080,16 +2779,16 @@ export namespace setSupplyCap {
  * ```ts
  * import { createClient, http } from 'viem'
  * import { tempo } from 'tempo.ts/chains'
- * import * as actions from 'tempo.ts/viem/actions'
+ * import { Actions } from 'tempo.ts/viem'
  * import { privateKeyToAccount } from 'viem/accounts'
  *
  * const client = createClient({
  *   account: privateKeyToAccount('0x...'),
- *   chain: tempo,
+ *   chain: tempo({ feeToken: '0x20c0000000000000000000000000000000000001' })
  *   transport: http(),
  * })
  *
- * const result = await actions.token.setSupplyCapSync(client, {
+ * const result = await Actions.token.setSupplyCapSync(client, {
  *   token: '0x...',
  *   supplyCap: 1000000n,
  * })
@@ -3133,6 +2832,9 @@ export namespace setSupplyCapSync {
   > & {
     receipt: TransactionReceipt
   }
+
+  // TODO: exhaustive error type
+  export type ErrorType = BaseErrorType
 }
 
 /**
@@ -3142,16 +2844,16 @@ export namespace setSupplyCapSync {
  * ```ts
  * import { createClient, http } from 'viem'
  * import { tempo } from 'tempo.ts/chains'
- * import * as actions from 'tempo.ts/viem/actions'
+ * import { Actions } from 'tempo.ts/viem'
  * import { privateKeyToAccount } from 'viem/accounts'
  *
  * const client = createClient({
  *   account: privateKeyToAccount('0x...'),
- *   chain: tempo,
+ *   chain: tempo({ feeToken: '0x20c0000000000000000000000000000000000001' })
  *   transport: http(),
  * })
  *
- * const result = await actions.token.setRoleAdmin(client, {
+ * const result = await Actions.token.setRoleAdmin(client, {
  *   token: '0x...',
  *   role: 'minter',
  *   adminRole: 'admin',
@@ -3189,6 +2891,9 @@ export namespace setRoleAdmin {
 
   export type ReturnValue = WriteContractReturnType
 
+  // TODO: exhaustive error type
+  export type ErrorType = BaseErrorType
+
   /** @internal */
   export async function inner<
     action extends typeof writeContract | typeof writeContractSync,
@@ -3219,10 +2924,10 @@ export namespace setRoleAdmin {
    * ```ts
    * import { createClient, http, walletActions } from 'viem'
    * import { tempo } from 'tempo.ts/chains'
-   * import * as actions from 'tempo.ts/viem/actions'
+   * import { Actions } from 'tempo.ts/viem'
    *
    * const client = createClient({
-   *   chain: tempo,
+   *   chain: tempo({ feeToken: '0x20c0000000000000000000000000000000000001' })
    *   transport: http(),
    * }).extend(walletActions)
    *
@@ -3276,16 +2981,16 @@ export namespace setRoleAdmin {
  * ```ts
  * import { createClient, http } from 'viem'
  * import { tempo } from 'tempo.ts/chains'
- * import * as actions from 'tempo.ts/viem/actions'
+ * import { Actions } from 'tempo.ts/viem'
  * import { privateKeyToAccount } from 'viem/accounts'
  *
  * const client = createClient({
  *   account: privateKeyToAccount('0x...'),
- *   chain: tempo,
+ *   chain: tempo({ feeToken: '0x20c0000000000000000000000000000000000001' })
  *   transport: http(),
  * })
  *
- * const result = await actions.token.setRoleAdminSync(client, {
+ * const result = await Actions.token.setRoleAdminSync(client, {
  *   token: '0x...',
  *   role: 'minter',
  *   adminRole: 'admin',
@@ -3330,6 +3035,9 @@ export namespace setRoleAdminSync {
   > & {
     receipt: TransactionReceipt
   }
+
+  // TODO: exhaustive error type
+  export type ErrorType = BaseErrorType
 }
 
 /**
@@ -3339,16 +3047,16 @@ export namespace setRoleAdminSync {
  * ```ts
  * import { createClient, http } from 'viem'
  * import { tempo } from 'tempo.ts/chains'
- * import * as actions from 'tempo.ts/viem/actions'
+ * import { Actions } from 'tempo.ts/viem'
  * import { privateKeyToAccount } from 'viem/accounts'
  *
  * const client = createClient({
  *   account: privateKeyToAccount('0x...'),
- *   chain: tempo,
+ *   chain: tempo({ feeToken: '0x20c0000000000000000000000000000000000001' })
  *   transport: http(),
  * })
  *
- * const result = await actions.token.transfer(client, {
+ * const result = await Actions.token.transfer(client, {
  *   to: '0x...',
  *   amount: 100n,
  * })
@@ -3381,14 +3089,17 @@ export namespace transfer {
     from?: Address | undefined
     /** Memo to include in the transfer. */
     memo?: Hex.Hex | undefined
-    /** Address or ID of the TIP20 token. @default `Addresses.defaultFeeToken` */
-    token?: TokenId.TokenIdOrAddress | 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,
@@ -3419,10 +3130,10 @@ export namespace transfer {
    * ```ts
    * import { createClient, http, walletActions } from 'viem'
    * import { tempo } from 'tempo.ts/chains'
-   * import * as actions from 'tempo.ts/viem/actions'
+   * import { Actions } from 'tempo.ts/viem'
    *
    * const client = createClient({
-   *   chain: tempo,
+   *   chain: tempo({ feeToken: '0x20c0000000000000000000000000000000000001' })
    *   transport: http(),
    * }).extend(walletActions)
    *
@@ -3441,7 +3152,7 @@ export namespace transfer {
    * @returns The call.
    */
   export function call(args: Args) {
-    const { amount, from, memo, token = Addresses.defaultFeeToken, to } = args
+    const { amount, from, memo, token, to } = args
     const callArgs = (() => {
       if (memo && from)
         return {
@@ -3494,16 +3205,16 @@ export namespace transfer {
  * ```ts
  * import { createClient, http } from 'viem'
  * import { tempo } from 'tempo.ts/chains'
- * import * as actions from 'tempo.ts/viem/actions'
+ * import { Actions } from 'tempo.ts/viem'
  * import { privateKeyToAccount } from 'viem/accounts'
  *
  * const client = createClient({
  *   account: privateKeyToAccount('0x...'),
- *   chain: tempo,
+ *   chain: tempo({ feeToken: '0x20c0000000000000000000000000000000000001' })
  *   transport: http(),
  * })
  *
- * const result = await actions.token.transferSync(client, {
+ * const result = await Actions.token.transferSync(client, {
  *   to: '0x...',
  *   amount: 100n,
  * })
@@ -3547,6 +3258,9 @@ export namespace transferSync {
   > & {
     receipt: TransactionReceipt
   }
+
+  // TODO: exhaustive error type
+  export type ErrorType = BaseErrorType
 }
 
 /**
@@ -3556,16 +3270,16 @@ export namespace transferSync {
  * ```ts
  * import { createClient, http } from 'viem'
  * import { tempo } from 'tempo.ts/chains'
- * import * as actions from 'tempo.ts/viem/actions'
+ * import { Actions } from 'tempo.ts/viem'
  * import { privateKeyToAccount } from 'viem/accounts'
  *
  * const client = createClient({
  *   account: privateKeyToAccount('0x...'),
- *   chain: tempo,
+ *   chain: tempo({ feeToken: '0x20c0000000000000000000000000000000000001' })
  *   transport: http(),
  * })
  *
- * const result = await actions.token.unpause(client, {
+ * const result = await Actions.token.unpause(client, {
  *   token: '0x...',
  * })
  * ```
@@ -3597,6 +3311,9 @@ export namespace unpause {
 
   export type ReturnValue = WriteContractReturnType
 
+  // TODO: exhaustive error type
+  export type ErrorType = BaseErrorType
+
   /** @internal */
   export async function inner<
     action extends typeof writeContract | typeof writeContractSync,
@@ -3627,10 +3344,10 @@ export namespace unpause {
    * ```ts
    * import { createClient, http, walletActions } from 'viem'
    * import { tempo } from 'tempo.ts/chains'
-   * import * as actions from 'tempo.ts/viem/actions'
+   * import { Actions } from 'tempo.ts/viem'
    *
    * const client = createClient({
-   *   chain: tempo,
+   *   chain: tempo({ feeToken: '0x20c0000000000000000000000000000000000001' })
    *   transport: http(),
    * }).extend(walletActions)
    *
@@ -3680,16 +3397,16 @@ export namespace unpause {
  * ```ts
  * import { createClient, http } from 'viem'
  * import { tempo } from 'tempo.ts/chains'
- * import * as actions from 'tempo.ts/viem/actions'
+ * import { Actions } from 'tempo.ts/viem'
  * import { privateKeyToAccount } from 'viem/accounts'
  *
  * const client = createClient({
  *   account: privateKeyToAccount('0x...'),
- *   chain: tempo,
+ *   chain: tempo({ feeToken: '0x20c0000000000000000000000000000000000001' })
  *   transport: http(),
  * })
  *
- * const result = await actions.token.unpauseSync(client, {
+ * const result = await Actions.token.unpauseSync(client, {
  *   token: '0x...',
  * })
  * ```
@@ -3732,6 +3449,140 @@ export namespace unpauseSync {
   > & {
     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
+  }
 }
 
 /**
@@ -3741,16 +3592,16 @@ export namespace unpauseSync {
  * ```ts
  * import { createClient, http } from 'viem'
  * import { tempo } from 'tempo.ts/chains'
- * import * as actions from 'tempo.ts/viem/actions'
+ * import { Actions } from 'tempo.ts/viem'
  * import { privateKeyToAccount } from 'viem/accounts'
  *
  * const client = createClient({
  *   account: privateKeyToAccount('0x...'),
- *   chain: tempo,
+ *   chain: tempo({ feeToken: '0x20c0000000000000000000000000000000000001' })
  *   transport: http(),
  * })
  *
- * const result = await actions.token.updateQuoteToken(client, {
+ * const result = await Actions.token.prepareUpdateQuoteTokenSync(client, {
  *   token: '0x...',
  *   quoteToken: '0x...',
  * })
@@ -3758,6 +3609,75 @@ export namespace unpauseSync {
  *
  * @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<
@@ -3777,14 +3697,15 @@ export namespace updateQuoteToken {
   > = 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,
@@ -3795,8 +3716,8 @@ export namespace updateQuoteToken {
     client: Client<Transport, chain, account>,
     parameters: updateQuoteToken.Parameters<chain, account>,
   ): Promise<ReturnType<action>> {
-    const { quoteToken, token, ...rest } = parameters
-    const call = updateQuoteToken.call({ quoteToken, token })
+    const { token, ...rest } = parameters
+    const call = updateQuoteToken.call({ token })
     return (await action(client, {
       ...rest,
       ...call,
@@ -3815,10 +3736,10 @@ export namespace updateQuoteToken {
    * ```ts
    * import { createClient, http, walletActions } from 'viem'
    * import { tempo } from 'tempo.ts/chains'
-   * import * as actions from 'tempo.ts/viem/actions'
+   * import { Actions } from 'tempo.ts/viem'
    *
    * const client = createClient({
-   *   chain: tempo,
+   *   chain: tempo({ feeToken: '0x20c0000000000000000000000000000000000001' })
    *   transport: http(),
    * }).extend(walletActions)
    *
@@ -3826,7 +3747,6 @@ export namespace updateQuoteToken {
    *   calls: [
    *     actions.token.updateQuoteToken.call({
    *       token: '0x20c0...babe',
-   *       quoteToken: '0x20c0...cafe',
    *     }),
    *   ]
    * })
@@ -3836,12 +3756,12 @@ export namespace updateQuoteToken {
    * @returns The call.
    */
   export function call(args: Args) {
-    const { token, quoteToken } = args
+    const { token } = args
     return defineCall({
       address: TokenId.toAddress(token),
       abi: Abis.tip20,
-      functionName: 'updateQuoteToken',
-      args: [TokenId.toAddress(quoteToken)],
+      functionName: 'completeQuoteTokenUpdate',
+      args: [],
     })
   }
 
@@ -3855,9 +3775,9 @@ export namespace updateQuoteToken {
     const [log] = parseEventLogs({
       abi: Abis.tip20,
       logs,
-      eventName: 'UpdateQuoteToken',
+      eventName: 'QuoteTokenUpdate',
     })
-    if (!log) throw new Error('`UpdateQuoteToken` event not found.')
+    if (!log) throw new Error('`QuoteTokenUpdateCompleted` event not found.')
     return log
   }
 }
@@ -3869,18 +3789,17 @@ export namespace updateQuoteToken {
  * ```ts
  * import { createClient, http } from 'viem'
  * import { tempo } from 'tempo.ts/chains'
- * import * as actions from 'tempo.ts/viem/actions'
+ * import { Actions } from 'tempo.ts/viem'
  * import { privateKeyToAccount } from 'viem/accounts'
  *
  * const client = createClient({
  *   account: privateKeyToAccount('0x...'),
- *   chain: tempo,
+ *   chain: tempo({ feeToken: '0x20c0000000000000000000000000000000000001' })
  *   transport: http(),
  * })
  *
- * const result = await actions.token.updateQuoteTokenSync(client, {
+ * const result = await Actions.token.updateQuoteTokenSync(client, {
  *   token: '0x...',
- *   quoteToken: '0x...',
  * })
  * ```
  *
@@ -3918,7 +3837,7 @@ export namespace updateQuoteTokenSync {
   export type ReturnValue = Compute<
     GetEventArgs<
       typeof Abis.tip20,
-      'UpdateQuoteToken',
+      'QuoteTokenUpdate',
       {
         IndexedOnly: false
         Required: true
@@ -3927,6 +3846,9 @@ export namespace updateQuoteTokenSync {
       receipt: TransactionReceipt
     }
   >
+
+  // TODO: exhaustive error type
+  export type ErrorType = BaseErrorType
 }
 
 /**
@@ -3936,10 +3858,10 @@ export namespace updateQuoteTokenSync {
  * ```ts
  * import { createClient, http } from 'viem'
  * import { tempo } from 'tempo.ts/chains'
- * import * as actions from 'tempo.ts/viem/actions'
+ * import { Actions } from 'tempo.ts/viem'
  *
  * const client = createClient({
- *   chain: tempo,
+ *   chain: tempo({ feeToken: '0x20c0000000000000000000000000000000000001' })
  *   transport: http(),
  * })
  *
@@ -3961,7 +3883,7 @@ export function watchApprove<
   client: Client<Transport, chain, account>,
   parameters: watchApprove.Parameters,
 ) {
-  const { onApproval, token = Addresses.defaultFeeToken, ...rest } = parameters
+  const { onApproval, token, ...rest } = parameters
   return watchContractEvent(client, {
     ...rest,
     address: TokenId.toAddress(token),
@@ -3995,8 +3917,8 @@ export declare namespace watchApprove {
   > & {
     /** Callback to invoke when tokens are approved. */
     onApproval: (args: Args, log: Log) => void
-    /** Address or ID of the TIP20 token. @default `Addresses.defaultFeeToken` */
-    token?: TokenId.TokenIdOrAddress | undefined
+    /** Address or ID of the TIP20 token. */
+    token: TokenId.TokenIdOrAddress
   }
 }
 
@@ -4007,10 +3929,10 @@ export declare namespace watchApprove {
  * ```ts
  * import { createClient, http } from 'viem'
  * import { tempo } from 'tempo.ts/chains'
- * import * as actions from 'tempo.ts/viem/actions'
+ * import { Actions } from 'tempo.ts/viem'
  *
  * const client = createClient({
- *   chain: tempo,
+ *   chain: tempo({ feeToken: '0x20c0000000000000000000000000000000000001' })
  *   transport: http(),
  * })
  *
@@ -4029,7 +3951,7 @@ export function watchBurn<
   chain extends Chain | undefined,
   account extends Account | undefined,
 >(client: Client<Transport, chain, account>, parameters: watchBurn.Parameters) {
-  const { onBurn, token = Addresses.defaultFeeToken, ...rest } = parameters
+  const { onBurn, token, ...rest } = parameters
   return watchContractEvent(client, {
     ...rest,
     address: TokenId.toAddress(token),
@@ -4063,8 +3985,8 @@ export declare namespace watchBurn {
   > & {
     /** Callback to invoke when tokens are burned. */
     onBurn: (args: Args, log: Log) => void
-    /** Address or ID of the TIP20 token. @default `Addresses.defaultFeeToken` */
-    token?: TokenId.TokenIdOrAddress | undefined
+    /** Address or ID of the TIP20 token. */
+    token: TokenId.TokenIdOrAddress
   }
 }
 
@@ -4075,10 +3997,10 @@ export declare namespace watchBurn {
  * ```ts
  * import { createClient, http } from 'viem'
  * import { tempo } from 'tempo.ts/chains'
- * import * as actions from 'tempo.ts/viem/actions'
+ * import { Actions } from 'tempo.ts/viem'
  *
  * const client = createClient({
- *   chain: tempo,
+ *   chain: tempo({ feeToken: '0x20c0000000000000000000000000000000000001' })
  *   transport: http(),
  * })
  *
@@ -4148,10 +4070,10 @@ export declare namespace watchCreate {
  * ```ts
  * import { createClient, http } from 'viem'
  * import { tempo } from 'tempo.ts/chains'
- * import * as actions from 'tempo.ts/viem/actions'
+ * import { Actions } from 'tempo.ts/viem'
  *
  * const client = createClient({
- *   chain: tempo,
+ *   chain: tempo({ feeToken: '0x20c0000000000000000000000000000000000001' })
  *   transport: http(),
  * })
  *
@@ -4170,7 +4092,7 @@ export function watchMint<
   chain extends Chain | undefined,
   account extends Account | undefined,
 >(client: Client<Transport, chain, account>, parameters: watchMint.Parameters) {
-  const { onMint, token = Addresses.defaultFeeToken, ...rest } = parameters
+  const { onMint, token, ...rest } = parameters
   return watchContractEvent(client, {
     ...rest,
     address: TokenId.toAddress(token),
@@ -4204,9 +4126,11 @@ export declare namespace watchMint {
   > & {
     /** Callback to invoke when tokens are minted. */
     onMint: (args: Args, log: Log) => void
-    /** Address or ID of the TIP20 token. @default `Addresses.defaultFeeToken` */
-    token?: TokenId.TokenIdOrAddress | undefined
+    /** Address or ID of the TIP20 token. */
+    token: TokenId.TokenIdOrAddress
   }
+
+  export type ReturnValue = WatchContractEventReturnType
 }
 
 /**
@@ -4216,10 +4140,10 @@ export declare namespace watchMint {
  * ```ts
  * import { createClient, http } from 'viem'
  * import { tempo } from 'tempo.ts/chains'
- * import * as actions from 'tempo.ts/viem/actions'
+ * import { Actions } from 'tempo.ts/viem'
  *
  * const client = createClient({
- *   chain: tempo,
+ *   chain: tempo({ feeToken: '0x20c0000000000000000000000000000000000001' })
  *   transport: http(),
  * })
  *
@@ -4241,11 +4165,7 @@ export function watchAdminRole<
   client: Client<Transport, chain, account>,
   parameters: watchAdminRole.Parameters,
 ) {
-  const {
-    onRoleAdminUpdated,
-    token = Addresses.defaultFeeToken,
-    ...rest
-  } = parameters
+  const { onRoleAdminUpdated, token, ...rest } = parameters
   return watchContractEvent(client, {
     ...rest,
     address: TokenId.toAddress(token),
@@ -4279,8 +4199,8 @@ export declare namespace watchAdminRole {
   > & {
     /** Callback to invoke when a role admin is updated. */
     onRoleAdminUpdated: (args: Args, log: Log) => void
-    /** Address or ID of the TIP20 token. @default `Addresses.defaultFeeToken` */
-    token?: TokenId.TokenIdOrAddress | undefined
+    /** Address or ID of the TIP20 token. */
+    token: TokenId.TokenIdOrAddress
   }
 }
 
@@ -4291,10 +4211,10 @@ export declare namespace watchAdminRole {
  * ```ts
  * import { createClient, http } from 'viem'
  * import { tempo } from 'tempo.ts/chains'
- * import * as actions from 'tempo.ts/viem/actions'
+ * import { Actions } from 'tempo.ts/viem'
  *
  * const client = createClient({
- *   chain: tempo,
+ *   chain: tempo({ feeToken: '0x20c0000000000000000000000000000000000001' })
  *   transport: http(),
  * })
  *
@@ -4313,11 +4233,7 @@ export function watchRole<
   chain extends Chain | undefined,
   account extends Account | undefined,
 >(client: Client<Transport, chain, account>, parameters: watchRole.Parameters) {
-  const {
-    onRoleUpdated,
-    token = Addresses.defaultFeeToken,
-    ...rest
-  } = parameters
+  const { onRoleUpdated, token, ...rest } = parameters
   return watchContractEvent(client, {
     ...rest,
     address: TokenId.toAddress(token),
@@ -4361,8 +4277,8 @@ export declare namespace watchRole {
   > & {
     /** Callback to invoke when a role membership is updated. */
     onRoleUpdated: (args: Args, log: Log) => void
-    /** Address or ID of the TIP20 token. @default `Addresses.defaultFeeToken` */
-    token?: TokenId.TokenIdOrAddress | undefined
+    /** Address or ID of the TIP20 token. */
+    token: TokenId.TokenIdOrAddress
   }
 }
 
@@ -4373,11 +4289,11 @@ export declare namespace watchRole {
  * ```ts
  * import { createClient, http } from 'viem'
  * import { tempo } from 'tempo.ts/chains'
- * import * as actions from 'tempo.ts/viem/actions'
+ * import { Actions } from 'tempo.ts/viem'
  *
  * const client = createClient({
  *   account: privateKeyToAccount('0x...'),
- *   chain: tempo,
+ *   chain: tempo({ feeToken: '0x20c0000000000000000000000000000000000001' })
  *   transport: http(),
  * })
  *
@@ -4399,7 +4315,7 @@ export function watchTransfer<
   client: Client<Transport, chain, account>,
   parameters: watchTransfer.Parameters,
 ) {
-  const { onTransfer, token = Addresses.defaultFeeToken, ...rest } = parameters
+  const { onTransfer, token, ...rest } = parameters
   return watchContractEvent(client, {
     ...rest,
     address: TokenId.toAddress(token),
@@ -4433,8 +4349,8 @@ export declare namespace watchTransfer {
   > & {
     /** Callback to invoke when tokens are transferred. */
     onTransfer: (args: Args, log: Log) => void
-    /** Address or ID of the TIP20 token. @default `Addresses.defaultFeeToken` */
-    token?: TokenId.TokenIdOrAddress | undefined
+    /** Address or ID of the TIP20 token. */
+    token: TokenId.TokenIdOrAddress
   }
 }
 
@@ -4445,17 +4361,17 @@ export declare namespace watchTransfer {
  * ```ts
  * import { createClient, http } from 'viem'
  * import { tempo } from 'tempo.ts/chains'
- * import * as actions from 'tempo.ts/viem/actions'
+ * import { Actions } from 'tempo.ts/viem'
  *
  * const client = createClient({
- *   chain: tempo,
+ *   chain: tempo({ feeToken: '0x20c0000000000000000000000000000000000001' })
  *   transport: http(),
  * })
  *
  * const unwatch = actions.token.watchUpdateQuoteToken(client, {
  *   onUpdateQuoteToken: (args, log) => {
- *     if (args.finalized)
- *       console.log('quote token update finalized:', args.newQuoteToken)
+ *     if (args.completed)
+ *       console.log('quote token update completed:', args.newQuoteToken)
  *     else
  *       console.log('quote token update proposed:', args.newQuoteToken)
  *   },
@@ -4473,11 +4389,7 @@ export function watchUpdateQuoteToken<
   client: Client<Transport, chain, account>,
   parameters: watchUpdateQuoteToken.Parameters,
 ) {
-  const {
-    onUpdateQuoteToken,
-    token = Addresses.defaultFeeToken,
-    ...rest
-  } = parameters
+  const { onUpdateQuoteToken, token, ...rest } = parameters
   const address = TokenId.toAddress(token)
 
   return watchContractEvent(client, {
@@ -4491,22 +4403,22 @@ export function watchUpdateQuoteToken<
         false,
         ExtractAbiItem<
           typeof Abis.tip20,
-          'UpdateQuoteToken' | 'QuoteTokenUpdateFinalized'
+          'NextQuoteTokenSet' | 'QuoteTokenUpdate'
         >,
         true
       >[],
     ) => {
       for (const log of logs) {
         if (
-          log.eventName !== 'UpdateQuoteToken' &&
-          log.eventName !== 'QuoteTokenUpdateFinalized'
+          log.eventName !== 'NextQuoteTokenSet' &&
+          log.eventName !== 'QuoteTokenUpdate'
         )
           continue
 
         onUpdateQuoteToken(
           {
             ...log.args,
-            finalized: log.eventName === 'QuoteTokenUpdateFinalized',
+            completed: log.eventName === 'QuoteTokenUpdate',
           },
           log,
         )
@@ -4520,17 +4432,17 @@ export declare namespace watchUpdateQuoteToken {
   export type Args = OneOf<
     | GetEventArgs<
         typeof Abis.tip20,
-        'UpdateQuoteToken',
+        'NextQuoteTokenSet',
         { IndexedOnly: false; Required: true }
       >
     | GetEventArgs<
         typeof Abis.tip20,
-        'QuoteTokenUpdateFinalized',
+        'QuoteTokenUpdate',
         { IndexedOnly: false; Required: true }
       >
   > & {
-    /** Whether the update has been finalized. */
-    finalized: boolean
+    /** Whether the update has been completed. */
+    completed: boolean
   }
 
   export type Log = viem_Log
@@ -4539,9 +4451,9 @@ export declare namespace watchUpdateQuoteToken {
     WatchContractEventParameters<typeof Abis.tip20, any, true>,
     'abi' | 'address' | 'batch' | 'eventName' | 'onLogs' | 'strict'
   > & {
-    /** Callback to invoke when a quote token update is proposed or finalized. */
+    /** 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. @default `Addresses.defaultFeeToken` */
-    token?: TokenId.TokenIdOrAddress | undefined
+    /** Address or ID of the TIP20 token. */
+    token: TokenId.TokenIdOrAddress
   }
 }