viem 2.53.1 → 2.54.1

package/tempo/actions/token.ts

@@ -3,14 +3,20 @@ import * as Hex from 'ox/Hex'
 import { TokenId, TokenRole } from 'ox/tempo'
 import type { Account } from '../../accounts/types.js'
 import { parseAccount } from '../../accounts/utils/parseAccount.js'
+import { estimateContractGas } from '../../actions/public/estimateContractGas.js'
 import { multicall } from '../../actions/public/multicall.js'
 import type { ReadContractReturnType } from '../../actions/public/readContract.js'
 import { readContract } from '../../actions/public/readContract.js'
+import {
+  type SimulateContractReturnType,
+  simulateContract,
+} from '../../actions/public/simulateContract.js'
 import type {
   WatchContractEventParameters,
   WatchContractEventReturnType,
 } from '../../actions/public/watchContractEvent.js'
 import { watchContractEvent } from '../../actions/public/watchContractEvent.js'
+import * as internal_Token from '../../actions/token/internal.js'
 import { sendTransaction } from '../../actions/wallet/sendTransaction.js'
 import {
   type SendTransactionSyncParameters,
@@ -21,6 +27,7 @@ import { writeContract } from '../../actions/wallet/writeContract.js'
 import { writeContractSync } from '../../actions/wallet/writeContractSync.js'
 import type { Client } from '../../clients/createClient.js'
 import type { Transport } from '../../clients/transports/createTransport.js'
+import { AccountNotFoundError } from '../../errors/account.js'
 import type { BaseErrorType } from '../../errors/base.js'
 import type { Chain } from '../../types/chain.js'
 import type { ExtractAbiItem, GetEventArgs } from '../../types/contract.js'
@@ -28,14 +35,23 @@ import type { Log, Log as viem_Log } from '../../types/log.js'
 import type { Compute, OneOf, UnionOmit } from '../../types/utils.js'
 import { encodeFunctionData } from '../../utils/abi/encodeFunctionData.js'
 import { parseEventLogs } from '../../utils/abi/parseEventLogs.js'
+import { formatUnits } from '../../utils/unit/formatUnits.js'
 import * as Abis from '../Abis.js'
 import * as Addresses from '../Addresses.js'
 import type {
   GetAccountParameter,
   ReadParameters,
+  TokenParameter,
+  TokenParameters,
   WriteParameters,
 } from '../internal/types.js'
-import { defineCall } from '../internal/utils.js'
+import {
+  defineCall,
+  findDeclaredToken,
+  pickWriteParameters,
+  resolveToken,
+  resolveTokenWithDecimals,
+} from '../internal/utils.js'
 import type { TransactionReceipt } from '../Transaction.js'
 
 /**
@@ -71,27 +87,21 @@ export async function approve<
   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 })
+  return approve.inner(writeContract, client, parameters)
 }
 
 export namespace approve {
+  export type Args = {
+    /** Amount of tokens to approve, in base units or formatted decimal form. */
+    amount: internal_Token.AmountInput
+    /** Address of the spender. */
+    spender: Address
+  } & TokenParameter
   export type Parameters<
     chain extends Chain | undefined = Chain | undefined,
     account extends Account | undefined = Account | undefined,
   > = WriteParameters<chain, account> & Args
-
-  export type 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
 
@@ -104,58 +114,88 @@ export namespace approve {
     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,
+      ...approve.call(client, parameters as never),
     } as never)) as never
   }
 
   /**
    * Defines a call to the `approve` function.
    *
-   * Can be passed as a parameter to:
-   * - [`estimateContractGas`](https://viem.sh/docs/contract/estimateContractGas): estimate the gas cost of the call
-   * - [`simulateContract`](https://viem.sh/docs/contract/simulateContract): simulate the call
-   * - [`sendCalls`](https://viem.sh/docs/actions/wallet/sendCalls): send multiple calls
-   *
-   * @example
-   * ```ts
-   * import { createClient, http, walletActions } from 'viem'
-   * import { tempo } from 'viem/chains'
-   * import { Actions } from 'viem/tempo'
-   *
-   * const client = createClient({
-   *   chain: tempo.extend({ feeToken: '0x20c0000000000000000000000000000000000001' })
-   *   transport: http(),
-   * }).extend(walletActions)
-   *
-   * const { result } = await client.sendCalls({
-   *   calls: [
-   *     actions.token.approve.call({
-   *       spender: '0x20c0...beef',
-   *       amount: 100n,
-   *       token: '0x20c0...babe',
-   *     }),
-   *   ]
-   * })
-   * ```
+   * Can be passed as a parameter to `estimateContractGas`, `simulateContract`,
+   * `sendCalls`, `sendTransaction` (`calls`), or `multicall`. The token is
+   * selected by `token`, which is either a TIP20 token id or a contract
+   * `address`; `amount.decimals` is inferred from the client's declared
+   * `tokens` when omitted.
    *
-   * @param args - Arguments.
+   * @param client - Client.
+   * @param parameters - Parameters.
    * @returns The call.
    */
