viem 2.53.1 → 2.54.1

package/_esm/tempo/actions/token.js

@@ -1,18 +1,23 @@
 import * as Hex from 'ox/Hex';
 import { TokenId, TokenRole } from 'ox/tempo';
 import { parseAccount } from '../../accounts/utils/parseAccount.js';
+import { estimateContractGas } from '../../actions/public/estimateContractGas.js';
 import { multicall } from '../../actions/public/multicall.js';
 import { readContract } from '../../actions/public/readContract.js';
+import { simulateContract, } from '../../actions/public/simulateContract.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 { sendTransactionSync, } from '../../actions/wallet/sendTransactionSync.js';
 import { writeContract } from '../../actions/wallet/writeContract.js';
 import { writeContractSync } from '../../actions/wallet/writeContractSync.js';
+import { AccountNotFoundError } from '../../errors/account.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 { defineCall } from '../internal/utils.js';
+import { defineCall, findDeclaredToken, pickWriteParameters, resolveToken, resolveTokenWithDecimals, } from '../internal/utils.js';
 /**
  * Approves a spender to transfer TIP20 tokens on behalf of the caller.
  *
@@ -40,62 +45,77 @@ import { defineCall } from '../internal/utils.js';
  * @returns The transaction hash.
  */
 export async function approve(client, parameters) {
-    const { token, ...rest } = parameters;
-    return approve.inner(writeContract, client, parameters, { ...rest, token });
+    return approve.inner(writeContract, client, parameters);
 }
 (function (approve) {
     /** @internal */
-    async function inner(action, client, parameters, args) {
-        const call = approve.call(args);
+    async function inner(action, client, parameters) {
         return (await action(client, {
             ...parameters,
-            ...call,
+            ...approve.call(client, parameters),
         }));
     }
     approve.inner = inner;
     /**
      * 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.
      */
-    function call(args) {
-        const { spender, amount, token } = args;
+    function call(client, parameters) {
+        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)],
         });
     }
     approve.call = call;
+    /**
+     * 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.
+     */
+    async function estimateGas(client, parameters) {
+        return estimateContractGas(client, {
+            ...pickWriteParameters(parameters),
+            ...approve.call(client, parameters),
+        });
+    }
+    approve.estimateGas = estimateGas;
+    /**
+     * 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.
+     */
+    async function simulate(client, parameters) {
+        return simulateContract(client, {
+            ...pickWriteParameters(parameters),
+            ...approve.call(client, parameters),
+        });
+    }
+    approve.simulate = simulate;
+    /**
+     * Extracts the `Approval` event from logs.
+     *
+     * @param logs - The logs.
+     * @returns The `Approval` event.
+     */
     function extractEvent(logs) {
         const [log] = parseEventLogs({
             abi: Abis.tip20,
@@ -135,11 +155,19 @@ export async function approve(client, parameters) {
  * @returns The transaction receipt and event data.
  */
 export async function approveSync(client, parameters) {
-    const { throwOnReceiptRevert = true, ...rest } = parameters;
-    const receipt = await approve.inner(writeContractSync, client, { ...parameters, throwOnReceiptRevert }, 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,
+    });
     const { args } = approve.extractEvent(receipt.logs);
     return {
         ...args,
+        ...(resolved === undefined
+            ? {}
+            : { decimals: resolved, formatted: formatUnits(args.amount, resolved) }),
         receipt,
     };
 }
@@ -177,7 +205,7 @@ export async function burnBlocked(client, parameters) {
     /** @internal */
     async function inner(action, client, parameters) {
         const { amount, from, token, ...rest } = parameters;
-        const call = burnBlocked.call({ amount, from, token });
+        const call = burnBlocked.call(client, { amount, from, token });
         return (await action(client, {
             ...rest,
             ...call,
@@ -205,7 +233,7 @@ export async function burnBlocked(client, parameters) {
      *
      * const { result } = await client.sendCalls({
      *   calls: [
-     *     actions.token.burnBlocked.call({
+     *     actions.token.burnBlocked.call(client, {
      *       from: '0x20c0...beef',
      *       amount: 100n,
      *       token: '0x20c0...babe',
@@ -214,16 +242,19 @@ export async function burnBlocked(client, parameters) {
      * })
      * ```
      *
+     * `amount.decimals` is inferred from the client's declared `tokens` when omitted.
+     *
      * @param args - Arguments.
      * @returns The call.
      */
-    function call(args) {
+    function call(client, 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)],
         });
     }
     burnBlocked.call = call;
@@ -317,7 +348,7 @@ export async function burn(client, parameters) {
     /** @internal */
     async function inner(action, client, parameters) {
         const { amount, memo, token, ...rest } = parameters;
-        const call = burn.call({ amount, memo, token });
+        const call = burn.call(client, { amount, memo, token });
         return (await action(client, {
             ...rest,
             ...call,
@@ -345,7 +376,7 @@ export async function burn(client, parameters) {
      *
      * const { result } = await client.sendCalls({
      *   calls: [
-     *     actions.token.burn.call({
+     *     actions.token.burn.call(client, {
      *       amount: 100n,
      *       token: '0x20c0...babe',
      *     }),
@@ -353,22 +384,26 @@ export async function burn(client, parameters) {
      * })
      * ```
      *
+     * `amount.decimals` is inferred from the client's declared `tokens` when omitted.
+     *
      * @param args - Arguments.
      * @returns The call.
      */
-    function call(args) {
+    function call(client, 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)],
             }
             : {
                 functionName: 'burn',
-                args: [amount],
+                args: [value],
             };
         return defineCall({
-            address: TokenId.toAddress(token),
+            address,
             abi: Abis.tip20,
             ...callArgs,
         });
@@ -463,7 +498,7 @@ export async function changeTransferPolicy(client, parameters) {
     /** @internal */
     async function inner(action, client, parameters) {
         const { policyId, token, ...rest } = parameters;
-        const call = changeTransferPolicy.call({ policyId, token });
+        const call = changeTransferPolicy.call(client, { policyId, token });
         return (await action(client, {
             ...rest,
             ...call,
@@ -491,7 +526,7 @@ export async function changeTransferPolicy(client, parameters) {
      *
      * const { result } = await client.sendCalls({
      *   calls: [
-     *     actions.token.changeTransferPolicy.call({
+     *     actions.token.changeTransferPolicy.call(client, {
      *       token: '0x20c0...babe',
      *       policyId: 1n,
      *     }),
@@ -502,10 +537,10 @@ export async function changeTransferPolicy(client, parameters) {
      * @param args - Arguments.
      * @returns The call.
      */
-    function call(args) {
+    function call(client, args) {
         const { token, policyId } = args;
         return defineCall({
-            address: TokenId.toAddress(token),
+            address: resolveToken(client, { token }).address,
             abi: Abis.tip20,
             functionName: 'changeTransferPolicyId',
             args: [policyId],
@@ -606,7 +641,7 @@ export async function create(client, parameters) {
         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, {
             ...parameters,
             account,
@@ -636,7 +671,7 @@ export async function create(client, parameters) {
      *
      * const { result } = await client.sendCalls({
      *   calls: [
-     *     actions.token.create.call({
+     *     actions.token.create.call(client, {
      *       name: 'My Token',
      *       symbol: 'MTK',
      *       currency: 'USD',
@@ -650,7 +685,7 @@ export async function create(client, parameters) {
      * @param args - Arguments.
      * @returns The call.
      */
-    function call(args) {
+    function call(client, args) {
         const { name, symbol, currency, logoURI, quoteToken = Addresses.pathUsd, admin, salt = Hex.random(32), } = args;
         return defineCall({
             address: Addresses.tip20Factory,
@@ -660,7 +695,7 @@ export async function create(client, parameters) {
                     name,
                     symbol,
                     currency,
-                    TokenId.toAddress(quoteToken),
+                    resolveToken(client, { token: quoteToken }).address,
                     admin,
                     salt,
                     logoURI,
@@ -669,7 +704,7 @@ export async function create(client, parameters) {
                     name,
                     symbol,
                     currency,
-                    TokenId.toAddress(quoteToken),
+                    resolveToken(client, { token: quoteToken }).address,
                     admin,
                     salt,
                 ],
@@ -755,38 +790,48 @@ export async function createSync(client, parameters) {
  * })
  *
  * 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(client, parameters) {
-    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 }),
+        }),
+        resolveTokenWithDecimals(client, {
+            decimals,
+            token,
+        }),
+    ]);
+    return internal_Token.toAmount(amount, resolved);
 }
 (function (getAllowance) {
     /**
      * 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.
      */
-    function call(args) {
-        const { account, spender, token } = args;
+    function call(client, 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],
         });
     }
     getAllowance.call = call;
@@ -808,35 +853,51 @@ export async function getAllowance(client, parameters) {
  * })
  *
  * 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(client, parameters) {
-    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 }),
+        }),
+        resolveTokenWithDecimals(client, {
+            decimals,
+            token,
+        }),
+    ]);
+    return internal_Token.toAmount(amount, resolved);
 }
 (function (getBalance) {
     /**
      * 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.
      */
-    function call(args) {
-        const { account, token } = args;
+    function call(client, args) {
+        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],
@@ -871,9 +932,15 @@ export async function getBalance(client, parameters) {
  */
 export async function getMetadata(client, parameters) {
     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: [
@@ -917,6 +984,7 @@ export async function getMetadata(client, parameters) {
             decimals: unwrapMulticallResult(decimals),
             logoURI: unwrapMulticallResult(logoURI, ''),
             totalSupply: unwrapMulticallResult(totalSupply),
+            ...overrides,
         }));
     return multicall(client, {
         ...rest,
@@ -985,6 +1053,7 @@ export async function getMetadata(client, parameters) {
         paused: unwrapMulticallResult(paused),
         supplyCap: unwrapMulticallResult(supplyCap),
         transferPolicyId: unwrapMulticallResult(transferPolicyId),
+        ...overrides,
     }));
 }
 function unwrapMulticallResult(response, ...fallback) {
@@ -995,6 +1064,65 @@ function unwrapMulticallResult(response, ...fallback) {
     }
     return response.result;
 }
+/**
+ * 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(client, parameters) {
+    const { decimals, token, ...rest } = parameters;
+    const [amount, { decimals: resolved }] = await Promise.all([
+        readContract(client, {
+            ...rest,
+            ...getTotalSupply.call(client, { token }),
+        }),
+        resolveTokenWithDecimals(client, {
+            decimals,
+            token,
+        }),
+    ]);
+    return internal_Token.toAmount(amount, resolved);
+}
+(function (getTotalSupply) {
+    /**
+     * 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.
+     */
+    function call(client, args) {
+        return defineCall({
+            address: resolveToken(client, args).address,
+            abi: Abis.tip20,
+            args: [],
+            functionName: 'totalSupply',
+        });
+    }
+    getTotalSupply.call = call;
+})(getTotalSupply || (getTotalSupply = {}));
 /**
  * Gets the admin role for a specific role in a TIP20 token.
  *
@@ -1022,7 +1150,7 @@ function unwrapMulticallResult(response, ...fallback) {
 export async function getRoleAdmin(client, parameters) {
     return readContract(client, {
         ...parameters,
-        ...getRoleAdmin.call(parameters),
+        ...getRoleAdmin.call(client, parameters),
     });
 }
 (function (getRoleAdmin) {
@@ -1032,10 +1160,10 @@ export async function getRoleAdmin(client, parameters) {
      * @param args - Arguments.
      * @returns The call.
      */
-    function call(args) {
+    function call(client, 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)],
@@ -1075,7 +1203,7 @@ export async function hasRole(client, parameters) {
         throw new Error('account is required.');
     return readContract(client, {
         ...parameters,
-        ...hasRole.call({ ...parameters, account: address }),
+        ...hasRole.call(client, { ...parameters, account: address }),
     });
 }
 (function (hasRole) {
@@ -1085,10 +1213,10 @@ export async function hasRole(client, parameters) {
      * @param args - Arguments.
      * @returns The call.
      */
-    function call(args) {
+    function call(client, 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)],
@@ -1132,7 +1260,7 @@ export async function grantRoles(client, parameters) {
         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),
@@ -1162,7 +1290,7 @@ export async function grantRoles(client, parameters) {
      *
      * const { result } = await client.sendCalls({
      *   calls: [
-     *     actions.token.grantRoles.call({
+     *     actions.token.grantRoles.call(client, {
      *       token: '0x20c0...babe',
      *       to: '0x20c0...beef',
      *       role: 'issuer',
@@ -1174,11 +1302,11 @@ export async function grantRoles(client, parameters) {
      * @param args - Arguments.
      * @returns The call.
      */
-    function call(args) {
+    function call(client, 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],
@@ -1276,9 +1404,10 @@ export async function mint(client, parameters) {
 (function (mint) {
     /** @internal */
     async function inner(action, client, parameters) {
-        const call = mint.call(parameters);
+        const { amount, memo, to, token, ...rest } = parameters;
+        const call = mint.call(client, { amount, memo, to, token });
         return (await action(client, {
-            ...parameters,
+            ...rest,
             ...call,
         }));
     }
@@ -1304,7 +1433,7 @@ export async function mint(client, parameters) {
      *
      * const { result } = await client.sendCalls({
      *   calls: [
-     *     actions.token.mint.call({
+     *     actions.token.mint.call(client, {
      *       to: '0x20c0...beef',
      *       amount: 100n,
      *       token: '0x20c0...babe',
@@ -1313,22 +1442,26 @@ export async function mint(client, parameters) {
      * })
      * ```
      *
+     * `amount.decimals` is inferred from the client's declared `tokens` when omitted.
+     *
      * @param args - Arguments.
      * @returns The call.
      */
-    function call(args) {
+    function call(client, 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)],
             }
             : {
                 functionName: 'mint',
-                args: [to, amount],
+                args: [to, value],
             };
         return defineCall({
-            address: TokenId.toAddress(token),
+            address,
             abi: Abis.tip20,
             ...callArgs,
         });
@@ -1423,7 +1556,7 @@ export async function pause(client, parameters) {
     /** @internal */
     async function inner(action, client, parameters) {
         const { token, ...rest } = parameters;
-        const call = pause.call({ token });
+        const call = pause.call(client, { token });
         return (await action(client, {
             ...rest,
             ...call,
@@ -1451,7 +1584,7 @@ export async function pause(client, parameters) {
      *
      * const { result } = await client.sendCalls({
      *   calls: [
-     *     actions.token.pause.call({
+     *     actions.token.pause.call(client, {
      *       token: '0x20c0...babe',
      *     }),
      *   ]
@@ -1461,10 +1594,10 @@ export async function pause(client, parameters) {
      * @param args - Arguments.
      * @returns The call.
      */
-    function call(args) {
+    function call(client, args) {
         const { token } = args;
         return defineCall({
-            address: TokenId.toAddress(token),
+            address: resolveToken(client, { token }).address,
             abi: Abis.tip20,
             functionName: 'pause',
             args: [],
@@ -1561,7 +1694,7 @@ export async function renounceRoles(client, parameters) {
         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),
@@ -1591,7 +1724,7 @@ export async function renounceRoles(client, parameters) {
      *
      * const { result } = await client.sendCalls({
      *   calls: [
-     *     actions.token.renounceRoles.call({
+     *     actions.token.renounceRoles.call(client, {
      *       token: '0x20c0...babe',
      *       role: 'issuer',
      *     }),
@@ -1602,11 +1735,11 @@ export async function renounceRoles(client, parameters) {
      * @param args - Arguments.
      * @returns The call.
      */
-    function call(args) {
+    function call(client, 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],
@@ -1707,7 +1840,7 @@ export async function revokeRoles(client, parameters) {
         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),
@@ -1737,7 +1870,7 @@ export async function revokeRoles(client, parameters) {
      *
      * const { result } = await client.sendCalls({
      *   calls: [
-     *     actions.token.revokeRoles.call({
+     *     actions.token.revokeRoles.call(client, {
      *       token: '0x20c0...babe',
      *       from: '0x20c0...beef',
      *       role: 'issuer',
@@ -1749,11 +1882,11 @@ export async function revokeRoles(client, parameters) {
      * @param args - Arguments.
      * @returns The call.
      */
-    function call(args) {
+    function call(client, 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],
@@ -1851,7 +1984,7 @@ export async function setSupplyCap(client, parameters) {
     /** @internal */
     async function inner(action, client, parameters) {
         const { supplyCap, token, ...rest } = parameters;
-        const call = setSupplyCap.call({ supplyCap, token });
+        const call = setSupplyCap.call(client, { supplyCap, token });
         return (await action(client, {
             ...rest,
             ...call,
@@ -1879,7 +2012,7 @@ export async function setSupplyCap(client, parameters) {
      *
      * const { result } = await client.sendCalls({
      *   calls: [
-     *     actions.token.setSupplyCap.call({
+     *     actions.token.setSupplyCap.call(client, {
      *       token: '0x20c0...babe',
      *       supplyCap: 1000000n,
      *     }),
@@ -1890,10 +2023,10 @@ export async function setSupplyCap(client, parameters) {
      * @param args - Arguments.
      * @returns The call.
      */
-    function call(args) {
+    function call(client, args) {
         const { token, supplyCap } = args;
         return defineCall({
-            address: TokenId.toAddress(token),
+            address: resolveToken(client, { token }).address,
             abi: Abis.tip20,
             functionName: 'setSupplyCap',
             args: [supplyCap],
@@ -1990,7 +2123,7 @@ export async function setRoleAdmin(client, parameters) {
     /** @internal */
     async function inner(action, client, parameters) {
         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,
@@ -2018,7 +2151,7 @@ export async function setRoleAdmin(client, parameters) {
      *
      * const { result } = await client.sendCalls({
      *   calls: [
-     *     actions.token.setRoleAdmin.call({
+     *     actions.token.setRoleAdmin.call(client, {
      *       token: '0x20c0...babe',
      *       role: 'issuer',
      *       adminRole: 'admin',
@@ -2030,12 +2163,12 @@ export async function setRoleAdmin(client, parameters) {
      * @param args - Arguments.
      * @returns The call.
      */
-    function call(args) {
+    function call(client, 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],
@@ -2131,82 +2264,93 @@ export async function transfer(client, parameters) {
 (function (transfer) {
     /** @internal */
     async function inner(action, client, parameters) {
-        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),
         }));
     }
     transfer.inner = inner;
     /**
-     * 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'
+     * 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 client = createClient({
-     *   chain: tempo.extend({ feeToken: '0x20c0000000000000000000000000000000000001' })
-     *   transport: http(),
-     * }).extend(walletActions)
-     *
-     * const { result } = await client.sendCalls({
-     *   calls: [
-     *     actions.token.transfer.call({
-     *       to: '0x20c0...beef',
-     *       amount: 100n,
-     *       token: '0x20c0...babe',
-     *     }),
-     *   ]
-     * })
-     * ```
-     *
-     * @param args - Arguments.
+     * @param client - Client.
+     * @param parameters - Parameters.
      * @returns The call.
      */
-    function call(args) {
-        const { amount, from, memo, token, to } = args;
+    function call(client, parameters) {
+        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)],
                 };
             if (memo)
                 return {
                     functionName: 'transferWithMemo',
-                    args: [to, amount, Hex.padLeft(memo, 32)],
+                    args: [to, value, Hex.padLeft(memo, 32)],
                 };
             if (from)
                 return {
                     functionName: 'transferFrom',
-                    args: [from, to, amount],
+                    args: [from, to, value],
                 };
             return {
                 functionName: 'transfer',
-                args: [to, amount],
+                args: [to, value],
             };
         })();
         return defineCall({
-            address: TokenId.toAddress(token),
+            address,
             abi: Abis.tip20,
             ...callArgs,
         });
     }
     transfer.call = call;
     /**
-     * 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.
+     */
+    async function estimateGas(client, parameters) {
+        return estimateContractGas(client, {
+            ...pickWriteParameters(parameters),
+            ...transfer.call(client, parameters),
+        });
+    }
+    transfer.estimateGas = estimateGas;
+    /**
+     * 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.
+     */
+    async function simulate(client, parameters) {
+        return simulateContract(client, {
+            ...pickWriteParameters(parameters),
+            ...transfer.call(client, parameters),
+        });
+    }
+    transfer.simulate = simulate;
+    /**
+     * Extracts the `Transfer` event from logs.
      *
      * @param logs - Logs.
-     * @returns The event.
+     * @returns The `Transfer` event.
      */
     function extractEvent(logs) {
         const [log] = parseEventLogs({
@@ -2247,14 +2391,19 @@ export async function transfer(client, parameters) {
  * @returns The transaction receipt and event data.
  */
 export async function transferSync(client, parameters) {
-    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,
     });
     const { args } = transfer.extractEvent(receipt.logs);
     return {
         ...args,
+        ...(resolved === undefined
+            ? {}
+            : { decimals: resolved, formatted: formatUnits(args.amount, resolved) }),
         receipt,
     };
 }
@@ -2290,7 +2439,7 @@ export async function unpause(client, parameters) {
     /** @internal */
     async function inner(action, client, parameters) {
         const { token, ...rest } = parameters;
-        const call = unpause.call({ token });
+        const call = unpause.call(client, { token });
         return (await action(client, {
             ...rest,
             ...call,
@@ -2318,7 +2467,7 @@ export async function unpause(client, parameters) {
      *
      * const { result } = await client.sendCalls({
      *   calls: [
-     *     actions.token.unpause.call({
+     *     actions.token.unpause.call(client, {
      *       token: '0x20c0...babe',
      *     }),
      *   ]
@@ -2328,10 +2477,10 @@ export async function unpause(client, parameters) {
      * @param args - Arguments.
      * @returns The call.
      */
-    function call(args) {
+    function call(client, args) {
         const { token } = args;
         return defineCall({
-            address: TokenId.toAddress(token),
+            address: resolveToken(client, { token }).address,
             abi: Abis.tip20,
             functionName: 'unpause',
             args: [],
@@ -2426,7 +2575,7 @@ export async function prepareUpdateQuoteToken(client, parameters) {
     /** @internal */
     async function inner(action, client, parameters) {
         const { quoteToken, token, ...rest } = parameters;
-        const call = prepareUpdateQuoteToken.call({ quoteToken, token });
+        const call = prepareUpdateQuoteToken.call(client, { quoteToken, token });
         return (await action(client, {
             ...rest,
             ...call,
@@ -2454,7 +2603,7 @@ export async function prepareUpdateQuoteToken(client, parameters) {
      *
      * const { result } = await client.sendCalls({
      *   calls: [
-     *     actions.token.prepareUpdateQuoteToken.call({
+     *     actions.token.prepareUpdateQuoteToken.call(client, {
      *       token: '0x20c0...babe',
      *       quoteToken: '0x20c0...cafe',
      *     }),
@@ -2465,13 +2614,13 @@ export async function prepareUpdateQuoteToken(client, parameters) {
      * @param args - Arguments.
      * @returns The call.
      */
-    function call(args) {
+    function call(client, 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],
         });
     }
     prepareUpdateQuoteToken.call = call;
@@ -2559,7 +2708,7 @@ export async function updateQuoteToken(client, parameters) {
     /** @internal */
     async function inner(action, client, parameters) {
         const { token, ...rest } = parameters;
-        const call = updateQuoteToken.call({ token });
+        const call = updateQuoteToken.call(client, { token });
         return (await action(client, {
             ...rest,
             ...call,
@@ -2587,7 +2736,7 @@ export async function updateQuoteToken(client, parameters) {
      *
      * const { result } = await client.sendCalls({
      *   calls: [
-     *     actions.token.updateQuoteToken.call({
+     *     actions.token.updateQuoteToken.call(client, {
      *       token: '0x20c0...babe',
      *     }),
      *   ]
@@ -2597,10 +2746,10 @@ export async function updateQuoteToken(client, parameters) {
      * @param args - Arguments.
      * @returns The call.
      */
-    function call(args) {
+    function call(client, args) {
         const { token } = args;
         return defineCall({
-            address: TokenId.toAddress(token),
+            address: resolveToken(client, { token }).address,
             abi: Abis.tip20,
             functionName: 'completeQuoteTokenUpdate',
             args: [],
@@ -2687,7 +2836,7 @@ export function watchApprove(client, parameters) {
     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) => {
@@ -2726,7 +2875,7 @@ export function watchBurn(client, parameters) {
     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) => {
@@ -2804,7 +2953,7 @@ export function watchMint(client, parameters) {
     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) => {
@@ -2843,7 +2992,7 @@ export function watchAdminRole(client, parameters) {
     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) => {
@@ -2882,7 +3031,7 @@ export function watchRole(client, parameters) {
     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) => {
@@ -2924,7 +3073,7 @@ export function watchTransfer(client, parameters) {
     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) => {
@@ -2964,7 +3113,7 @@ export function watchTransfer(client, parameters) {
  */
 export function watchUpdateQuoteToken(client, parameters) {
     const { onUpdateQuoteToken, token, ...rest } = parameters;
-    const address = TokenId.toAddress(token);
+    const address = resolveToken(client, { token }).address;
     return watchContractEvent(client, {
         ...rest,
         address,