-  export function call(args: Args) {
-    const { spender, amount, token } = args
+  export function call<chain extends Chain | undefined>(
+    client: Client<Transport, chain>,
+    parameters: Args,
+  ) {
+    const { amount, spender, token } = parameters
+    const { address, decimals } = resolveToken(client, { token })
     return defineCall({
-      address: TokenId.toAddress(token),
+      address,
       abi: Abis.tip20,
       functionName: 'approve',
-      args: [spender, amount],
+      args: [spender, internal_Token.toBaseUnits(amount, decimals)],
     })
   }
 
+  /**
+   * Estimates the gas required to approve a spender. `amount.decimals` is
+   * inferred from the client's declared `tokens` when omitted.
+   *
+   * @param client - Client.
+   * @param parameters - Parameters.
+   * @returns The gas estimate.
+   */
+  export async function estimateGas<
+    chain extends Chain | undefined,
+    account extends Account | undefined,
+  >(
+    client: Client<Transport, chain, account>,
+    parameters: approve.Parameters<chain, account>,
+  ): Promise<bigint> {
+    return estimateContractGas(client, {
+      ...pickWriteParameters(parameters as never),
+      ...approve.call(client, parameters as never),
+    } as never)
+  }
+
+  /**
+   * Simulates an approval of a spender. `amount.decimals` is inferred from
+   * the client's declared `tokens` when omitted.
+   *
+   * @param client - Client.
+   * @param parameters - Parameters.
+   * @returns The simulation result and write request.
+   */
+  export async function simulate<
+    chain extends Chain | undefined,
+    account extends Account | undefined,
+  >(
+    client: Client<Transport, chain, account>,
+    parameters: approve.Parameters<chain, account>,
+  ): Promise<SimulateContractReturnType<typeof Abis.tip20, 'approve'>> {
+    return simulateContract(client, {
+      ...pickWriteParameters(parameters as never),
+      ...approve.call(client, parameters as never),
+    } as never) as never
+  }
+
+  /**
+   * Extracts the `Approval` event from logs.
+   *
+   * @param logs - The logs.
+   * @returns The `Approval` event.
+   */
   export function extractEvent(logs: Log[]) {
     const [log] = parseEventLogs({
       abi: Abis.tip20,
@@ -200,28 +240,29 @@ export async function approveSync<
   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 { amount, token, throwOnReceiptRevert = true } = parameters
+  const { decimals } = resolveToken(client, { token })
+  const resolved = internal_Token.resolveAmountDecimals(amount, decimals)
+  const receipt = await approve.inner(writeContractSync, client, {
+    ...parameters,
+    throwOnReceiptRevert,
+  } as never)
   const { args } = approve.extractEvent(receipt.logs)
   return {
     ...args,
+    ...(resolved === undefined
+      ? {}
+      : { decimals: resolved, formatted: formatUnits(args.amount, resolved) }),
     receipt,
   } as never
 }
 
 export namespace approveSync {
+  export type Args = approve.Args
   export type Parameters<
     chain extends Chain | undefined = Chain | undefined,
     account extends Account | undefined = Account | undefined,
   > = approve.Parameters<chain, account>
-
-  export type Args = approve.Args
-
   export type ReturnValue = Compute<
     GetEventArgs<
       typeof Abis.tip20,
@@ -231,11 +272,14 @@ export namespace approveSync {
         Required: true
       }
     > & {
+      /** Token decimals used to derive `formatted`, if known. */
+      decimals?: number | undefined
+      /** Approved amount formatted with the token's `decimals`, if known. */
+      formatted?: string | undefined
       /** Transaction receipt. */
       receipt: TransactionReceipt
     }
   >
-
   // TODO: exhaustive error type
   export type ErrorType = BaseErrorType
 }
@@ -278,20 +322,18 @@ export async function burnBlocked<
 }
 
 export namespace burnBlocked {
+  export type Args = {
+    /** Amount of tokens to burn, in base units or formatted decimal form. */
+    amount: internal_Token.AmountInput
+    /** Address to burn tokens from. */
+    from: Address
+  } & TokenParameter
+
   export type Parameters<
     chain extends Chain | undefined = Chain | undefined,
     account extends Account | undefined = Account | undefined,
   > = WriteParameters<chain, account> & Args
 
-  export type 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
@@ -308,7 +350,7 @@ export namespace burnBlocked {
     parameters: burnBlocked.Parameters<chain, account>,
   ): Promise<ReturnType<action>> {
     const { amount, from, token, ...rest } = parameters
-    const call = burnBlocked.call({ amount, from, token })
+    const call = burnBlocked.call(client, { amount, from, token } as never)
     return (await action(client, {
       ...rest,
       ...call,
@@ -336,7 +378,7 @@ export namespace burnBlocked {
    *
    * const { result } = await client.sendCalls({
    *   calls: [
-   *     actions.token.burnBlocked.call({
+   *     actions.token.burnBlocked.call(client, {
    *       from: '0x20c0...beef',
    *       amount: 100n,
    *       token: '0x20c0...babe',
@@ -345,16 +387,22 @@ export namespace burnBlocked {
    * })
    * ```
    *
+   * `amount.decimals` is inferred from the client's declared `tokens` when omitted.
+   *
    * @param args - Arguments.
    * @returns The call.
    */
-  export function call(args: Args) {
+  export function call<chain extends Chain | undefined>(
+    client: Client<Transport, chain>,
+    args: Args,
+  ) {
     const { from, amount, token } = args
+    const { address, decimals } = resolveToken(client, { token })
     return defineCall({
-      address: TokenId.toAddress(token),
+      address,
       abi: Abis.tip20,
       functionName: 'burnBlocked',
-      args: [from, amount],
+      args: [from, internal_Token.toBaseUnits(amount, decimals)],
     })
   }
 
@@ -484,20 +532,18 @@ export async function burn<
 }
 
 export namespace burn {
+  export type Args = {
+    /** Amount of tokens to burn, in base units or formatted decimal form. */
+    amount: internal_Token.AmountInput
+    /** Memo to include in the transfer. */
+    memo?: Hex.Hex | undefined
+  } & TokenParameter
+
   export type Parameters<
     chain extends Chain | undefined = Chain | undefined,
     account extends Account | undefined = Account | undefined,
   > = WriteParameters<chain, account> & Args
 
-  export type 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
@@ -514,7 +560,7 @@ export namespace burn {
     parameters: burn.Parameters<chain, account>,
   ): Promise<ReturnType<action>> {
     const { amount, memo, token, ...rest } = parameters
-    const call = burn.call({ amount, memo, token })
+    const call = burn.call(client, { amount, memo, token } as never)
     return (await action(client, {
       ...rest,
       ...call,
@@ -542,7 +588,7 @@ export namespace burn {
    *
    * const { result } = await client.sendCalls({
    *   calls: [
-   *     actions.token.burn.call({
+   *     actions.token.burn.call(client, {
    *       amount: 100n,
    *       token: '0x20c0...babe',
    *     }),
@@ -550,22 +596,29 @@ export namespace burn {
    * })
    * ```
    *
+   * `amount.decimals` is inferred from the client's declared `tokens` when omitted.
+   *
    * @param args - Arguments.
    * @returns The call.
    */
-  export function call(args: Args) {
+  export function call<chain extends Chain | undefined>(
+    client: Client<Transport, chain>,
+    args: Args,
+  ) {
     const { amount, memo, token } = args
+    const { address, decimals } = resolveToken(client, { token })
+    const value = internal_Token.toBaseUnits(amount, decimals)
     const callArgs = memo
       ? ({
           functionName: 'burnWithMemo',
-          args: [amount, Hex.padLeft(memo, 32)],
+          args: [value, Hex.padLeft(memo, 32)],
         } as const)
       : ({
           functionName: 'burn',
-          args: [amount],
+          args: [value],
         } as const)
     return defineCall({
-      address: TokenId.toAddress(token),
+      address,
       abi: Abis.tip20,
       ...callArgs,
     })
@@ -723,7 +776,7 @@ export namespace changeTransferPolicy {
     parameters: changeTransferPolicy.Parameters<chain, account>,
   ): Promise<ReturnType<action>> {
     const { policyId, token, ...rest } = parameters
-    const call = changeTransferPolicy.call({ policyId, token })
+    const call = changeTransferPolicy.call(client, { policyId, token })
     return (await action(client, {
       ...rest,
       ...call,
@@ -751,7 +804,7 @@ export namespace changeTransferPolicy {
    *
    * const { result } = await client.sendCalls({
    *   calls: [
-   *     actions.token.changeTransferPolicy.call({
+   *     actions.token.changeTransferPolicy.call(client, {
    *       token: '0x20c0...babe',
    *       policyId: 1n,
    *     }),
@@ -762,10 +815,13 @@ export namespace changeTransferPolicy {
    * @param args - Arguments.
    * @returns The call.
    */
-  export function call(args: Args) {
+  export function call<chain extends Chain | undefined>(
+    client: Client<Transport, chain>,
+    args: Args,
+  ) {
     const { token, policyId } = args
     return defineCall({
-      address: TokenId.toAddress(token),
+      address: resolveToken(client, { token }).address,
       abi: Abis.tip20,
       functionName: 'changeTransferPolicyId',
       args: [policyId],
@@ -948,7 +1004,7 @@ export namespace create {
     const admin = admin_ ? parseAccount(admin_) : undefined
     if (!admin) throw new Error('admin is required.')
 
-    const call = create.call({ ...rest, admin: admin.address })
+    const call = create.call(client, { ...rest, admin: admin.address })
 
     return (await action(
       client as never,
@@ -982,7 +1038,7 @@ export namespace create {
    *
    * const { result } = await client.sendCalls({
    *   calls: [
-   *     actions.token.create.call({
+   *     actions.token.create.call(client, {
    *       name: 'My Token',
    *       symbol: 'MTK',
    *       currency: 'USD',
@@ -996,7 +1052,10 @@ export namespace create {
    * @param args - Arguments.
    * @returns The call.
    */
-  export function call(args: Args) {
+  export function call<chain extends Chain | undefined>(
+    client: Client<Transport, chain>,
+    args: Args,
+  ) {
     const {
       name,
       symbol,
@@ -1015,7 +1074,7 @@ export namespace create {
               name,
               symbol,
               currency,
-              TokenId.toAddress(quoteToken),
+              resolveToken(client, { token: quoteToken }).address,
               admin,
               salt,
               logoURI,
@@ -1024,7 +1083,7 @@ export namespace create {
               name,
               symbol,
               currency,
-              TokenId.toAddress(quoteToken),
+              resolveToken(client, { token: quoteToken }).address,
               admin,
               salt,
             ],
@@ -1143,63 +1202,64 @@ export namespace createSync {
  * })
  *
  * const allowance = await Actions.token.getAllowance(client, {
+ *   account: '0x...',
  *   spender: '0x...',
+ *   token: '0x...',
  * })
  * ```
  *
  * @param client - Client.
  * @param parameters - Parameters.
- * @returns The token allowance.
+ * @returns The token allowance, in base units and human-readable form.
  */
-export async function getAllowance<
-  chain extends Chain | undefined,
-  account extends Account | undefined,
->(
-  client: Client<Transport, chain, account>,
-  parameters: getAllowance.Parameters<account>,
+export async function getAllowance<chain extends Chain | undefined>(
+  client: Client<Transport, chain>,
+  parameters: getAllowance.Parameters,
 ): 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 }),
-  })
+  const { account, decimals, spender, token, ...rest } = parameters
+  const [amount, { decimals: resolved }] = await Promise.all([
+    readContract(client, {
+      ...rest,
+      ...getAllowance.call(client, { account, spender, token } as never),
+    }),
+    resolveTokenWithDecimals(client, {
+      decimals,
+      token,
+    }),
+  ])
+  return internal_Token.toAmount(amount, resolved)
 }
 
 export namespace getAllowance {
-  export type Parameters<
-    account extends Account | undefined = Account | undefined,
-  > = ReadParameters & GetAccountParameter<account> & Omit<Args, 'account'> & {}
-
   export type Args = {
-    /** Account address. */
+    /** Account that owns the tokens. */
     account: Address
-    /** Address of the spender. */
+    /** Spender of the tokens. */
     spender: Address
-    /** Address or ID of the TIP20 token. */
-    token: TokenId.TokenIdOrAddress
-  }
-
-  export type ReturnValue = ReadContractReturnType<
-    typeof Abis.tip20,
-    'allowance',
-    never
-  >
+  } & TokenParameters
+  export type Parameters = ReadParameters & Args
+  export type ReturnValue = internal_Token.Amount
 
   /**
    * Defines a call to the `allowance` function.
    *
+   * Can be passed as a parameter to `multicall`, `simulateContract`, or any
+   * other action that accepts a contract call. The token is selected by `token`,
+   * which is either a TIP20 token id or a contract address.
+   *
+   * @param client - Client.
    * @param args - Arguments.
    * @returns The call.
    */
-  export function call(args: Args) {
-    const { account, spender, token } = args
+  export function call<chain extends Chain | undefined>(
+    client: Client<Transport, chain>,
+    args: Args,
+  ) {
     return defineCall({
-      address: TokenId.toAddress(token),
+      address: resolveToken(client, args).address,
       abi: Abis.tip20,
       functionName: 'allowance',
-      args: [account, spender],
+      args: [args.account, args.spender],
     })
   }
 }
@@ -1221,13 +1281,14 @@ export namespace getAllowance {
  * })
  *
  * const balance = await Actions.token.getBalance(client, {
+ *   account: '0x...',
  *   token: '0x...',
  * })
  * ```
  *
  * @param client - Client.
  * @param parameters - Parameters.
- * @returns The token balance.
+ * @returns The token balance, in base units and human-readable form.
  */
 export async function getBalance<
   chain extends Chain | undefined,
@@ -1236,43 +1297,55 @@ export async function getBalance<
   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 }),
-  })
+  const {
+    account: account_ = client.account,
+    decimals,
+    token,
+    ...rest
+  } = parameters
+  if (!account_) throw new AccountNotFoundError()
+  const account = parseAccount(account_).address
+  const [amount, { decimals: resolved }] = await Promise.all([
+    readContract(client, {
+      ...rest,
+      ...getBalance.call(client, { account, token } as never),
+    }),
+    resolveTokenWithDecimals(client, {
+      decimals,
+      token,
+    }),
+  ])
+  return internal_Token.toAmount(amount, resolved)
 }
 
 export namespace getBalance {
+  export type Args<account extends Account | undefined = Account | undefined> =
+    GetAccountParameter<account, Account | Address> & TokenParameters
   export type Parameters<
     account extends Account | undefined = Account | undefined,
-  > = 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
-  >
+  > = Omit<ReadParameters, 'account'> & Args<account>
+  export type ReturnValue = internal_Token.Amount
 
   /**
    * Defines a call to the `balanceOf` function.
    *
+   * Can be passed as a parameter to `multicall`, `simulateContract`, or any
+   * other action that accepts a contract call. The token is selected by `token`,
+   * which is either a TIP20 token id or a contract address.
+   *
+   * @param client - Client.
    * @param args - Arguments.
    * @returns The call.
    */
-  export function call(args: Args) {
-    const { account, token } = args
+  export function call<
+    chain extends Chain | undefined,
+    account extends Account | undefined,
+  >(client: Client<Transport, chain, account>, args: Args<account>) {
+    const account_ = args.account ?? client.account
+    if (!account_) throw new AccountNotFoundError()
+    const account = parseAccount(account_).address
     return defineCall({
-      address: TokenId.toAddress(token),
+      address: resolveToken(client, args).address,
       abi: Abis.tip20,
       functionName: 'balanceOf',
       args: [account],
@@ -1310,10 +1383,17 @@ export async function getMetadata<chain extends Chain | undefined>(
   parameters: getMetadata.Parameters,
 ): Promise<getMetadata.ReturnValue> {
   const { token, ...rest } = parameters
-  const address = TokenId.toAddress(token)
+  const { address } = resolveToken(client, { token })
   const abi = Abis.tip20
 
-  if (TokenId.from(token) === TokenId.fromAddress(Addresses.pathUsd))
+  const declared = findDeclaredToken(client, token)
+  const overrides = {
+    ...(declared?.decimals != null ? { decimals: declared.decimals } : {}),
+    ...(declared?.name != null ? { name: declared.name } : {}),
+    ...(declared?.symbol != null ? { symbol: declared.symbol } : {}),
+  }
+
+  if (TokenId.fromAddress(address) === TokenId.fromAddress(Addresses.pathUsd))
     return multicall(client, {
       ...rest,
       contracts: [
@@ -1357,6 +1437,7 @@ export async function getMetadata<chain extends Chain | undefined>(
       decimals: unwrapMulticallResult(decimals),
       logoURI: unwrapMulticallResult(logoURI, ''),
       totalSupply: unwrapMulticallResult(totalSupply),
+      ...overrides,
     }))
 
   return multicall(client, {
@@ -1438,6 +1519,7 @@ export async function getMetadata<chain extends Chain | undefined>(
       paused: unwrapMulticallResult(paused),
       supplyCap: unwrapMulticallResult(supplyCap),
       transferPolicyId: unwrapMulticallResult(transferPolicyId),
+      ...overrides,
     }),
   )
 }
@@ -1467,10 +1549,7 @@ function unwrapMulticallResult<result>(
 }
 
 export declare namespace getMetadata {
-  export type Parameters = {
-    /** Address or ID of the TIP20 token. */
-    token: TokenId.TokenIdOrAddress
-  }
+  export type Parameters = Omit<ReadParameters, 'account'> & TokenParameter
 
   export type ReturnValue = Compute<{
     /**
@@ -1526,6 +1605,76 @@ export declare namespace getMetadata {
   }>
 }
 
+/**
+ * Gets the total supply of a TIP20 token.
+ *
+ * @example
+ * ```ts
+ * import { createClient, http } from 'viem'
+ * import { tempo } from 'viem/chains'
+ * import { Actions } from 'viem/tempo'
+ *
+ * const client = createClient({
+ *   chain: tempo.extend({ feeToken: '0x20c0000000000000000000000000000000000001' })
+ *   transport: http(),
+ * })
+ *
+ * const totalSupply = await Actions.token.getTotalSupply(client, {
+ *   token: '0x...',
+ * })
+ * ```
+ *
+ * @param client - Client.
+ * @param parameters - Parameters.
+ * @returns The token total supply, in base units and human-readable form.
+ */
+export async function getTotalSupply<chain extends Chain | undefined>(
+  client: Client<Transport, chain>,
+  parameters: getTotalSupply.Parameters,
+): Promise<getTotalSupply.ReturnValue> {
+  const { decimals, token, ...rest } = parameters
+  const [amount, { decimals: resolved }] = await Promise.all([
+    readContract(client, {
+      ...rest,
+      ...getTotalSupply.call(client, { token } as never),
+    }),
+    resolveTokenWithDecimals(client, {
+      decimals,
+      token,
+    }),
+  ])
+  return internal_Token.toAmount(amount, resolved)
+}
+
+export namespace getTotalSupply {
+  export type Args = TokenParameters
+  export type Parameters = Omit<ReadParameters, 'account'> & Args
+  export type ReturnValue = internal_Token.Amount
+
+  /**
+   * Defines a call to the `totalSupply` function.
+   *
+   * Can be passed as a parameter to `multicall`, `simulateContract`, or any
+   * other action that accepts a contract call. The token is selected by `token`,
+   * which is either a TIP20 token id or a contract address.
+   *
+   * @param client - Client.
+   * @param args - Arguments.
+   * @returns The call.
+   */
+  export function call<chain extends Chain | undefined>(
+    client: Client<Transport, chain>,
+    args: Args,
+  ) {
+    return defineCall({
+      address: resolveToken(client, args).address,
+      abi: Abis.tip20,
+      args: [],
+      functionName: 'totalSupply',
+    })
+  }
+}
+
 /**
  * Gets the admin role for a specific role in a TIP20 token.
  *
@@ -1556,7 +1705,7 @@ export async function getRoleAdmin<chain extends Chain | undefined>(
 ): Promise<getRoleAdmin.ReturnValue> {
   return readContract(client, {
     ...parameters,
-    ...getRoleAdmin.call(parameters),
+    ...getRoleAdmin.call(client, parameters),
   })
 }
 
@@ -1582,10 +1731,13 @@ export namespace getRoleAdmin {
    * @param args - Arguments.
    * @returns The call.
    */
-  export function call(args: Args) {
+  export function call<chain extends Chain | undefined>(
+    client: Client<Transport, chain>,
+    args: Args,
+  ) {
     const { role, token } = args
     return defineCall({
-      address: TokenId.toAddress(token),
+      address: resolveToken(client, { token }).address,
       abi: Abis.tip20,
       functionName: 'getRoleAdmin',
       args: [TokenRole.serialize(role)],
@@ -1630,7 +1782,7 @@ export async function hasRole<
   if (!address) throw new Error('account is required.')
   return readContract(client, {
     ...parameters,
-    ...hasRole.call({ ...parameters, account: address }),
+    ...hasRole.call(client, { ...parameters, account: address }),
   })
 }
 
@@ -1660,10 +1812,13 @@ export namespace hasRole {
    * @param args - Arguments.
    * @returns The call.
    */
-  export function call(args: Args) {
+  export function call<chain extends Chain | undefined>(
+    client: Client<Transport, chain>,
+    args: Args,
+  ) {
     const { account, role, token } = args
     return defineCall({
-      address: TokenId.toAddress(token),
+      address: resolveToken(client, { token }).address,
       abi: Abis.tip20,
       functionName: 'hasRole',
       args: [account, TokenRole.serialize(role)],
@@ -1745,7 +1900,7 @@ export namespace grantRoles {
     return (await action(client, {
       ...parameters,
       calls: parameters.roles.map((role) => {
-        const call = grantRoles.call({ ...parameters, role })
+        const call = grantRoles.call(client, { ...parameters, role })
         return {
           ...call,
           data: encodeFunctionData(call),
@@ -1775,7 +1930,7 @@ export namespace grantRoles {
    *
    * const { result } = await client.sendCalls({
    *   calls: [
-   *     actions.token.grantRoles.call({
+   *     actions.token.grantRoles.call(client, {
    *       token: '0x20c0...babe',
    *       to: '0x20c0...beef',
    *       role: 'issuer',
@@ -1787,11 +1942,14 @@ export namespace grantRoles {
    * @param args - Arguments.
    * @returns The call.
    */
-  export function call(args: Args) {
+  export function call<chain extends Chain | undefined>(
+    client: Client<Transport, chain>,
+    args: Args,
+  ) {
     const { token, to, role } = args
     const roleHash = TokenRole.serialize(role)
     return defineCall({
-      address: TokenId.toAddress(token),
+      address: resolveToken(client, { token }).address,
       abi: Abis.tip20,
       functionName: 'grantRole',
       args: [roleHash, to],
@@ -1922,21 +2080,19 @@ export async function mint<
 }
 
 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
+    /** Amount of tokens to mint, in base units or formatted decimal form. */
+    amount: internal_Token.AmountInput
     /** Memo to include in the mint. */
     memo?: Hex.Hex | undefined
     /** Address to mint tokens to. */
     to: Address
-    /** Address or ID of the TIP20 token. */
-    token: TokenId.TokenIdOrAddress
-  }
+  } & TokenParameter
+
+  export type Parameters<
+    chain extends Chain | undefined = Chain | undefined,
+    account extends Account | undefined = Account | undefined,
+  > = WriteParameters<chain, account> & Args
 
   export type ReturnValue = WriteContractReturnType
 
@@ -1951,11 +2107,12 @@ export namespace mint {
   >(
     action: action,
     client: Client<Transport, chain, account>,
-    parameters: any,
+    parameters: mint.Parameters<chain, account>,
   ): Promise<ReturnType<action>> {
-    const call = mint.call(parameters)
+    const { amount, memo, to, token, ...rest } = parameters
+    const call = mint.call(client, { amount, memo, to, token } as never)
     return (await action(client, {
-      ...parameters,
+      ...rest,
       ...call,
     } as never)) as never
   }
@@ -1981,7 +2138,7 @@ export namespace mint {
    *
    * const { result } = await client.sendCalls({
    *   calls: [
-   *     actions.token.mint.call({
+   *     actions.token.mint.call(client, {
    *       to: '0x20c0...beef',
    *       amount: 100n,
    *       token: '0x20c0...babe',
@@ -1990,22 +2147,29 @@ export namespace mint {
    * })
    * ```
    *
+   * `amount.decimals` is inferred from the client's declared `tokens` when omitted.
+   *
    * @param args - Arguments.
    * @returns The call.
    */
-  export function call(args: Args) {
+  export function call<chain extends Chain | undefined>(
+    client: Client<Transport, chain>,
+    args: Args,
+  ) {
     const { to, amount, memo, token } = args
+    const { address, decimals } = resolveToken(client, { token })
+    const value = internal_Token.toBaseUnits(amount, decimals)
     const callArgs = memo
       ? ({
           functionName: 'mintWithMemo',
-          args: [to, amount, Hex.padLeft(memo, 32)],
+          args: [to, value, Hex.padLeft(memo, 32)],
         } as const)
       : ({
           functionName: 'mint',
-          args: [to, amount],
+          args: [to, value],
         } as const)
     return defineCall({
-      address: TokenId.toAddress(token),
+      address,
       abi: Abis.tip20,
       ...callArgs,
     })
@@ -2161,7 +2325,7 @@ export namespace pause {
     parameters: pause.Parameters<chain, account>,
   ): Promise<ReturnType<action>> {
     const { token, ...rest } = parameters
-    const call = pause.call({ token })
+    const call = pause.call(client, { token })
     return (await action(client, {
       ...rest,
       ...call,
@@ -2189,7 +2353,7 @@ export namespace pause {
    *
    * const { result } = await client.sendCalls({
    *   calls: [
-   *     actions.token.pause.call({
+   *     actions.token.pause.call(client, {
    *       token: '0x20c0...babe',
    *     }),
    *   ]
@@ -2199,10 +2363,13 @@ export namespace pause {
    * @param args - Arguments.
    * @returns The call.
    */
-  export function call(args: Args) {
+  export function call<chain extends Chain | undefined>(
+    client: Client<Transport, chain>,
+    args: Args,
+  ) {
     const { token } = args
     return defineCall({
-      address: TokenId.toAddress(token),
+      address: resolveToken(client, { token }).address,
       abi: Abis.tip20,
       functionName: 'pause',
       args: [],
@@ -2361,7 +2528,7 @@ export namespace renounceRoles {
     return (await action(client, {
       ...parameters,
       calls: parameters.roles.map((role) => {
-        const call = renounceRoles.call({ ...parameters, role })
+        const call = renounceRoles.call(client, { ...parameters, role })
         return {
           ...call,
           data: encodeFunctionData(call),
@@ -2391,7 +2558,7 @@ export namespace renounceRoles {
    *
    * const { result } = await client.sendCalls({
    *   calls: [
-   *     actions.token.renounceRoles.call({
+   *     actions.token.renounceRoles.call(client, {
    *       token: '0x20c0...babe',
    *       role: 'issuer',
    *     }),
@@ -2402,11 +2569,14 @@ export namespace renounceRoles {
    * @param args - Arguments.
    * @returns The call.
    */
-  export function call(args: Args) {
+  export function call<chain extends Chain | undefined>(
+    client: Client<Transport, chain>,
+    args: Args,
+  ) {
     const { token, role } = args
     const roleHash = TokenRole.serialize(role)
     return defineCall({
-      address: TokenId.toAddress(token),
+      address: resolveToken(client, { token }).address,
       abi: Abis.tip20,
       functionName: 'renounceRole',
       args: [roleHash],
@@ -2573,7 +2743,7 @@ export namespace revokeRoles {
     return (await action(client, {
       ...rest,
       calls: parameters.roles.map((role) => {
-        const call = revokeRoles.call({ ...parameters, role })
+        const call = revokeRoles.call(client, { ...parameters, role })
         return {
           ...call,
           data: encodeFunctionData(call),
@@ -2603,7 +2773,7 @@ export namespace revokeRoles {
    *
    * const { result } = await client.sendCalls({
    *   calls: [
-   *     actions.token.revokeRoles.call({
+   *     actions.token.revokeRoles.call(client, {
    *       token: '0x20c0...babe',
    *       from: '0x20c0...beef',
    *       role: 'issuer',
@@ -2615,11 +2785,14 @@ export namespace revokeRoles {
    * @param args - Arguments.
    * @returns The call.
    */
-  export function call(args: Args) {
+  export function call<chain extends Chain | undefined>(
+    client: Client<Transport, chain>,
+    args: Args,
+  ) {
     const { token, from, role } = args
     const roleHash = TokenRole.serialize(role)
     return defineCall({
-      address: TokenId.toAddress(token),
+      address: resolveToken(client, { token }).address,
       abi: Abis.tip20,
       functionName: 'revokeRole',
       args: [roleHash, from],
@@ -2777,7 +2950,7 @@ export namespace setSupplyCap {
     parameters: setSupplyCap.Parameters<chain, account>,
   ): Promise<ReturnType<action>> {
     const { supplyCap, token, ...rest } = parameters
-    const call = setSupplyCap.call({ supplyCap, token })
+    const call = setSupplyCap.call(client, { supplyCap, token })
     return (await action(client, {
       ...rest,
       ...call,
@@ -2805,7 +2978,7 @@ export namespace setSupplyCap {
    *
    * const { result } = await client.sendCalls({
    *   calls: [
-   *     actions.token.setSupplyCap.call({
+   *     actions.token.setSupplyCap.call(client, {
    *       token: '0x20c0...babe',
    *       supplyCap: 1000000n,
    *     }),
@@ -2816,10 +2989,13 @@ export namespace setSupplyCap {
    * @param args - Arguments.
    * @returns The call.
    */
-  export function call(args: Args) {
+  export function call<chain extends Chain | undefined>(
+    client: Client<Transport, chain>,
+    args: Args,
+  ) {
     const { token, supplyCap } = args
     return defineCall({
-      address: TokenId.toAddress(token),
+      address: resolveToken(client, { token }).address,
       abi: Abis.tip20,
       functionName: 'setSupplyCap',
       args: [supplyCap],
@@ -2976,7 +3152,7 @@ export namespace setRoleAdmin {
     parameters: setRoleAdmin.Parameters<chain, account>,
   ): Promise<ReturnType<action>> {
     const { adminRole, role, token, ...rest } = parameters
-    const call = setRoleAdmin.call({ adminRole, role, token })
+    const call = setRoleAdmin.call(client, { adminRole, role, token })
     return (await action(client, {
       ...rest,
       ...call,
@@ -3004,7 +3180,7 @@ export namespace setRoleAdmin {
    *
    * const { result } = await client.sendCalls({
    *   calls: [
-   *     actions.token.setRoleAdmin.call({
+   *     actions.token.setRoleAdmin.call(client, {
    *       token: '0x20c0...babe',
    *       role: 'issuer',
    *       adminRole: 'admin',
@@ -3016,12 +3192,15 @@ export namespace setRoleAdmin {
    * @param args - Arguments.
    * @returns The call.
    */
-  export function call(args: Args) {
+  export function call<chain extends Chain | undefined>(
+    client: Client<Transport, chain>,
+    args: Args,
+  ) {
     const { token, role, adminRole } = args
     const roleHash = TokenRole.serialize(role)
     const adminRoleHash = TokenRole.serialize(adminRole)
     return defineCall({
-      address: TokenId.toAddress(token),
+      address: resolveToken(client, { token }).address,
       abi: Abis.tip20,
       functionName: 'setRoleAdmin',
       args: [roleHash, adminRoleHash],
@@ -3148,26 +3327,21 @@ export async function transfer<
 }
 
 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. */
+    /** Amount of tokens to transfer, in base units or formatted decimal form. */
+    amount: internal_Token.AmountInput
+    /** Address to transfer tokens from (uses an allowance via `transferFrom`). */
     from?: Address | undefined
     /** Memo to include in the transfer. */
     memo?: Hex.Hex | undefined
-    /** Address or ID of the TIP20 token. */
-    token: TokenId.TokenIdOrAddress
     /** Address to transfer tokens to. */
     to: Address
-  }
-
+  } & TokenParameter
+  export type Parameters<
+    chain extends Chain | undefined = Chain | undefined,
+    account extends Account | undefined = Account | undefined,
+  > = WriteParameters<chain, account> & Args
   export type ReturnValue = WriteContractReturnType
-
   // TODO: exhaustive error type
   export type ErrorType = BaseErrorType
 
@@ -3181,82 +3355,113 @@ export namespace transfer {
     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,
+      ...parameters,
+      ...transfer.call(client, parameters as never),
     } as never)) as never
   }
 
   /**
-   * Defines a call to the `transfer`, `transferFrom`, `transferWithMemo`, or `transferFromWithMemo` function.
-   *
-   * Can be passed as a parameter to:
-   * - [`estimateContractGas`](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
+   * Defines a call to the `transfer`, `transferFrom`, `transferWithMemo`, or
+   * `transferFromWithMemo` function.
    *
-   * @example
-   * ```ts
-   * import { createClient, http, walletActions } from 'viem'
-   * import { tempo } from 'viem/chains'
-   * import { Actions } from 'viem/tempo'
-   *
-   * const client = createClient({
-   *   chain: tempo.extend({ feeToken: '0x20c0000000000000000000000000000000000001' })
-   *   transport: http(),
-   * }).extend(walletActions)
+   * Can be passed as a parameter to `estimateContractGas`, `simulateContract`,
+   * `sendCalls`, `sendTransaction` (`calls`), or `multicall`. The token is
+   * selected by `token`, which is either a TIP20 token id or a contract
+   * `address`; `amount.decimals` is inferred from the client's declared
+   * `tokens` when omitted.
    *
-   * const { result } = await client.sendCalls({
-   *   calls: [
-   *     actions.token.transfer.call({
-   *       to: '0x20c0...beef',
-   *       amount: 100n,
-   *       token: '0x20c0...babe',
-   *     }),
-   *   ]
-   * })
-   * ```
-   *
-   * @param args - Arguments.
+   * @param client - Client.
+   * @param parameters - Parameters.
    * @returns The call.
    */
-  export function call(args: Args) {
-    const { amount, from, memo, token, to } = args
+  export function call<chain extends Chain | undefined>(
+    client: Client<Transport, chain>,
+    parameters: Args,
+  ) {
+    const { from, memo, to, token } = parameters
+    const { address, decimals } = resolveToken(client, { token })
+    const value = internal_Token.toBaseUnits(parameters.amount, decimals)
     const callArgs = (() => {
       if (memo && from)
         return {
           functionName: 'transferFromWithMemo',
-          args: [from, to, amount, Hex.padLeft(memo, 32)],
+          args: [from, to, value, Hex.padLeft(memo, 32)],
         } as const
       if (memo)
         return {
           functionName: 'transferWithMemo',
-          args: [to, amount, Hex.padLeft(memo, 32)],
+          args: [to, value, Hex.padLeft(memo, 32)],
         } as const
       if (from)
         return {
           functionName: 'transferFrom',
-          args: [from, to, amount],
+          args: [from, to, value],
         } as const
       return {
         functionName: 'transfer',
-        args: [to, amount],
+        args: [to, value],
       } as const
     })()
     return defineCall({
-      address: TokenId.toAddress(token),
+      address,
       abi: Abis.tip20,
       ...callArgs,
     })
   }
 
   /**
-   * Extracts the event from the logs.
+   * Estimates the gas required to transfer TIP20 tokens. `amount.decimals` is
+   * inferred from the client's declared `tokens` when omitted.
+   *
+   * @param client - Client.
+   * @param parameters - Parameters.
+   * @returns The gas estimate.
+   */
+  export async function estimateGas<
+    chain extends Chain | undefined,
+    account extends Account | undefined,
+  >(
+    client: Client<Transport, chain, account>,
+    parameters: transfer.Parameters<chain, account>,
+  ): Promise<bigint> {
+    return estimateContractGas(client, {
+      ...pickWriteParameters(parameters as never),
+      ...transfer.call(client, parameters as never),
+    } as never)
+  }
+
+  /**
+   * Simulates a transfer of TIP20 tokens. `amount.decimals` is inferred from
+   * the client's declared `tokens` when omitted.
+   *
+   * @param client - Client.
+   * @param parameters - Parameters.
+   * @returns The simulation result and write request.
+   */
+  export async function simulate<
+    chain extends Chain | undefined,
+    account extends Account | undefined,
+  >(
+    client: Client<Transport, chain, account>,
+    parameters: transfer.Parameters<chain, account>,
+  ): Promise<
+    SimulateContractReturnType<
+      typeof Abis.tip20,
+      'transfer' | 'transferFrom' | 'transferWithMemo' | 'transferFromWithMemo'
+    >
+  > {
+    return simulateContract(client, {
+      ...pickWriteParameters(parameters as never),
+      ...transfer.call(client, parameters as never),
+    } as never) as never
+  }
+
+  /**
+   * Extracts the `Transfer` event from logs.
    *
    * @param logs - Logs.
-   * @returns The event.
+   * @returns The `Transfer` event.
    */
   export function extractEvent(logs: Log[]) {
     const [log] = parseEventLogs({
@@ -3302,34 +3507,43 @@ export async function transferSync<
   client: Client<Transport, chain, account>,
   parameters: transferSync.Parameters<chain, account>,
 ): Promise<transferSync.ReturnValue> {
-  const { throwOnReceiptRevert = true, ...rest } = parameters
+  const { amount, token, throwOnReceiptRevert = true } = parameters
+  const { decimals } = resolveToken(client, { token })
+  const resolved = internal_Token.resolveAmountDecimals(amount, decimals)
   const receipt = await transfer.inner(writeContractSync, client, {
-    ...rest,
+    ...parameters,
     throwOnReceiptRevert,
   } as never)
   const { args } = transfer.extractEvent(receipt.logs)
   return {
     ...args,
+    ...(resolved === undefined
+      ? {}
+      : { decimals: resolved, formatted: formatUnits(args.amount, resolved) }),
     receipt,
   } as never
 }
 
 export namespace transferSync {
+  export type Args = transfer.Args
   export type Parameters<
     chain extends Chain | undefined = Chain | undefined,
     account extends Account | undefined = Account | undefined,
   > = transfer.Parameters<chain, account>
-
-  export type Args = transfer.Args
-
-  export type ReturnValue = GetEventArgs<
-    typeof Abis.tip20,
-    'Transfer',
-    { IndexedOnly: false; Required: true }
-  > & {
-    receipt: TransactionReceipt
-  }
-
+  export type ReturnValue = Compute<
+    GetEventArgs<
+      typeof Abis.tip20,
+      'Transfer',
+      { IndexedOnly: false; Required: true }
+    > & {
+      /** Token decimals used to derive `formatted`, if known. */
+      decimals?: number | undefined
+      /** Transferred amount formatted with the token's `decimals`, if known. */
+      formatted?: string | undefined
+      /** Transaction receipt. */
+      receipt: TransactionReceipt
+    }
+  >
   // TODO: exhaustive error type
   export type ErrorType = BaseErrorType
 }
@@ -3396,7 +3610,7 @@ export namespace unpause {
     parameters: unpause.Parameters<chain, account>,
   ): Promise<ReturnType<action>> {
     const { token, ...rest } = parameters
-    const call = unpause.call({ token })
+    const call = unpause.call(client, { token })
     return (await action(client, {
       ...rest,
       ...call,
@@ -3424,7 +3638,7 @@ export namespace unpause {
    *
    * const { result } = await client.sendCalls({
    *   calls: [
-   *     actions.token.unpause.call({
+   *     actions.token.unpause.call(client, {
    *       token: '0x20c0...babe',
    *     }),
    *   ]
@@ -3434,10 +3648,13 @@ export namespace unpause {
    * @param args - Arguments.
    * @returns The call.
    */
-  export function call(args: Args) {
+  export function call<chain extends Chain | undefined>(
+    client: Client<Transport, chain>,
+    args: Args,
+  ) {
     const { token } = args
     return defineCall({
-      address: TokenId.toAddress(token),
+      address: resolveToken(client, { token }).address,
       abi: Abis.tip20,
       functionName: 'unpause',
       args: [],
@@ -3590,7 +3807,7 @@ export namespace prepareUpdateQuoteToken {
     parameters: prepareUpdateQuoteToken.Parameters<chain, account>,
   ): Promise<ReturnType<action>> {
     const { quoteToken, token, ...rest } = parameters
-    const call = prepareUpdateQuoteToken.call({ quoteToken, token })
+    const call = prepareUpdateQuoteToken.call(client, { quoteToken, token })
     return (await action(client, {
       ...rest,
       ...call,
@@ -3618,7 +3835,7 @@ export namespace prepareUpdateQuoteToken {
    *
    * const { result } = await client.sendCalls({
    *   calls: [
-   *     actions.token.prepareUpdateQuoteToken.call({
+   *     actions.token.prepareUpdateQuoteToken.call(client, {
    *       token: '0x20c0...babe',
    *       quoteToken: '0x20c0...cafe',
    *     }),
@@ -3629,13 +3846,16 @@ export namespace prepareUpdateQuoteToken {
    * @param args - Arguments.
    * @returns The call.
    */
-  export function call(args: Args) {
+  export function call<chain extends Chain | undefined>(
+    client: Client<Transport, chain>,
+    args: Args,
+  ) {
     const { token, quoteToken } = args
     return defineCall({
-      address: TokenId.toAddress(token),
+      address: resolveToken(client, { token }).address,
       abi: Abis.tip20,
       functionName: 'setNextQuoteToken',
-      args: [TokenId.toAddress(quoteToken)],
+      args: [resolveToken(client, { token: quoteToken }).address],
     })
   }
 
@@ -3788,7 +4008,7 @@ export namespace updateQuoteToken {
     parameters: updateQuoteToken.Parameters<chain, account>,
   ): Promise<ReturnType<action>> {
     const { token, ...rest } = parameters
-    const call = updateQuoteToken.call({ token })
+    const call = updateQuoteToken.call(client, { token })
     return (await action(client, {
       ...rest,
       ...call,
@@ -3816,7 +4036,7 @@ export namespace updateQuoteToken {
    *
    * const { result } = await client.sendCalls({
    *   calls: [
-   *     actions.token.updateQuoteToken.call({
+   *     actions.token.updateQuoteToken.call(client, {
    *       token: '0x20c0...babe',
    *     }),
    *   ]
@@ -3826,10 +4046,13 @@ export namespace updateQuoteToken {
    * @param args - Arguments.
    * @returns The call.
    */
-  export function call(args: Args) {
+  export function call<chain extends Chain | undefined>(
+    client: Client<Transport, chain>,
+    args: Args,
+  ) {
     const { token } = args
     return defineCall({
-      address: TokenId.toAddress(token),
+      address: resolveToken(client, { token }).address,
       abi: Abis.tip20,
       functionName: 'completeQuoteTokenUpdate',
       args: [],
@@ -3957,7 +4180,7 @@ export function watchApprove<
   const { onApproval, token, ...rest } = parameters
   return watchContractEvent(client, {
     ...rest,
-    address: TokenId.toAddress(token),
+    address: resolveToken(client, { token }).address,
     abi: Abis.tip20,
     eventName: 'Approval',
     onLogs: (logs) => {
@@ -4025,7 +4248,7 @@ export function watchBurn<
   const { onBurn, token, ...rest } = parameters
   return watchContractEvent(client, {
     ...rest,
-    address: TokenId.toAddress(token),
+    address: resolveToken(client, { token }).address,
     abi: Abis.tip20,
     eventName: 'Burn',
     onLogs: (logs) => {
@@ -4166,7 +4389,7 @@ export function watchMint<
   const { onMint, token, ...rest } = parameters
   return watchContractEvent(client, {
     ...rest,
-    address: TokenId.toAddress(token),
+    address: resolveToken(client, { token }).address,
     abi: Abis.tip20,
     eventName: 'Mint',
     onLogs: (logs) => {
@@ -4239,7 +4462,7 @@ export function watchAdminRole<
   const { onRoleAdminUpdated, token, ...rest } = parameters
   return watchContractEvent(client, {
     ...rest,
-    address: TokenId.toAddress(token),
+    address: resolveToken(client, { token }).address,
     abi: Abis.tip20,
     eventName: 'RoleAdminUpdated',
     onLogs: (logs) => {
@@ -4307,7 +4530,7 @@ export function watchRole<
   const { onRoleUpdated, token, ...rest } = parameters
   return watchContractEvent(client, {
     ...rest,
-    address: TokenId.toAddress(token),
+    address: resolveToken(client, { token }).address,
     abi: Abis.tip20,
     eventName: 'RoleMembershipUpdated',
     onLogs: (logs) => {
@@ -4389,7 +4612,7 @@ export function watchTransfer<
   const { onTransfer, token, ...rest } = parameters
   return watchContractEvent(client, {
     ...rest,
-    address: TokenId.toAddress(token),
+    address: resolveToken(client, { token }).address,
     abi: Abis.tip20,
     eventName: 'Transfer',
     onLogs: (logs) => {
@@ -4461,7 +4684,7 @@ export function watchUpdateQuoteToken<
   parameters: watchUpdateQuoteToken.Parameters,
 ) {
   const { onUpdateQuoteToken, token, ...rest } = parameters
-  const address = TokenId.toAddress(token)
+  const address = resolveToken(client, { token }).address
 
   return watchContractEvent(client, {
     ...rest,