tempo.ts 0.11.0 → 0.11.1

package/dist/viem/Decorator.d.ts

@@ -0,0 +1,2783 @@
+import type { Account, Chain, Client, Transport } from 'viem';
+import type { VerifyHashParameters, VerifyHashReturnType } from 'viem/actions';
+import type { PartialBy } from '../internal/types.js';
+import * as ammActions from './Actions/amm.js';
+import * as dexActions from './Actions/dex.js';
+import * as faucetActions from './Actions/faucet.js';
+import * as feeActions from './Actions/fee.js';
+import * as policyActions from './Actions/policy.js';
+import * as rewardActions from './Actions/reward.js';
+import * as tokenActions from './Actions/token.js';
+export type Decorator<chain extends Chain | undefined = Chain | undefined, account extends Account | undefined = Account | undefined> = {
+    /**
+     * Verifies that a signature is valid for a given hash and address.
+     * Supports Secp256k1, P256, WebCrypto P256, and WebAuthn signatures.
+     *
+     * @example
+     * ```ts
+     * import { createClient, http } from 'viem'
+     * import { tempo } from 'tempo.ts/chains'
+     * import { tempoActions } from 'tempo.ts/viem'
+     *
+     * const client = createClient({
+     *   chain: tempo({ feeToken: '0x20c0000000000000000000000000000000000001' })
+     *   transport: http(),
+     * }).extend(tempoActions())
+     *
+     * const valid = await client.verifyHash({
+     *   address: '0x...',
+     *   hash: '0x...',
+     *   signature: '0x...',
+     * })
+     * ```
+     *
+     * @param parameters - Parameters.
+     * @returns Whether the signature is valid.
+     */
+    verifyHash: (parameters: PartialBy<VerifyHashParameters, 'address'>) => Promise<VerifyHashReturnType>;
+    amm: {
+        /**
+         * Gets the reserves for a liquidity pool.
+         *
+         * @example
+         * ```ts
+         * import { createClient, http } from 'viem'
+         * import { tempo } from 'tempo.ts/chains'
+         * import { tempoActions } from 'tempo.ts/viem'
+         *
+         * const client = createClient({
+         *   chain: tempo({ feeToken: '0x20c...001' }),
+         *   transport: http(),
+         * }).extend(tempoActions())
+         *
+         * const pool = await client.amm.getPool({
+         *   userToken: '0x...',
+         *   validatorToken: '0x...',
+         * })
+         * ```
+         *
+         * @param parameters - Parameters.
+         * @returns The pool reserves.
+         */
+        getPool: (parameters: ammActions.getPool.Parameters) => Promise<ammActions.getPool.ReturnValue>;
+        /**
+         * Gets the LP token balance for an account in a specific pool.
+         *
+         * @example
+         * ```ts
+         * import { createClient, http } from 'viem'
+         * import { tempo } from 'tempo.ts/chains'
+         * import { tempoActions } from 'tempo.ts/viem'
+         *
+         * const client = createClient({
+         *   chain: tempo({ feeToken: '0x20c0000000000000000000000000000000000001' })
+         *   transport: http(),
+         * }).extend(tempoActions())
+         *
+         * const poolId = await client.amm.getPoolId({
+         *   userToken: '0x...',
+         *   validatorToken: '0x...',
+         * })
+         *
+         * const balance = await client.amm.getLiquidityBalance({
+         *   poolId,
+         *   address: '0x...',
+         * })
+         * ```
+         *
+         * @param parameters - Parameters.
+         * @returns The LP token balance.
+         */
+        getLiquidityBalance: (parameters: ammActions.getLiquidityBalance.Parameters) => Promise<ammActions.getLiquidityBalance.ReturnValue>;
+        /**
+         * Removes liquidity from a pool.
+         *
+         * @example
+         * ```ts
+         * import { createClient, http } from 'viem'
+         * import { privateKeyToAccount } from 'viem/accounts'
+         * import { tempo } from 'tempo.ts/chains'
+         * import { tempoActions } from 'tempo.ts/viem'
+         *
+         * const client = createClient({
+         *   account: privateKeyToAccount('0x...'),
+         *   chain: tempo({ feeToken: '0x20c0000000000000000000000000000000000001' })
+         *   transport: http(),
+         * }).extend(tempoActions())
+         *
+         * const hash = await client.amm.burn({
+         *   userToken: '0x...',
+         *   validatorToken: '0x...',
+         *   liquidity: 50n,
+         *   to: '0x...',
+         * })
+         * ```
+         *
+         * @param parameters - Parameters.
+         * @returns The transaction hash.
+         */
+        burn: (parameters: ammActions.burn.Parameters<chain, account>) => Promise<ammActions.burn.ReturnValue>;
+        /**
+         * Removes liquidity from a pool and waits for confirmation.
+         *
+         * @example
+         * ```ts
+         * import { createClient, http } from 'viem'
+         * import { privateKeyToAccount } from 'viem/accounts'
+         * import { tempo } from 'tempo.ts/chains'
+         * import { tempoActions } from 'tempo.ts/viem'
+         *
+         * const client = createClient({
+         *   account: privateKeyToAccount('0x...'),
+         *   chain: tempo({ feeToken: '0x20c0000000000000000000000000000000000001' })
+         *   transport: http(),
+         * }).extend(tempoActions())
+         *
+         * const { receipt, ...result } = await client.amm.burnSync({
+         *   userToken: '0x...',
+         *   validatorToken: '0x...',
+         *   liquidity: 50n,
+         *   to: '0x...',
+         * })
+         * ```
+         *
+         * @param parameters - Parameters.
+         * @returns The transaction receipt and event data.
+         */
+        burnSync: (parameters: ammActions.burnSync.Parameters<chain, account>) => Promise<ammActions.burnSync.ReturnValue>;
+        /**
+         * Adds liquidity to a pool.
+         *
+         * @example
+         * ```ts
+         * import { createClient, http } from 'viem'
+         * import { privateKeyToAccount } from 'viem/accounts'
+         * import { tempo } from 'tempo.ts/chains'
+         * import { tempoActions } from 'tempo.ts/viem'
+         *
+         * const client = createClient({
+         *   account: privateKeyToAccount('0x...'),
+         *   chain: tempo({ feeToken: '0x20c0000000000000000000000000000000000001' })
+         *   transport: http(),
+         * }).extend(tempoActions())
+         *
+         * const hash = await client.amm.mint({
+         *   userTokenAddress: '0x...',
+         *   validatorTokenAddress: '0x...',
+         *   validatorTokenAmount: 100n,
+         *   to: '0x...',
+         * })
+         * ```
+         *
+         * @param parameters - Parameters.
+         * @returns The transaction hash.
+         */
+        mint: (parameters: ammActions.mint.Parameters<chain, account>) => Promise<ammActions.mint.ReturnValue>;
+        /**
+         * Adds liquidity to a pool.
+         *
+         * @example
+         * ```ts
+         * import { createClient, http } from 'viem'
+         * import { privateKeyToAccount } from 'viem/accounts'
+         * import { tempo } from 'tempo.ts/chains'
+         * import { tempoActions } from 'tempo.ts/viem'
+         *
+         * const client = createClient({
+         *   account: privateKeyToAccount('0x...'),
+         *   chain: tempo({ feeToken: '0x20c0000000000000000000000000000000000001' })
+         *   transport: http(),
+         * }).extend(tempoActions())
+         *
+         * const result = await client.amm.mintSync({
+         *   userTokenAddress: '0x...',
+         *   validatorTokenAddress: '0x...',
+         *   validatorTokenAmount: 100n,
+         *   to: '0x...',
+         * })
+         * ```
+         *
+         * @param parameters - Parameters.
+         * @returns The transaction receipt and event data.
+         */
+        mintSync: (parameters: ammActions.mintSync.Parameters<chain, account>) => Promise<ammActions.mintSync.ReturnValue>;
+        /**
+         * Swaps tokens during a rebalance operation.
+         *
+         * @example
+         * ```ts
+         * import { createClient, http } from 'viem'
+         * import { privateKeyToAccount } from 'viem/accounts'
+         * import { tempo } from 'tempo.ts/chains'
+         * import { tempoActions } from 'tempo.ts/viem'
+         *
+         * const client = createClient({
+         *   account: privateKeyToAccount('0x...'),
+         *   chain: tempo({ feeToken: '0x20c0000000000000000000000000000000000001' })
+         *   transport: http(),
+         * }).extend(tempoActions())
+         *
+         * const hash = await client.amm.rebalanceSwap({
+         *   userToken: '0x...',
+         *   validatorToken: '0x...',
+         *   amountOut: 100n,
+         *   to: '0x...',
+         * })
+         * ```
+         *
+         * @param parameters - Parameters.
+         * @returns The transaction hash.
+         */
+        rebalanceSwap: (parameters: ammActions.rebalanceSwap.Parameters<chain, account>) => Promise<ammActions.rebalanceSwap.ReturnValue>;
+        /**
+         * Swaps tokens during a rebalance operation and waits for confirmation.
+         *
+         * @example
+         * ```ts
+         * import { createClient, http } from 'viem'
+         * import { privateKeyToAccount } from 'viem/accounts'
+         * import { tempo } from 'tempo.ts/chains'
+         * import { tempoActions } from 'tempo.ts/viem'
+         *
+         * const client = createClient({
+         *   account: privateKeyToAccount('0x...'),
+         *   chain: tempo({ feeToken: '0x20c0000000000000000000000000000000000001' })
+         *   transport: http(),
+         * }).extend(tempoActions())
+         *
+         * const { receipt, ...result } = await client.amm.rebalanceSwapSync({
+         *   userToken: '0x...',
+         *   validatorToken: '0x...',
+         *   amountOut: 100n,
+         *   to: '0x...',
+         * })
+         * ```
+         *
+         * @param parameters - Parameters.
+         * @returns The transaction receipt and event data.
+         */
+        rebalanceSwapSync: (parameters: ammActions.rebalanceSwapSync.Parameters<chain, account>) => Promise<ammActions.rebalanceSwapSync.ReturnValue>;
+        /**
+         * Watches for burn (liquidity removal) events.
+         *
+         * @example
+         * ```ts
+         * import { createClient, http } from 'viem'
+         * import { tempo } from 'tempo.ts/chains'
+         * import { tempoActions } from 'tempo.ts/viem'
+         *
+         * const client = createClient({
+         *   chain: tempo({ feeToken: '0x20c0000000000000000000000000000000000001' })
+         *   transport: http(),
+         * }).extend(tempoActions())
+         *
+         * const unwatch = client.amm.watchBurn({
+         *   onBurn: (args, log) => {
+         *     console.log('Liquidity removed:', args)
+         *   },
+         * })
+         * ```
+         *
+         * @param parameters - Parameters.
+         * @returns A function to unsubscribe from the event.
+         */
+        watchBurn: (parameters: ammActions.watchBurn.Parameters) => () => void;
+        /**
+         * Watches for fee swap events.
+         *
+         * @example
+         * ```ts
+         * import { createClient, http } from 'viem'
+         * import { tempo } from 'tempo.ts/chains'
+         * import { tempoActions } from 'tempo.ts/viem'
+         *
+         * const client = createClient({
+         *   chain: tempo({ feeToken: '0x20c0000000000000000000000000000000000001' })
+         *   transport: http(),
+         * }).extend(tempoActions())
+         *
+         * const unwatch = client.amm.watchFeeSwap({
+         *   onFeeSwap: (args, log) => {
+         *     console.log('Fee swap:', args)
+         *   },
+         * })
+         * ```
+         *
+         * @param parameters - Parameters.
+         * @returns A function to unsubscribe from the event.
+         */
+        watchFeeSwap: (parameters: ammActions.watchFeeSwap.Parameters) => () => void;
+        /**
+         * Watches for liquidity mint events.
+         *
+         * @example
+         * ```ts
+         * import { createClient, http } from 'viem'
+         * import { tempo } from 'tempo.ts/chains'
+         * import { tempoActions } from 'tempo.ts/viem'
+         *
+         * const client = createClient({
+         *   chain: tempo({ feeToken: '0x20c0000000000000000000000000000000000001' })
+         *   transport: http(),
+         * }).extend(tempoActions())
+         *
+         * const unwatch = client.amm.watchMint({
+         *   onMint: (args, log) => {
+         *     console.log('Liquidity added:', args)
+         *   },
+         * })
+         * ```
+         *
+         * @param parameters - Parameters.
+         * @returns A function to unsubscribe from the event.
+         */
+        watchMint: (parameters: ammActions.watchMint.Parameters) => () => void;
+        /**
+         * Watches for rebalance swap events.
+         *
+         * @example
+         * ```ts
+         * import { createClient, http } from 'viem'
+         * import { tempo } from 'tempo.ts/chains'
+         * import { tempoActions } from 'tempo.ts/viem'
+         *
+         * const client = createClient({
+         *   chain: tempo({ feeToken: '0x20c0000000000000000000000000000000000001' })
+         *   transport: http(),
+         * }).extend(tempoActions())
+         *
+         * const unwatch = client.amm.watchRebalanceSwap({
+         *   onRebalanceSwap: (args, log) => {
+         *     console.log('Rebalance swap:', args)
+         *   },
+         * })
+         * ```
+         *
+         * @param parameters - Parameters.
+         * @returns A function to unsubscribe from the event.
+         */
+        watchRebalanceSwap: (parameters: ammActions.watchRebalanceSwap.Parameters) => () => void;
+    };
+    dex: {
+        /**
+         * Buys a specific amount of tokens.
+         *
+         * @example
+         * ```ts
+         * import { createClient, http } from 'viem'
+         * import { privateKeyToAccount } from 'viem/accounts'
+         * import { tempo } from 'tempo.ts/chains'
+         * import { tempoActions } from 'tempo.ts/viem'
+         *
+         * const client = createClient({
+         *   account: privateKeyToAccount('0x...'),
+         *   chain: tempo({ feeToken: '0x20c0000000000000000000000000000000000001' })
+         *   transport: http(),
+         * }).extend(tempoActions())
+         *
+         * const hash = await client.dex.buy({
+         *   tokenIn: '0x20c...11',
+         *   tokenOut: '0x20c...20',
+         *   amountOut: 100n,
+         *   maxAmountIn: 105n,
+         * })
+         * ```
+         *
+         * @param parameters - Parameters.
+         * @returns The transaction hash.
+         */
+        buy: (parameters: dexActions.buy.Parameters<chain, account>) => Promise<dexActions.buy.ReturnValue>;
+        /**
+         * Buys a specific amount of tokens.
+         *
+         * @example
+         * ```ts
+         * import { createClient, http } from 'viem'
+         * import { privateKeyToAccount } from 'viem/accounts'
+         * import { tempo } from 'tempo.ts/chains'
+         * import { tempoActions } from 'tempo.ts/viem'
+         *
+         * const client = createClient({
+         *   account: privateKeyToAccount('0x...'),
+         *   chain: tempo({ feeToken: '0x20c0000000000000000000000000000000000001' })
+         *   transport: http(),
+         * }).extend(tempoActions())
+         *
+         * const result = await client.dex.buySync({
+         *   tokenIn: '0x20c...11',
+         *   tokenOut: '0x20c...20',
+         *   amountOut: 100n,
+         *   maxAmountIn: 105n,
+         * })
+         * ```
+         *
+         * @param parameters - Parameters.
+         * @returns The transaction receipt.
+         */
+        buySync: (parameters: dexActions.buySync.Parameters<chain, account>) => Promise<dexActions.buySync.ReturnValue>;
+        /**
+         * Cancels an order from the orderbook.
+         *
+         * @example
+         * ```ts
+         * import { createClient, http } from 'viem'
+         * import { privateKeyToAccount } from 'viem/accounts'
+         * import { tempo } from 'tempo.ts/chains'
+         * import { tempoActions } from 'tempo.ts/viem'
+         *
+         * const client = createClient({
+         *   account: privateKeyToAccount('0x...'),
+         *   chain: tempo({ feeToken: '0x20c0000000000000000000000000000000000001' })
+         *   transport: http(),
+         * }).extend(tempoActions())
+         *
+         * const hash = await client.dex.cancel({
+         *   orderId: 123n,
+         * })
+         * ```
+         *
+         * @param parameters - Parameters.
+         * @returns The transaction hash.
+         */
+        cancel: (parameters: dexActions.cancel.Parameters<chain, account>) => Promise<dexActions.cancel.ReturnValue>;
+        /**
+         * Cancels an order from the orderbook.
+         *
+         * @example
+         * ```ts
+         * import { createClient, http } from 'viem'
+         * import { privateKeyToAccount } from 'viem/accounts'
+         * import { tempo } from 'tempo.ts/chains'
+         * import { tempoActions } from 'tempo.ts/viem'
+         *
+         * const client = createClient({
+         *   account: privateKeyToAccount('0x...'),
+         *   chain: tempo({ feeToken: '0x20c0000000000000000000000000000000000001' })
+         *   transport: http(),
+         * }).extend(tempoActions())
+         *
+         * const result = await client.dex.cancelSync({
+         *   orderId: 123n,
+         * })
+         * ```
+         *
+         * @param parameters - Parameters.
+         * @returns The transaction receipt and event data.
+         */
+        cancelSync: (parameters: dexActions.cancelSync.Parameters<chain, account>) => Promise<dexActions.cancelSync.ReturnValue>;
+        /**
+         * Creates a new trading pair on the DEX.
+         *
+         * @example
+         * ```ts
+         * import { createClient, http } from 'viem'
+         * import { privateKeyToAccount } from 'viem/accounts'
+         * import { tempo } from 'tempo.ts/chains'
+         * import { tempoActions } from 'tempo.ts/viem'
+         *
+         * const client = createClient({
+         *   account: privateKeyToAccount('0x...'),
+         *   chain: tempo({ feeToken: '0x20c0000000000000000000000000000000000001' })
+         *   transport: http(),
+         * }).extend(tempoActions())
+         *
+         * const hash = await client.dex.createPair({
+         *   base: '0x20c...11',
+         * })
+         * ```
+         *
+         * @param parameters - Parameters.
+         * @returns The transaction hash.
+         */
+        createPair: (parameters: dexActions.createPair.Parameters<chain, account>) => Promise<dexActions.createPair.ReturnValue>;
+        /**
+         * Creates a new trading pair on the DEX.
+         *
+         * @example
+         * ```ts
+         * import { createClient, http } from 'viem'
+         * import { privateKeyToAccount } from 'viem/accounts'
+         * import { tempo } from 'tempo.ts/chains'
+         * import { tempoActions } from 'tempo.ts/viem'
+         *
+         * const client = createClient({
+         *   account: privateKeyToAccount('0x...'),
+         *   chain: tempo({ feeToken: '0x20c0000000000000000000000000000000000001' })
+         *   transport: http(),
+         * }).extend(tempoActions())
+         *
+         * const result = await client.dex.createPairSync({
+         *   base: '0x20c...11',
+         * })
+         * ```
+         *
+         * @param parameters - Parameters.
+         * @returns The transaction receipt and event data.
+         */
+        createPairSync: (parameters: dexActions.createPairSync.Parameters<chain, account>) => Promise<dexActions.createPairSync.ReturnValue>;
+        /**
+         * Gets a user's token balance on the DEX.
+         *
+         * @example
+         * ```ts
+         * import { createClient, http } from 'viem'
+         * import { tempo } from 'tempo.ts/chains'
+         * import { tempoActions } from 'tempo.ts/viem'
+         *
+         * const client = createClient({
+         *   chain: tempo({ feeToken: '0x20c0000000000000000000000000000000000001' })
+         *   transport: http(),
+         * }).extend(tempoActions())
+         *
+         * const balance = await client.dex.getBalance({
+         *   account: '0x...',
+         *   token: '0x20c...11',
+         * })
+         * ```
+         *
+         * @param parameters - Parameters.
+         * @returns The user's token balance on the DEX.
+         */
+        getBalance: (parameters: dexActions.getBalance.Parameters<account>) => Promise<dexActions.getBalance.ReturnValue>;
+        /**
+         * Gets the quote for buying a specific amount of tokens.
+         *
+         * @example
+         * ```ts
+         * import { createClient, http } from 'viem'
+         * import { tempo } from 'tempo.ts/chains'
+         * import { tempoActions } from 'tempo.ts/viem'
+         *
+         * const client = createClient({
+         *   chain: tempo({ feeToken: '0x20c0000000000000000000000000000000000001' })
+         *   transport: http(),
+         * }).extend(tempoActions())
+         *
+         * const amountIn = await client.dex.getBuyQuote({
+         *   tokenIn: '0x20c...11',
+         *   tokenOut: '0x20c...20',
+         *   amountOut: 100n,
+         * })
+         * ```
+         *
+         * @param parameters - Parameters.
+         * @returns The amount of tokenIn needed to buy the specified amountOut.
+         */
+        getBuyQuote: (parameters: dexActions.getBuyQuote.Parameters) => Promise<dexActions.getBuyQuote.ReturnValue>;
+        /**
+         * Gets an order's details from the orderbook.
+         *
+         * @example
+         * ```ts
+         * import { createClient, http } from 'viem'
+         * import { tempo } from 'tempo.ts/chains'
+         * import { tempoActions } from 'tempo.ts/viem'
+         *
+         * const client = createClient({
+         *   chain: tempo({ feeToken: '0x20c0000000000000000000000000000000000001' })
+         *   transport: http(),
+         * }).extend(tempoActions())
+         *
+         * const order = await client.dex.getOrder({
+         *   orderId: 123n,
+         * })
+         * ```
+         *
+         * @param parameters - Parameters.
+         * @returns The order details.
+         */
+        getOrder: (parameters: dexActions.getOrder.Parameters) => Promise<dexActions.getOrder.ReturnValue>;
+        /**
+         * Gets the price level information at a specific tick.
+         *
+         * @example
+         * ```ts
+         * import { createClient, http } from 'viem'
+         * import { tempo } from 'tempo.ts/chains'
+         * import { tempoActions, Tick } from 'tempo.ts/viem'
+         *
+         * const client = createClient({
+         *   chain: tempo({ feeToken: '0x20c0000000000000000000000000000000000001' })
+         *   transport: http(),
+         * }).extend(tempoActions())
+         *
+         * const level = await client.dex.getTickLevel({
+         *   base: '0x20c...11',
+         *   tick: Tick.fromPrice('1.001'),
+         *   isBid: true,
+         * })
+         * ```
+         *
+         * @param parameters - Parameters.
+         * @returns The price level information.
+         */
+        getTickLevel: (parameters: dexActions.getTickLevel.Parameters) => Promise<dexActions.getTickLevel.ReturnValue>;
+        /**
+         * Gets the quote for selling a specific amount of tokens.
+         *
+         * @example
+         * ```ts
+         * import { createClient, http } from 'viem'
+         * import { tempo } from 'tempo.ts/chains'
+         * import { tempoActions } from 'tempo.ts/viem'
+         *
+         * const client = createClient({
+         *   chain: tempo({ feeToken: '0x20c0000000000000000000000000000000000001' })
+         *   transport: http(),
+         * }).extend(tempoActions())
+         *
+         * const amountOut = await client.dex.getSellQuote({
+         *   tokenIn: '0x20c...11',
+         *   tokenOut: '0x20c...20',
+         *   amountIn: 100n,
+         * })
+         * ```
+         *
+         * @param parameters - Parameters.
+         * @returns The amount of tokenOut received for selling the specified amountIn.
+         */
+        getSellQuote: (parameters: dexActions.getSellQuote.Parameters) => Promise<dexActions.getSellQuote.ReturnValue>;
+        /**
+         * Places a limit order on the orderbook.
+         *
+         * @example
+         * ```ts
+         * import { createClient, http } from 'viem'
+         * import { privateKeyToAccount } from 'viem/accounts'
+         * import { tempo } from 'tempo.ts/chains'
+         * import { tempoActions, Tick } from 'tempo.ts/viem'
+         *
+         * const client = createClient({
+         *   account: privateKeyToAccount('0x...'),
+         *   chain: tempo({ feeToken: '0x20c0000000000000000000000000000000000001' })
+         *   transport: http(),
+         * }).extend(tempoActions())
+         *
+         * const hash = await client.dex.place({
+         *   token: '0x20c...11',
+         *   amount: 100n,
+         *   type: 'buy',
+         *   tick: Tick.fromPrice('0.99'),
+         * })
+         * ```
+         *
+         * @param parameters - Parameters.
+         * @returns The transaction hash.
+         */
+        place: (parameters: dexActions.place.Parameters<chain, account>) => Promise<dexActions.place.ReturnValue>;
+        /**
+         * Places a limit order on the orderbook.
+         *
+         * @example
+         * ```ts
+         * import { createClient, http } from 'viem'
+         * import { privateKeyToAccount } from 'viem/accounts'
+         * import { tempo } from 'tempo.ts/chains'
+         * import { tempoActions, Tick } from 'tempo.ts/viem'
+         *
+         * const client = createClient({
+         *   account: privateKeyToAccount('0x...'),
+         *   chain: tempo({ feeToken: '0x20c0000000000000000000000000000000000001' })
+         *   transport: http(),
+         * }).extend(tempoActions())
+         *
+         * const result = await client.dex.placeSync({
+         *   token: '0x20c...11',
+         *   amount: 100n,
+         *   type: 'buy',
+         *   tick: Tick.fromPrice('0.99'),
+         * })
+         * ```
+         *
+         * @param parameters - Parameters.
+         * @returns The transaction receipt and event data.
+         */
+        placeSync: (parameters: dexActions.placeSync.Parameters<chain, account>) => Promise<dexActions.placeSync.ReturnValue>;
+        /**
+         * Places a flip order that automatically flips when filled.
+         *
+         * @example
+         * ```ts
+         * import { createClient, http } from 'viem'
+         * import { privateKeyToAccount } from 'viem/accounts'
+         * import { tempo } from 'tempo.ts/chains'
+         * import { tempoActions, Tick } from 'tempo.ts/viem'
+         *
+         * const client = createClient({
+         *   account: privateKeyToAccount('0x...'),
+         *   chain: tempo({ feeToken: '0x20c0000000000000000000000000000000000001' })
+         *   transport: http(),
+         * }).extend(tempoActions())
+         *
+         * const hash = await client.dex.placeFlip({
+         *   token: '0x20c...11',
+         *   amount: 100n,
+         *   type: 'buy',
+         *   tick: Tick.fromPrice('0.99'),
+         *   flipTick: Tick.fromPrice('1.01'),
+         * })
+         * ```
+         *
+         * @param parameters - Parameters.
+         * @returns The transaction hash.
+         */
+        placeFlip: (parameters: dexActions.placeFlip.Parameters<chain, account>) => Promise<dexActions.placeFlip.ReturnValue>;
+        /**
+         * Places a flip order that automatically flips when filled.
+         *
+         * @example
+         * ```ts
+         * import { createClient, http } from 'viem'
+         * import { privateKeyToAccount } from 'viem/accounts'
+         * import { tempo } from 'tempo.ts/chains'
+         * import { tempoActions, Tick } from 'tempo.ts/viem'
+         *
+         * const client = createClient({
+         *   account: privateKeyToAccount('0x...'),
+         *   chain: tempo({ feeToken: '0x20c0000000000000000000000000000000000001' })
+         *   transport: http(),
+         * }).extend(tempoActions())
+         *
+         * const result = await client.dex.placeFlipSync({
+         *   token: '0x20c...11',
+         *   amount: 100n,
+         *   type: 'buy',
+         *   tick: Tick.fromPrice('0.99'),
+         *   flipTick: Tick.fromPrice('1.01'),
+         * })
+         * ```
+         *
+         * @param parameters - Parameters.
+         * @returns The transaction receipt and event data.
+         */
+        placeFlipSync: (parameters: dexActions.placeFlipSync.Parameters<chain, account>) => Promise<dexActions.placeFlipSync.ReturnValue>;
+        /**
+         * Sells a specific amount of tokens.
+         *
+         * @example
+         * ```ts
+         * import { createClient, http } from 'viem'
+         * import { privateKeyToAccount } from 'viem/accounts'
+         * import { tempo } from 'tempo.ts/chains'
+         * import { tempoActions } from 'tempo.ts/viem'
+         *
+         * const client = createClient({
+         *   account: privateKeyToAccount('0x...'),
+         *   chain: tempo({ feeToken: '0x20c0000000000000000000000000000000000001' })
+         *   transport: http(),
+         * }).extend(tempoActions())
+         *
+         * const hash = await client.dex.sell({
+         *   tokenIn: '0x20c...11',
+         *   tokenOut: '0x20c...20',
+         *   amountIn: 100n,
+         *   minAmountOut: 95n,
+         * })
+         * ```
+         *
+         * @param parameters - Parameters.
+         * @returns The transaction hash.
+         */
+        sell: (parameters: dexActions.sell.Parameters<chain, account>) => Promise<dexActions.sell.ReturnValue>;
+        /**
+         * Sells a specific amount of tokens.
+         *
+         * @example
+         * ```ts
+         * import { createClient, http } from 'viem'
+         * import { privateKeyToAccount } from 'viem/accounts'
+         * import { tempo } from 'tempo.ts/chains'
+         * import { tempoActions } from 'tempo.ts/viem'
+         *
+         * const client = createClient({
+         *   account: privateKeyToAccount('0x...'),
+         *   chain: tempo({ feeToken: '0x20c0000000000000000000000000000000000001' })
+         *   transport: http(),
+         * }).extend(tempoActions())
+         *
+         * const result = await client.dex.sellSync({
+         *   tokenIn: '0x20c...11',
+         *   tokenOut: '0x20c...20',
+         *   amountIn: 100n,
+         *   minAmountOut: 95n,
+         * })
+         * ```
+         *
+         * @param parameters - Parameters.
+         * @returns The transaction receipt.
+         */
+        sellSync: (parameters: dexActions.sellSync.Parameters<chain, account>) => Promise<dexActions.sellSync.ReturnValue>;
+        /**
+         * Withdraws tokens from the DEX to the caller's wallet.
+         *
+         * @example
+         * ```ts
+         * import { createClient, http } from 'viem'
+         * import { privateKeyToAccount } from 'viem/accounts'
+         * import { tempo } from 'tempo.ts/chains'
+         * import { tempoActions } from 'tempo.ts/viem'
+         *
+         * const client = createClient({
+         *   account: privateKeyToAccount('0x...'),
+         *   chain: tempo({ feeToken: '0x20c0000000000000000000000000000000000001' })
+         *   transport: http(),
+         * }).extend(tempoActions())
+         *
+         * const hash = await client.dex.withdraw({
+         *   token: '0x20c...11',
+         *   amount: 100n,
+         * })
+         * ```
+         *
+         * @param parameters - Parameters.
+         * @returns The transaction hash.
+         */
+        withdraw: (parameters: dexActions.withdraw.Parameters<chain, account>) => Promise<dexActions.withdraw.ReturnValue>;
+        /**
+         * Withdraws tokens from the DEX to the caller's wallet.
+         *
+         * @example
+         * ```ts
+         * import { createClient, http } from 'viem'
+         * import { privateKeyToAccount } from 'viem/accounts'
+         * import { tempo } from 'tempo.ts/chains'
+         * import { tempoActions } from 'tempo.ts/viem'
+         *
+         * const client = createClient({
+         *   account: privateKeyToAccount('0x...'),
+         *   chain: tempo({ feeToken: '0x20c0000000000000000000000000000000000001' })
+         *   transport: http(),
+         * }).extend(tempoActions())
+         *
+         * const result = await client.dex.withdrawSync({
+         *   token: '0x20c...11',
+         *   amount: 100n,
+         * })
+         * ```
+         *
+         * @param parameters - Parameters.
+         * @returns The transaction receipt.
+         */
+        withdrawSync: (parameters: dexActions.withdrawSync.Parameters<chain, account>) => Promise<dexActions.withdrawSync.ReturnValue>;
+        /**
+         * Watches for flip order placed events.
+         *
+         * @example
+         * ```ts
+         * import { createClient, http } from 'viem'
+         * import { tempo } from 'tempo.ts/chains'
+         * import { tempoActions } from 'tempo.ts/viem'
+         *
+         * const client = createClient({
+         *   chain: tempo({ feeToken: '0x20c0000000000000000000000000000000000001' })
+         *   transport: http(),
+         * }).extend(tempoActions())
+         *
+         * const unwatch = client.dex.watchFlipOrderPlaced({
+         *   onFlipOrderPlaced: (args, log) => {
+         *     console.log('Flip order placed:', args)
+         *   },
+         * })
+         * ```
+         *
+         * @param parameters - Parameters.
+         * @returns A function to unsubscribe from the event.
+         */
+        watchFlipOrderPlaced: (parameters: dexActions.watchFlipOrderPlaced.Parameters) => () => void;
+        /**
+         * Watches for order cancelled events.
+         *
+         * @example
+         * ```ts
+         * import { createClient, http } from 'viem'
+         * import { tempo } from 'tempo.ts/chains'
+         * import { tempoActions } from 'tempo.ts/viem'
+         *
+         * const client = createClient({
+         *   chain: tempo({ feeToken: '0x20c0000000000000000000000000000000000001' })
+         *   transport: http(),
+         * }).extend(tempoActions())
+         *
+         * const unwatch = client.dex.watchOrderCancelled({
+         *   onOrderCancelled: (args, log) => {
+         *     console.log('Order cancelled:', args)
+         *   },
+         * })
+         * ```
+         *
+         * @param parameters - Parameters.
+         * @returns A function to unsubscribe from the event.
+         */
+        watchOrderCancelled: (parameters: dexActions.watchOrderCancelled.Parameters) => () => void;
+        /**
+         * Watches for order filled events.
+         *
+         * @example
+         * ```ts
+         * import { createClient, http } from 'viem'
+         * import { tempo } from 'tempo.ts/chains'
+         * import { tempoActions } from 'tempo.ts/viem'
+         *
+         * const client = createClient({
+         *   chain: tempo({ feeToken: '0x20c0000000000000000000000000000000000001' })
+         *   transport: http(),
+         * }).extend(tempoActions())
+         *
+         * const unwatch = client.dex.watchOrderFilled({
+         *   onOrderFilled: (args, log) => {
+         *     console.log('Order filled:', args)
+         *   },
+         * })
+         * ```
+         *
+         * @param parameters - Parameters.
+         * @returns A function to unsubscribe from the event.
+         */
+        watchOrderFilled: (parameters: dexActions.watchOrderFilled.Parameters) => () => void;
+        /**
+         * Watches for order placed events.
+         *
+         * @example
+         * ```ts
+         * import { createClient, http } from 'viem'
+         * import { tempo } from 'tempo.ts/chains'
+         * import { tempoActions } from 'tempo.ts/viem'
+         *
+         * const client = createClient({
+         *   chain: tempo({ feeToken: '0x20c0000000000000000000000000000000000001' })
+         *   transport: http(),
+         * }).extend(tempoActions())
+         *
+         * const unwatch = client.dex.watchOrderPlaced({
+         *   onOrderPlaced: (args, log) => {
+         *     console.log('Order placed:', args)
+         *   },
+         * })
+         * ```
+         *
+         * @param parameters - Parameters.
+         * @returns A function to unsubscribe from the event.
+         */
+        watchOrderPlaced: (parameters: dexActions.watchOrderPlaced.Parameters) => () => void;
+    };
+    faucet: {
+        /**
+         * Funds an account with an initial amount of set token(s)
+         * on Tempo's testnet.
+         *
+         * @example
+         * ```ts
+         * import { createClient, http } from 'viem'
+         * import { tempo } from 'tempo.ts/chains'
+         * import { tempoActions } from 'tempo.ts/viem'
+         *
+         * const client = createClient({
+         *   chain: tempo({ feeToken: '0x20c0000000000000000000000000000000000001' })
+         *   transport: http(),
+         * }).extend(tempoActions())
+         *
+         * const hashes = await client.faucet.fund({
+         *   account: '0xdeadbeefdeadbeefdeadbeefdeadbeefdeadbeef',
+         * })
+         * ```
+         *
+         * @param parameters - Parameters.
+         * @returns The transaction hashes.
+         */
+        fund: (parameters: faucetActions.fund.Parameters) => Promise<faucetActions.fund.ReturnValue>;
+    };
+    fee: {
+        /**
+         * Gets the user's default fee token.
+         *
+         * @example
+         * ```ts
+         * import { createClient, http } from 'viem'
+         * import { privateKeyToAccount } from 'viem/accounts'
+         * import { tempo } from 'tempo.ts/chains'
+         * import { tempoActions } from 'tempo.ts/viem'
+         *
+         * const client = createClient({
+         *   account: privateKeyToAccount('0x...'),
+         *   chain: tempo({ feeToken: '0x20c0000000000000000000000000000000000001' })
+         *   transport: http(),
+         * }).extend(tempoActions())
+         *
+         * const { address, id } = await client.token.getUserToken()
+         * ```
+         *
+         * @param client - Client.
+         * @param parameters - Parameters.
+         * @returns The transaction hash.
+         */
+        getUserToken: (...parameters: account extends Account ? [feeActions.getUserToken.Parameters<account>] | [] : [feeActions.getUserToken.Parameters<account>]) => Promise<feeActions.getUserToken.ReturnValue>;
+        /**
+         * Sets the user's default fee token.
+         *
+         * @example
+         * ```ts
+         * import { createClient, http } from 'viem'
+         * import { privateKeyToAccount } from 'viem/accounts'
+         * import { tempo } from 'tempo.ts/chains'
+         * import { tempoActions } from 'tempo.ts/viem'
+         *
+         * const client = createClient({
+         *   account: privateKeyToAccount('0x...'),
+         *   chain: tempo({ feeToken: '0x20c0000000000000000000000000000000000001' })
+         *   transport: http(),
+         * }).extend(tempoActions())
+         *
+         * const hash = await client.token.setUserToken({
+         *   token: '0x...',
+         * })
+         * ```
+         *
+         * @param client - Client.
+         * @param parameters - Parameters.
+         * @returns The transaction hash.
+         */
+        setUserToken: (parameters: feeActions.setUserToken.Parameters<chain, account>) => Promise<feeActions.setUserToken.ReturnValue>;
+        /**
+         * Sets the user's default fee token.
+         *
+         * @example
+         * ```ts
+         * import { createClient, http } from 'viem'
+         * import { privateKeyToAccount } from 'viem/accounts'
+         * import { tempo } from 'tempo.ts/chains'
+         * import { tempoActions } from 'tempo.ts/viem'
+         *
+         * const client = createClient({
+         *   account: privateKeyToAccount('0x...'),
+         *   chain: tempo({ feeToken: '0x20c0000000000000000000000000000000000001' })
+         *   transport: http(),
+         * }).extend(tempoActions())
+         *
+         * const result = await client.fee.setUserTokenSync({
+         *   token: '0x...',
+         * })
+         * ```
+         *
+         * @param parameters - Parameters.
+         * @returns The transaction receipt and event data.
+         */
+        setUserTokenSync: (parameters: feeActions.setUserTokenSync.Parameters<chain, account>) => Promise<feeActions.setUserTokenSync.ReturnValue>;
+        /**
+         * Watches for user token set events.
+         *
+         * @example
+         * ```ts
+         * import { createClient, http } from 'viem'
+         * import { tempo } from 'tempo.ts/chains'
+         * import { tempoActions } from 'tempo.ts/viem'
+         *
+         * const client = createClient({
+         *   chain: tempo({ feeToken: '0x20c0000000000000000000000000000000000001' })
+         *   transport: http(),
+         * }).extend(tempoActions())
+         *
+         * const unwatch = client.token.watchSetUserToken({
+         *   onUserTokenSet: (args, log) => {
+         *     console.log('User token set:', args)
+         *   },
+         * })
+         * ```
+         *
+         * @param client - Client.
+         * @param parameters - Parameters.
+         * @returns A function to unsubscribe from the event.
+         */
+        watchSetUserToken: (parameters: feeActions.watchSetUserToken.Parameters) => () => void;
+    };
+    policy: {
+        /**
+         * Creates a new policy.
+         *
+         * @example
+         * ```ts
+         * import { createClient, http } from 'viem'
+         * import { privateKeyToAccount } from 'viem/accounts'
+         * import { tempo } from 'tempo.ts/chains'
+         * import { tempoActions } from 'tempo.ts/viem'
+         *
+         * const client = createClient({
+         *   account: privateKeyToAccount('0x...'),
+         *   chain: tempo({ feeToken: '0x20c0000000000000000000000000000000000001' })
+         *   transport: http(),
+         * }).extend(tempoActions())
+         *
+         * const hash = await client.policy.create({
+         *   admin: '0x...',
+         *   type: 'whitelist',
+         * })
+         * ```
+         *
+         * @param parameters - Parameters.
+         * @returns The transaction hash.
+         */
+        create: (parameters: policyActions.create.Parameters<chain, account>) => Promise<policyActions.create.ReturnValue>;
+        /**
+         * Creates a new policy.
+         *
+         * @example
+         * ```ts
+         * import { createClient, http } from 'viem'
+         * import { privateKeyToAccount } from 'viem/accounts'
+         * import { tempo } from 'tempo.ts/chains'
+         * import { tempoActions } from 'tempo.ts/viem'
+         *
+         * const client = createClient({
+         *   account: privateKeyToAccount('0x...'),
+         *   chain: tempo({ feeToken: '0x20c0000000000000000000000000000000000001' })
+         *   transport: http(),
+         * }).extend(tempoActions())
+         *
+         * const result = await client.policy.createSync({
+         *   admin: '0x...',
+         *   type: 'whitelist',
+         * })
+         * ```
+         *
+         * @param parameters - Parameters.
+         * @returns The transaction receipt and event data.
+         */
+        createSync: (parameters: policyActions.createSync.Parameters<chain, account>) => Promise<policyActions.createSync.ReturnValue>;
+        /**
+         * Sets the admin for a policy.
+         *
+         * @example
+         * ```ts
+         * import { createClient, http } from 'viem'
+         * import { privateKeyToAccount } from 'viem/accounts'
+         * import { tempo } from 'tempo.ts/chains'
+         * import { tempoActions } from 'tempo.ts/viem'
+         *
+         * const client = createClient({
+         *   account: privateKeyToAccount('0x...'),
+         *   chain: tempo({ feeToken: '0x20c0000000000000000000000000000000000001' })
+         *   transport: http(),
+         * }).extend(tempoActions())
+         *
+         * const hash = await client.policy.setAdmin({
+         *   policyId: 2n,
+         *   admin: '0x...',
+         * })
+         * ```
+         *
+         * @param parameters - Parameters.
+         * @returns The transaction hash.
+         */
+        setAdmin: (parameters: policyActions.setAdmin.Parameters<chain, account>) => Promise<policyActions.setAdmin.ReturnValue>;
+        /**
+         * Sets the admin for a policy.
+         *
+         * @example
+         * ```ts
+         * import { createClient, http } from 'viem'
+         * import { privateKeyToAccount } from 'viem/accounts'
+         * import { tempo } from 'tempo.ts/chains'
+         * import { tempoActions } from 'tempo.ts/viem'
+         *
+         * const client = createClient({
+         *   account: privateKeyToAccount('0x...'),
+         *   chain: tempo({ feeToken: '0x20c0000000000000000000000000000000000001' })
+         *   transport: http(),
+         * }).extend(tempoActions())
+         *
+         * const result = await client.policy.setAdminSync({
+         *   policyId: 2n,
+         *   admin: '0x...',
+         * })
+         * ```
+         *
+         * @param parameters - Parameters.
+         * @returns The transaction receipt and event data.
+         */
+        setAdminSync: (parameters: policyActions.setAdminSync.Parameters<chain, account>) => Promise<policyActions.setAdminSync.ReturnValue>;
+        /**
+         * Modifies a policy whitelist.
+         *
+         * @example
+         * ```ts
+         * import { createClient, http } from 'viem'
+         * import { privateKeyToAccount } from 'viem/accounts'
+         * import { tempo } from 'tempo.ts/chains'
+         * import { tempoActions } from 'tempo.ts/viem'
+         *
+         * const client = createClient({
+         *   account: privateKeyToAccount('0x...'),
+         *   chain: tempo({ feeToken: '0x20c0000000000000000000000000000000000001' })
+         *   transport: http(),
+         * }).extend(tempoActions())
+         *
+         * const hash = await client.policy.modifyWhitelist({
+         *   policyId: 2n,
+         *   address: '0x...',
+         *   allowed: true,
+         * })
+         * ```
+         *
+         * @param parameters - Parameters.
+         * @returns The transaction hash.
+         */
+        modifyWhitelist: (parameters: policyActions.modifyWhitelist.Parameters<chain, account>) => Promise<policyActions.modifyWhitelist.ReturnValue>;
+        /**
+         * Modifies a policy whitelist.
+         *
+         * @example
+         * ```ts
+         * import { createClient, http } from 'viem'
+         * import { privateKeyToAccount } from 'viem/accounts'
+         * import { tempo } from 'tempo.ts/chains'
+         * import { tempoActions } from 'tempo.ts/viem'
+         *
+         * const client = createClient({
+         *   account: privateKeyToAccount('0x...'),
+         *   chain: tempo({ feeToken: '0x20c0000000000000000000000000000000000001' })
+         *   transport: http(),
+         * }).extend(tempoActions())
+         *
+         * const result = await client.policy.modifyWhitelistSync({
+         *   policyId: 2n,
+         *   address: '0x...',
+         *   allowed: true,
+         * })
+         * ```
+         *
+         * @param parameters - Parameters.
+         * @returns The transaction receipt and event data.
+         */
+        modifyWhitelistSync: (parameters: policyActions.modifyWhitelistSync.Parameters<chain, account>) => Promise<policyActions.modifyWhitelistSync.ReturnValue>;
+        /**
+         * Modifies a policy blacklist.
+         *
+         * @example
+         * ```ts
+         * import { createClient, http } from 'viem'
+         * import { privateKeyToAccount } from 'viem/accounts'
+         * import { tempo } from 'tempo.ts/chains'
+         * import { tempoActions } from 'tempo.ts/viem'
+         *
+         * const client = createClient({
+         *   account: privateKeyToAccount('0x...'),
+         *   chain: tempo({ feeToken: '0x20c0000000000000000000000000000000000001' })
+         *   transport: http(),
+         * }).extend(tempoActions())
+         *
+         * const hash = await client.policy.modifyBlacklist({
+         *   policyId: 2n,
+         *   address: '0x...',
+         *   restricted: true,
+         * })
+         * ```
+         *
+         * @param parameters - Parameters.
+         * @returns The transaction hash.
+         */
+        modifyBlacklist: (parameters: policyActions.modifyBlacklist.Parameters<chain, account>) => Promise<policyActions.modifyBlacklist.ReturnValue>;
+        /**
+         * Modifies a policy blacklist.
+         *
+         * @example
+         * ```ts
+         * import { createClient, http } from 'viem'
+         * import { privateKeyToAccount } from 'viem/accounts'
+         * import { tempo } from 'tempo.ts/chains'
+         * import { tempoActions } from 'tempo.ts/viem'
+         *
+         * const client = createClient({
+         *   account: privateKeyToAccount('0x...'),
+         *   chain: tempo({ feeToken: '0x20c0000000000000000000000000000000000001' })
+         *   transport: http(),
+         * }).extend(tempoActions())
+         *
+         * const result = await client.policy.modifyBlacklistSync({
+         *   policyId: 2n,
+         *   address: '0x...',
+         *   restricted: true,
+         * })
+         * ```
+         *
+         * @param parameters - Parameters.
+         * @returns The transaction receipt and event data.
+         */
+        modifyBlacklistSync: (parameters: policyActions.modifyBlacklistSync.Parameters<chain, account>) => Promise<policyActions.modifyBlacklistSync.ReturnValue>;
+        /**
+         * Gets policy data.
+         *
+         * @example
+         * ```ts
+         * import { createClient, http } from 'viem'
+         * import { tempo } from 'tempo.ts/chains'
+         * import { tempoActions } from 'tempo.ts/viem'
+         *
+         * const client = createClient({
+         *   chain: tempo({ feeToken: '0x20c0000000000000000000000000000000000001' })
+         *   transport: http(),
+         * }).extend(tempoActions())
+         *
+         * const data = await client.policy.getData({
+         *   policyId: 2n,
+         * })
+         * ```
+         *
+         * @param parameters - Parameters.
+         * @returns The policy data.
+         */
+        getData: (parameters: policyActions.getData.Parameters) => Promise<policyActions.getData.ReturnValue>;
+        /**
+         * Checks if a user is authorized by a policy.
+         *
+         * @example
+         * ```ts
+         * import { createClient, http } from 'viem'
+         * import { tempo } from 'tempo.ts/chains'
+         * import { tempoActions } from 'tempo.ts/viem'
+         *
+         * const client = createClient({
+         *   chain: tempo({ feeToken: '0x20c0000000000000000000000000000000000001' })
+         *   transport: http(),
+         * }).extend(tempoActions())
+         *
+         * const authorized = await client.policy.isAuthorized({
+         *   policyId: 2n,
+         *   user: '0x...',
+         * })
+         * ```
+         *
+         * @param parameters - Parameters.
+         * @returns Whether the user is authorized.
+         */
+        isAuthorized: (parameters: policyActions.isAuthorized.Parameters) => Promise<policyActions.isAuthorized.ReturnValue>;
+        /**
+         * Watches for policy creation events.
+         *
+         * @example
+         * ```ts
+         * import { createClient, http } from 'viem'
+         * import { tempo } from 'tempo.ts/chains'
+         * import { tempoActions } from 'tempo.ts/viem'
+         *
+         * const client = createClient({
+         *   chain: tempo({ feeToken: '0x20c0000000000000000000000000000000000001' })
+         *   transport: http(),
+         * }).extend(tempoActions())
+         *
+         * const unwatch = client.policy.watchCreate({
+         *   onPolicyCreated: (args, log) => {
+         *     console.log('Policy created:', args)
+         *   },
+         * })
+         * ```
+         *
+         * @param parameters - Parameters.
+         * @returns A function to unsubscribe from the event.
+         */
+        watchCreate: (parameters: policyActions.watchCreate.Parameters) => () => void;
+        /**
+         * Watches for policy admin update events.
+         *
+         * @example
+         * ```ts
+         * import { createClient, http } from 'viem'
+         * import { tempo } from 'tempo.ts/chains'
+         * import { tempoActions } from 'tempo.ts/viem'
+         *
+         * const client = createClient({
+         *   chain: tempo({ feeToken: '0x20c0000000000000000000000000000000000001' })
+         *   transport: http(),
+         * }).extend(tempoActions())
+         *
+         * const unwatch = client.policy.watchAdminUpdated({
+         *   onAdminUpdated: (args, log) => {
+         *     console.log('Policy admin updated:', args)
+         *   },
+         * })
+         * ```
+         *
+         * @param parameters - Parameters.
+         * @returns A function to unsubscribe from the event.
+         */
+        watchAdminUpdated: (parameters: policyActions.watchAdminUpdated.Parameters) => () => void;
+        /**
+         * Watches for whitelist update events.
+         *
+         * @example
+         * ```ts
+         * import { createClient, http } from 'viem'
+         * import { tempo } from 'tempo.ts/chains'
+         * import { tempoActions } from 'tempo.ts/viem'
+         *
+         * const client = createClient({
+         *   chain: tempo({ feeToken: '0x20c0000000000000000000000000000000000001' })
+         *   transport: http(),
+         * }).extend(tempoActions())
+         *
+         * const unwatch = client.policy.watchWhitelistUpdated({
+         *   onWhitelistUpdated: (args, log) => {
+         *     console.log('Whitelist updated:', args)
+         *   },
+         * })
+         * ```
+         *
+         * @param parameters - Parameters.
+         * @returns A function to unsubscribe from the event.
+         */
+        watchWhitelistUpdated: (parameters: policyActions.watchWhitelistUpdated.Parameters) => () => void;
+        /**
+         * Watches for blacklist update events.
+         *
+         * @example
+         * ```ts
+         * import { createClient, http } from 'viem'
+         * import { tempo } from 'tempo.ts/chains'
+         * import { tempoActions } from 'tempo.ts/viem'
+         *
+         * const client = createClient({
+         *   chain: tempo({ feeToken: '0x20c0000000000000000000000000000000000001' })
+         *   transport: http(),
+         * }).extend(tempoActions())
+         *
+         * const unwatch = client.policy.watchBlacklistUpdated({
+         *   onBlacklistUpdated: (args, log) => {
+         *     console.log('Blacklist updated:', args)
+         *   },
+         * })
+         * ```
+         *
+         * @param parameters - Parameters.
+         * @returns A function to unsubscribe from the event.
+         */
+        watchBlacklistUpdated: (parameters: policyActions.watchBlacklistUpdated.Parameters) => () => void;
+    };
+    reward: {
+        /**
+         * Claims accumulated rewards for a recipient.
+         *
+         * @example
+         * ```ts
+         * import { createClient, http } from 'viem'
+         * import { privateKeyToAccount } from 'viem/accounts'
+         * import { tempo } from 'tempo.ts/chains'
+         * import { tempoActions } from 'tempo.ts/viem'
+         *
+         * const client = createClient({
+         *   account: privateKeyToAccount('0x...'),
+         *   chain: tempo({ feeToken: '0x20c0000000000000000000000000000000000001' })
+         *   transport: http(),
+         * }).extend(tempoActions())
+         *
+         * const hash = await client.reward.claim({
+         *   token: '0x20c0000000000000000000000000000000000001',
+         * })
+         * ```
+         *
+         * @param parameters - Parameters.
+         * @returns The transaction hash.
+         */
+        claim: (parameters: rewardActions.claim.Parameters<chain, account>) => Promise<rewardActions.claim.ReturnValue>;
+        /**
+         * Claims accumulated rewards for a recipient and waits for confirmation.
+         *
+         * @example
+         * ```ts
+         * import { createClient, http } from 'viem'
+         * import { privateKeyToAccount } from 'viem/accounts'
+         * import { tempo } from 'tempo.ts/chains'
+         * import { tempoActions } from 'tempo.ts/viem'
+         *
+         * const client = createClient({
+         *   account: privateKeyToAccount('0x...'),
+         *   chain: tempo({ feeToken: '0x20c0000000000000000000000000000000000001' })
+         *   transport: http(),
+         * }).extend(tempoActions())
+         *
+         * const result = await client.reward.claimSync({
+         *   token: '0x20c0000000000000000000000000000000000001',
+         * })
+         * ```
+         *
+         * @param parameters - Parameters.
+         * @returns The amount claimed and transaction receipt.
+         */
+        claimSync: (parameters: rewardActions.claimSync.Parameters<chain, account>) => Promise<rewardActions.claimSync.ReturnValue>;
+        /**
+         * Gets the total reward per second rate for all active streams.
+         *
+         * @example
+         * ```ts
+         * import { createClient, http } from 'viem'
+         * import { tempo } from 'tempo.ts/chains'
+         * import { tempoActions } from 'tempo.ts/viem'
+         *
+         * const client = createClient({
+         *   chain: tempo({ feeToken: '0x20c0000000000000000000000000000000000001' })
+         *   transport: http(),
+         * }).extend(tempoActions())
+         *
+         * const rate = await client.reward.getTotalPerSecond({
+         *   token: '0x20c0000000000000000000000000000000000001',
+         * })
+         * ```
+         *
+         * @param parameters - Parameters.
+         * @returns The total reward per second (scaled by 1e18).
+         */
+        getTotalPerSecond: (parameters: rewardActions.getTotalPerSecond.Parameters) => Promise<rewardActions.getTotalPerSecond.ReturnValue>;
+        /**
+         * Gets the reward information for a specific account.
+         *
+         * @example
+         * ```ts
+         * import { createClient, http } from 'viem'
+         * import { tempo } from 'tempo.ts/chains'
+         * import { tempoActions } from 'tempo.ts/viem'
+         *
+         * const client = createClient({
+         *   chain: tempo({ feeToken: '0x20c0000000000000000000000000000000000001' })
+         *   transport: http(),
+         * }).extend(tempoActions())
+         *
+         * const info = await client.reward.getUserRewardInfo({
+         *   token: '0x20c0000000000000000000000000000000000001',
+         *   account: '0xa5cc3c03994DB5b0d9A5eEdD10CabaB0813678AC',
+         * })
+         * ```
+         *
+         * @param parameters - Parameters.
+         * @returns The user's reward information (recipient, rewardPerToken, rewardBalance).
+         */
+        getUserRewardInfo: (parameters: rewardActions.getUserRewardInfo.Parameters) => Promise<rewardActions.getUserRewardInfo.ReturnValue>;
+        /**
+         * Sets or changes the reward recipient for a token holder.
+         *
+         * @example
+         * ```ts
+         * import { createClient, http } from 'viem'
+         * import { privateKeyToAccount } from 'viem/accounts'
+         * import { tempo } from 'tempo.ts/chains'
+         * import { tempoActions } from 'tempo.ts/viem'
+         *
+         * const client = createClient({
+         *   account: privateKeyToAccount('0x...'),
+         *   chain: tempo({ feeToken: '0x20c0000000000000000000000000000000000001' })
+         *   transport: http(),
+         * }).extend(tempoActions())
+         *
+         * const hash = await client.reward.setRecipient({
+         *   recipient: '0xa5cc3c03994DB5b0d9A5eEdD10CabaB0813678AC',
+         *   token: '0x20c0000000000000000000000000000000000001',
+         * })
+         * ```
+         *
+         * @param parameters - Parameters.
+         * @returns The transaction hash.
+         */
+        setRecipient: (parameters: rewardActions.setRecipient.Parameters<chain, account>) => Promise<rewardActions.setRecipient.ReturnValue>;
+        /**
+         * Sets or changes the reward recipient for a token holder and waits for confirmation.
+         *
+         * @example
+         * ```ts
+         * import { createClient, http } from 'viem'
+         * import { privateKeyToAccount } from 'viem/accounts'
+         * import { tempo } from 'tempo.ts/chains'
+         * import { tempoActions } from 'tempo.ts/viem'
+         *
+         * const client = createClient({
+         *   account: privateKeyToAccount('0x...'),
+         *   chain: tempo({ feeToken: '0x20c0000000000000000000000000000000000001' })
+         *   transport: http(),
+         * }).extend(tempoActions())
+         *
+         * const result = await client.reward.setRecipientSync({
+         *   recipient: '0xa5cc3c03994DB5b0d9A5eEdD10CabaB0813678AC',
+         *   token: '0x20c0000000000000000000000000000000000001',
+         * })
+         * ```
+         *
+         * @param parameters - Parameters.
+         * @returns The transaction receipt and event data.
+         */
+        setRecipientSync: (parameters: rewardActions.setRecipientSync.Parameters<chain, account>) => Promise<rewardActions.setRecipientSync.ReturnValue>;
+        /**
+         * Starts a new reward stream that distributes tokens to opted-in holders.
+         *
+         * @example
+         * ```ts
+         * import { createClient, http } from 'viem'
+         * import { privateKeyToAccount } from 'viem/accounts'
+         * import { tempo } from 'tempo.ts/chains'
+         * import { tempoActions } from 'tempo.ts/viem'
+         *
+         * const client = createClient({
+         *   account: privateKeyToAccount('0x...'),
+         *   chain: tempo({ feeToken: '0x20c0000000000000000000000000000000000001' })
+         *   transport: http(),
+         * }).extend(tempoActions())
+         *
+         * const hash = await client.reward.start({
+         *   amount: 100000000000000000000n,
+         *   seconds: 86400,
+         *   token: '0x20c0000000000000000000000000000000000001',
+         * })
+         * ```
+         *
+         * @param parameters - Parameters.
+         * @returns The transaction hash.
+         */
+        start: (parameters: rewardActions.start.Parameters<chain, account>) => Promise<rewardActions.start.ReturnValue>;
+        /**
+         * Starts a new reward stream that distributes tokens to opted-in holders and waits for confirmation.
+         *
+         * @example
+         * ```ts
+         * import { createClient, http } from 'viem'
+         * import { privateKeyToAccount } from 'viem/accounts'
+         * import { tempo } from 'tempo.ts/chains'
+         * import { tempoActions } from 'tempo.ts/viem'
+         *
+         * const client = createClient({
+         *   account: privateKeyToAccount('0x...'),
+         *   chain: tempo({ feeToken: '0x20c0000000000000000000000000000000000001' })
+         *   transport: http(),
+         * }).extend(tempoActions())
+         *
+         * const result = await client.reward.startSync({
+         *   amount: 100000000000000000000n,
+         *   seconds: 86400,
+         *   token: '0x20c0000000000000000000000000000000000001',
+         * })
+         * ```
+         *
+         * @param parameters - Parameters.
+         * @returns The transaction receipt and event data.
+         */
+        startSync: (parameters: rewardActions.startSync.Parameters<chain, account>) => Promise<rewardActions.startSync.ReturnValue>;
+        /**
+         * Watches for reward recipient set events.
+         *
+         * @example
+         * ```ts
+         * import { createClient, http } from 'viem'
+         * import { tempo } from 'tempo.ts/chains'
+         * import { tempoActions } from 'tempo.ts/viem'
+         *
+         * const client = createClient({
+         *   chain: tempo({ feeToken: '0x20c0000000000000000000000000000000000001' })
+         *   transport: http(),
+         * }).extend(tempoActions())
+         *
+         * const unwatch = client.reward.watchRewardRecipientSet({
+         *   token: '0x20c0000000000000000000000000000000000001',
+         *   onRewardRecipientSet: (args, log) => {
+         *     console.log('Reward recipient set:', args)
+         *   },
+         * })
+         * ```
+         *
+         * @param parameters - Parameters.
+         * @returns A function to unsubscribe from the event.
+         */
+        watchRewardRecipientSet: (parameters: rewardActions.watchRewardRecipientSet.Parameters) => () => void;
+        /**
+         * Watches for reward scheduled events.
+         *
+         * @example
+         * ```ts
+         * import { createClient, http } from 'viem'
+         * import { tempo } from 'tempo.ts/chains'
+         * import { tempoActions } from 'tempo.ts/viem'
+         *
+         * const client = createClient({
+         *   chain: tempo({ feeToken: '0x20c0000000000000000000000000000000000001' })
+         *   transport: http(),
+         * }).extend(tempoActions())
+         *
+         * const unwatch = client.reward.watchRewardScheduled({
+         *   token: '0x20c0000000000000000000000000000000000001',
+         *   onRewardScheduled: (args, log) => {
+         *     console.log('Reward scheduled:', args)
+         *   },
+         * })
+         * ```
+         *
+         * @param parameters - Parameters.
+         * @returns A function to unsubscribe from the event.
+         */
+        watchRewardScheduled: (parameters: rewardActions.watchRewardScheduled.Parameters) => () => void;
+    };
+    token: {
+        /**
+         * Approves a spender to transfer TIP20 tokens on behalf of the caller.
+         *
+         * @example
+         * ```ts
+         * import { createClient, http } from 'viem'
+         * import { privateKeyToAccount } from 'viem/accounts'
+         * import { tempo } from 'tempo.ts/chains'
+         * import { tempoActions } from 'tempo.ts/viem'
+         *
+         * const client = createClient({
+         *   account: privateKeyToAccount('0x...'),
+         *   chain: tempo({ feeToken: '0x20c0000000000000000000000000000000000001' })
+         *   transport: http(),
+         * }).extend(tempoActions())
+         *
+         * const hash = await client.token.approve({
+         *   spender: '0x...',
+         *   amount: 100n,
+         * })
+         * ```
+         *
+         * @param client - Client.
+         * @param parameters - Parameters.
+         * @returns The transaction hash.
+         */
+        approve: (parameters: tokenActions.approve.Parameters<chain, account>) => Promise<tokenActions.approve.ReturnValue>;
+        /**
+         * Approves a spender to transfer TIP20 tokens on behalf of the caller.
+         *
+         * @example
+         * ```ts
+         * import { createClient, http } from 'viem'
+         * import { privateKeyToAccount } from 'viem/accounts'
+         * import { tempo } from 'tempo.ts/chains'
+         * import { tempoActions } from 'tempo.ts/viem'
+         *
+         * const client = createClient({
+         *   account: privateKeyToAccount('0x...'),
+         *   chain: tempo({ feeToken: '0x20c0000000000000000000000000000000000001' })
+         *   transport: http(),
+         * }).extend(tempoActions())
+         *
+         * const result = await client.token.approveSync({
+         *   spender: '0x...',
+         *   amount: 100n,
+         * })
+         * ```
+         *
+         * @param client - Client.
+         * @param parameters - Parameters.
+         * @returns The transaction receipt and event data.
+         */
+        approveSync: (parameters: tokenActions.approveSync.Parameters<chain, account>) => Promise<tokenActions.approveSync.ReturnValue>;
+        /**
+         * Burns TIP20 tokens from a blocked address.
+         *
+         * @example
+         * ```ts
+         * import { createClient, http } from 'viem'
+         * import { privateKeyToAccount } from 'viem/accounts'
+         * import { tempo } from 'tempo.ts/chains'
+         * import { tempoActions } from 'tempo.ts/viem'
+         *
+         * const client = createClient({
+         *   account: privateKeyToAccount('0x...'),
+         *   chain: tempo({ feeToken: '0x20c0000000000000000000000000000000000001' })
+         *   transport: http(),
+         * }).extend(tempoActions())
+         *
+         * const hash = await client.token.burnBlocked({
+         *   from: '0x...',
+         *   amount: 100n,
+         *   token: '0x...',
+         * })
+         * ```
+         *
+         * @param client - Client.
+         * @param parameters - Parameters.
+         * @returns The transaction hash.
+         */
+        burnBlocked: (parameters: tokenActions.burnBlocked.Parameters<chain, account>) => Promise<tokenActions.burnBlocked.ReturnValue>;
+        /**
+         * Burns TIP20 tokens from a blocked address.
+         *
+         * @example
+         * ```ts
+         * import { createClient, http } from 'viem'
+         * import { privateKeyToAccount } from 'viem/accounts'
+         * import { tempo } from 'tempo.ts/chains'
+         * import { tempoActions } from 'tempo.ts/viem'
+         *
+         * const client = createClient({
+         *   account: privateKeyToAccount('0x...'),
+         *   chain: tempo({ feeToken: '0x20c0000000000000000000000000000000000001' })
+         *   transport: http(),
+         * }).extend(tempoActions())
+         *
+         * const result = await client.token.burnBlockedSync({
+         *   from: '0x...',
+         *   amount: 100n,
+         *   token: '0x...',
+         * })
+         * ```
+         *
+         * @param client - Client.
+         * @param parameters - Parameters.
+         * @returns The transaction receipt and event data.
+         */
+        burnBlockedSync: (parameters: tokenActions.burnBlockedSync.Parameters<chain, account>) => Promise<tokenActions.burnBlockedSync.ReturnValue>;
+        /**
+         * Burns TIP20 tokens from the caller's balance.
+         *
+         * @example
+         * ```ts
+         * import { createClient, http } from 'viem'
+         * import { privateKeyToAccount } from 'viem/accounts'
+         * import { tempo } from 'tempo.ts/chains'
+         * import { tempoActions } from 'tempo.ts/viem'
+         *
+         * const client = createClient({
+         *   account: privateKeyToAccount('0x...'),
+         *   chain: tempo({ feeToken: '0x20c0000000000000000000000000000000000001' })
+         *   transport: http(),
+         * }).extend(tempoActions())
+         *
+         * const hash = await client.token.burn({
+         *   amount: 100n,
+         *   token: '0x...',
+         * })
+         * ```
+         *
+         * @param client - Client.
+         * @param parameters - Parameters.
+         * @returns The transaction hash.
+         */
+        burn: (parameters: tokenActions.burn.Parameters<chain, account>) => Promise<tokenActions.burn.ReturnValue>;
+        /**
+         * Burns TIP20 tokens from the caller's balance.
+         *
+         * @example
+         * ```ts
+         * import { createClient, http } from 'viem'
+         * import { privateKeyToAccount } from 'viem/accounts'
+         * import { tempo } from 'tempo.ts/chains'
+         * import { tempoActions } from 'tempo.ts/viem'
+         *
+         * const client = createClient({
+         *   account: privateKeyToAccount('0x...'),
+         *   chain: tempo({ feeToken: '0x20c0000000000000000000000000000000000001' })
+         *   transport: http(),
+         * }).extend(tempoActions())
+         *
+         * const result = await client.token.burnSync({
+         *   amount: 100n,
+         *   token: '0x...',
+         * })
+         * ```
+         *
+         * @param client - Client.
+         * @param parameters - Parameters.
+         * @returns The transaction receipt and event data.
+         */
+        burnSync: (parameters: tokenActions.burnSync.Parameters<chain, account>) => Promise<tokenActions.burnSync.ReturnValue>;
+        /**
+         * Changes the transfer policy ID for a TIP20 token.
+         *
+         * @example
+         * ```ts
+         * import { createClient, http } from 'viem'
+         * import { privateKeyToAccount } from 'viem/accounts'
+         * import { tempo } from 'tempo.ts/chains'
+         * import { tempoActions } from 'tempo.ts/viem'
+         *
+         * const client = createClient({
+         *   account: privateKeyToAccount('0x...'),
+         *   chain: tempo({ feeToken: '0x20c0000000000000000000000000000000000001' })
+         *   transport: http(),
+         * }).extend(tempoActions())
+         *
+         * const hash = await client.token.changeTransferPolicy({
+         *   token: '0x...',
+         *   policyId: 1n,
+         * })
+         * ```
+         *
+         * @param client - Client.
+         * @param parameters - Parameters.
+         * @returns The transaction hash.
+         */
+        changeTransferPolicy: (parameters: tokenActions.changeTransferPolicy.Parameters<chain, account>) => Promise<tokenActions.changeTransferPolicy.ReturnValue>;
+        /**
+         * Changes the transfer policy ID for a TIP20 token.
+         *
+         * @example
+         * ```ts
+         * import { createClient, http } from 'viem'
+         * import { privateKeyToAccount } from 'viem/accounts'
+         * import { tempo } from 'tempo.ts/chains'
+         * import { tempoActions } from 'tempo.ts/viem'
+         *
+         * const client = createClient({
+         *   account: privateKeyToAccount('0x...'),
+         *   chain: tempo({ feeToken: '0x20c0000000000000000000000000000000000001' })
+         *   transport: http(),
+         * }).extend(tempoActions())
+         *
+         * const result = await client.token.changeTransferPolicySync({
+         *   token: '0x...',
+         *   policyId: 1n,
+         * })
+         * ```
+         *
+         * @param client - Client.
+         * @param parameters - Parameters.
+         * @returns The transaction receipt and event data.
+         */
+        changeTransferPolicySync: (parameters: tokenActions.changeTransferPolicySync.Parameters<chain, account>) => Promise<tokenActions.changeTransferPolicySync.ReturnValue>;
+        /**
+         * Creates a new TIP20 token.
+         *
+         * @example
+         * ```ts
+         * import { createClient, http } from 'viem'
+         * import { privateKeyToAccount } from 'viem/accounts'
+         * import { tempo } from 'tempo.ts/chains'
+         * import { tempoActions } from 'tempo.ts/viem'
+         *
+         * const client = createClient({
+         *   account: privateKeyToAccount('0x...'),
+         *   chain: tempo({ feeToken: '0x20c0000000000000000000000000000000000001' })
+         *   transport: http(),
+         * }).extend(tempoActions())
+         *
+         * const { hash, id, address } = await client.token.create({
+         *   name: 'My Token',
+         *   symbol: 'MTK',
+         *   currency: 'USD',
+         * })
+         * ```
+         *
+         * @param client - Client.
+         * @param parameters - Parameters.
+         * @returns The transaction hash.
+         */
+        create: (parameters: tokenActions.create.Parameters<chain, account>) => Promise<tokenActions.create.ReturnValue>;
+        /**
+         * Creates a new TIP20 token.
+         *
+         * @example
+         * ```ts
+         * import { createClient, http } from 'viem'
+         * import { privateKeyToAccount } from 'viem/accounts'
+         * import { tempo } from 'tempo.ts/chains'
+         * import { tempoActions } from 'tempo.ts/viem'
+         *
+         * const client = createClient({
+         *   account: privateKeyToAccount('0x...'),
+         *   chain: tempo({ feeToken: '0x20c0000000000000000000000000000000000001' })
+         *   transport: http(),
+         * }).extend(tempoActions())
+         *
+         * const result = await client.token.createSync({
+         *   name: 'My Token',
+         *   symbol: 'MTK',
+         *   currency: 'USD',
+         * })
+         * ```
+         *
+         * @param client - Client.
+         * @param parameters - Parameters.
+         * @returns The transaction receipt and event data.
+         */
+        createSync: (parameters: tokenActions.createSync.Parameters<chain, account>) => Promise<tokenActions.createSync.ReturnValue>;
+        /**
+         * Gets TIP20 token allowance.
+         *
+         * @example
+         * ```ts
+         * import { createClient, http } from 'viem'
+         * import { privateKeyToAccount } from 'viem/accounts'
+         * import { tempo } from 'tempo.ts/chains'
+         * import { tempoActions } from 'tempo.ts/viem'
+         *
+         * const client = createClient({
+         *   account: privateKeyToAccount('0x...'),
+         *   chain: tempo({ feeToken: '0x20c0000000000000000000000000000000000001' })
+         *   transport: http(),
+         * }).extend(tempoActions())
+         *
+         * const allowance = await client.token.getAllowance({
+         *   spender: '0x...',
+         * })
+         * ```
+         *
+         * @param client - Client.
+         * @param parameters - Parameters.
+         * @returns The token allowance.
+         */
+        getAllowance: (parameters: tokenActions.getAllowance.Parameters) => Promise<tokenActions.getAllowance.ReturnValue>;
+        /**
+         * Gets TIP20 token balance for an address.
+         *
+         * @example
+         * ```ts
+         * import { createClient, http } from 'viem'
+         * import { privateKeyToAccount } from 'viem/accounts'
+         * import { tempo } from 'tempo.ts/chains'
+         * import { tempoActions } from 'tempo.ts/viem'
+         *
+         * const client = createClient({
+         *   account: privateKeyToAccount('0x...'),
+         *   chain: tempo({ feeToken: '0x20c0000000000000000000000000000000000001' })
+         *   transport: http(),
+         * }).extend(tempoActions())
+         *
+         * const balance = await client.token.getBalance()
+         * ```
+         *
+         * @param client - Client.
+         * @param parameters - Parameters.
+         * @returns The token balance.
+         */
+        getBalance: (parameters: tokenActions.getBalance.Parameters<account>) => Promise<tokenActions.getBalance.ReturnValue>;
+        /**
+         * Gets TIP20 token metadata including name, symbol, currency, decimals, and total supply.
+         *
+         * @example
+         * ```ts
+         * import { createClient, http } from 'viem'
+         * import { tempo } from 'tempo.ts/chains'
+         * import { tempoActions } from 'tempo.ts/viem'
+         *
+         * const client = createClient({
+         *   chain: tempo({ feeToken: '0x20c0000000000000000000000000000000000001' })
+         *   transport: http(),
+         * }).extend(tempoActions())
+         *
+         * const metadata = await client.token.getMetadata({
+         *   token: '0x...',
+         * })
+         * ```
+         *
+         * @param client - Client.
+         * @param parameters - Parameters.
+         * @returns The token metadata.
+         */
+        getMetadata: (parameters: tokenActions.getMetadata.Parameters) => Promise<tokenActions.getMetadata.ReturnValue>;
+        /**
+         * Gets the admin role for a specific role in a TIP20 token.
+         *
+         * @example
+         * ```ts
+         * import { createClient, http } from 'viem'
+         * import { tempo } from 'tempo.ts/chains'
+         * import { tempoActions } from 'tempo.ts/viem'
+         *
+         * const client = createClient({
+         *   chain: tempo({ feeToken: '0x20c0000000000000000000000000000000000001' })
+         *   transport: http(),
+         * }).extend(tempoActions())
+         *
+         * const adminRole = await client.token.getRoleAdmin({
+         *   role: 'issuer',
+         *   token: '0x...',
+         * })
+         * ```
+         *
+         * @param client - Client.
+         * @param parameters - Parameters.
+         * @returns The admin role hash.
+         */
+        getRoleAdmin: (parameters: tokenActions.getRoleAdmin.Parameters) => Promise<tokenActions.getRoleAdmin.ReturnValue>;
+        /**
+         * Checks if an account has a specific role for a TIP20 token.
+         *
+         * @example
+         * ```ts
+         * import { createClient, http } from 'viem'
+         * import { privateKeyToAccount } from 'viem/accounts'
+         * import { tempo } from 'tempo.ts/chains'
+         * import { tempoActions } from 'tempo.ts/viem'
+         *
+         * const client = createClient({
+         *   account: privateKeyToAccount('0x...'),
+         *   chain: tempo({ feeToken: '0x20c0000000000000000000000000000000000001' })
+         *   transport: http(),
+         * }).extend(tempoActions())
+         *
+         * const hasRole = await client.token.hasRole({
+         *   token: '0x...',
+         *   role: 'issuer',
+         * })
+         * ```
+         *
+         * @param client - Client.
+         * @param parameters - Parameters.
+         * @returns Whether the account has the role.
+         */
+        hasRole: (parameters: tokenActions.hasRole.Parameters<account>) => Promise<tokenActions.hasRole.ReturnValue>;
+        /**
+         * Grants a role for a TIP20 token.
+         *
+         * @example
+         * ```ts
+         * import { createClient, http } from 'viem'
+         * import { privateKeyToAccount } from 'viem/accounts'
+         * import { tempo } from 'tempo.ts/chains'
+         * import { tempoActions } from 'tempo.ts/viem'
+         *
+         * const client = createClient({
+         *   account: privateKeyToAccount('0x...'),
+         *   chain: tempo({ feeToken: '0x20c0000000000000000000000000000000000001' })
+         *   transport: http(),
+         * }).extend(tempoActions())
+         *
+         * const hash = await client.token.grantRoles({
+         *   token: '0x...',
+         *   to: '0x...',
+         *   roles: ['issuer'],
+         * })
+         * ```
+         *
+         * @param client - Client.
+         * @param parameters - Parameters.
+         * @returns The transaction hash.
+         */
+        grantRoles: (parameters: tokenActions.grantRoles.Parameters<chain, account>) => Promise<tokenActions.grantRoles.ReturnValue>;
+        /**
+         * Grants a role for a TIP20 token.
+         *
+         * @example
+         * ```ts
+         * import { createClient, http } from 'viem'
+         * import { privateKeyToAccount } from 'viem/accounts'
+         * import { tempo } from 'tempo.ts/chains'
+         * import { tempoActions } from 'tempo.ts/viem'
+         *
+         * const client = createClient({
+         *   account: privateKeyToAccount('0x...'),
+         *   chain: tempo({ feeToken: '0x20c0000000000000000000000000000000000001' })
+         *   transport: http(),
+         * }).extend(tempoActions())
+         *
+         * const result = await client.token.grantRolesSync({
+         *   token: '0x...',
+         *   to: '0x...',
+         *   roles: ['issuer'],
+         * })
+         * ```
+         *
+         * @param parameters - Parameters.
+         * @returns The transaction receipt and event data.
+         */
+        grantRolesSync: (parameters: tokenActions.grantRolesSync.Parameters<chain, account>) => Promise<tokenActions.grantRolesSync.ReturnValue>;
+        /**
+         * Mints TIP20 tokens to an address.
+         *
+         * @example
+         * ```ts
+         * import { createClient, http } from 'viem'
+         * import { privateKeyToAccount } from 'viem/accounts'
+         * import { tempo } from 'tempo.ts/chains'
+         * import { tempoActions } from 'tempo.ts/viem'
+         *
+         * const client = createClient({
+         *   account: privateKeyToAccount('0x...'),
+         *   chain: tempo({ feeToken: '0x20c0000000000000000000000000000000000001' })
+         *   transport: http(),
+         * }).extend(tempoActions())
+         *
+         * const hash = await client.token.mint({
+         *   to: '0x...',
+         *   amount: 100n,
+         *   token: '0x...',
+         * })
+         * ```
+         *
+         * @param client - Client.
+         * @param parameters - Parameters.
+         * @returns The transaction hash.
+         */
+        mint: (parameters: tokenActions.mint.Parameters<chain, account>) => Promise<tokenActions.mint.ReturnValue>;
+        /**
+         * Mints TIP20 tokens to an address.
+         *
+         * @example
+         * ```ts
+         * import { createClient, http } from 'viem'
+         * import { privateKeyToAccount } from 'viem/accounts'
+         * import { tempo } from 'tempo.ts/chains'
+         * import { tempoActions } from 'tempo.ts/viem'
+         *
+         * const client = createClient({
+         *   account: privateKeyToAccount('0x...'),
+         *   chain: tempo({ feeToken: '0x20c0000000000000000000000000000000000001' })
+         *   transport: http(),
+         * }).extend(tempoActions())
+         *
+         * const result = await client.token.mintSync({
+         *   to: '0x...',
+         *   amount: 100n,
+         *   token: '0x...',
+         * })
+         * ```
+         *
+         * @param client - Client.
+         * @param parameters - Parameters.
+         * @returns The transaction receipt and event data.
+         */
+        mintSync: (parameters: tokenActions.mintSync.Parameters<chain, account>) => Promise<tokenActions.mintSync.ReturnValue>;
+        /**
+         * Pauses a TIP20 token.
+         *
+         * @example
+         * ```ts
+         * import { createClient, http } from 'viem'
+         * import { privateKeyToAccount } from 'viem/accounts'
+         * import { tempo } from 'tempo.ts/chains'
+         * import { tempoActions } from 'tempo.ts/viem'
+         *
+         * const client = createClient({
+         *   account: privateKeyToAccount('0x...'),
+         *   chain: tempo({ feeToken: '0x20c0000000000000000000000000000000000001' })
+         *   transport: http(),
+         * }).extend(tempoActions())
+         *
+         * const hash = await client.token.pause({
+         *   token: '0x...',
+         * })
+         * ```
+         *
+         * @param client - Client.
+         * @param parameters - Parameters.
+         * @returns The transaction hash.
+         */
+        pause: (parameters: tokenActions.pause.Parameters<chain, account>) => Promise<tokenActions.pause.ReturnValue>;
+        /**
+         * Pauses a TIP20 token.
+         *
+         * @example
+         * ```ts
+         * import { createClient, http } from 'viem'
+         * import { privateKeyToAccount } from 'viem/accounts'
+         * import { tempo } from 'tempo.ts/chains'
+         * import { tempoActions } from 'tempo.ts/viem'
+         *
+         * const client = createClient({
+         *   account: privateKeyToAccount('0x...'),
+         *   chain: tempo({ feeToken: '0x20c0000000000000000000000000000000000001' })
+         *   transport: http(),
+         * }).extend(tempoActions())
+         *
+         * const result = await client.token.pauseSync({
+         *   token: '0x...',
+         * })
+         * ```
+         *
+         * @param client - Client.
+         * @param parameters - Parameters.
+         * @returns The transaction receipt and event data.
+         */
+        pauseSync: (parameters: tokenActions.pauseSync.Parameters<chain, account>) => Promise<tokenActions.pauseSync.ReturnValue>;
+        /**
+         * Renounces a role for a TIP20 token.
+         *
+         * @example
+         * ```ts
+         * import { createClient, http } from 'viem'
+         * import { privateKeyToAccount } from 'viem/accounts'
+         * import { tempo } from 'tempo.ts/chains'
+         * import { tempoActions } from 'tempo.ts/viem'
+         *
+         * const client = createClient({
+         *   account: privateKeyToAccount('0x...'),
+         *   chain: tempo({ feeToken: '0x20c0000000000000000000000000000000000001' })
+         *   transport: http(),
+         * }).extend(tempoActions())
+         *
+         * const hash = await client.token.renounceRoles({
+         *   token: '0x...',
+         *   roles: ['issuer'],
+         * })
+         * ```
+         *
+         * @param client - Client.
+         * @param parameters - Parameters.
+         * @returns The transaction hash.
+         */
+        renounceRoles: (parameters: tokenActions.renounceRoles.Parameters<chain, account>) => Promise<tokenActions.renounceRoles.ReturnValue>;
+        /**
+         * Renounces a role for a TIP20 token.
+         *
+         * @example
+         * ```ts
+         * import { createClient, http } from 'viem'
+         * import { privateKeyToAccount } from 'viem/accounts'
+         * import { tempo } from 'tempo.ts/chains'
+         * import { tempoActions } from 'tempo.ts/viem'
+         *
+         * const client = createClient({
+         *   account: privateKeyToAccount('0x...'),
+         *   chain: tempo({ feeToken: '0x20c0000000000000000000000000000000000001' })
+         *   transport: http(),
+         * }).extend(tempoActions())
+         *
+         * const result = await client.token.renounceRolesSync({
+         *   token: '0x...',
+         *   roles: ['issuer'],
+         * })
+         * ```
+         *
+         * @param parameters - Parameters.
+         * @returns The transaction receipt and event data.
+         */
+        renounceRolesSync: (parameters: tokenActions.renounceRolesSync.Parameters<chain, account>) => Promise<tokenActions.renounceRolesSync.ReturnValue>;
+        /**
+         * Revokes a role for a TIP20 token.
+         *
+         * @example
+         * ```ts
+         * import { createClient, http } from 'viem'
+         * import { privateKeyToAccount } from 'viem/accounts'
+         * import { tempo } from 'tempo.ts/chains'
+         * import { tempoActions } from 'tempo.ts/viem'
+         *
+         * const client = createClient({
+         *   account: privateKeyToAccount('0x...'),
+         *   chain: tempo({ feeToken: '0x20c0000000000000000000000000000000000001' })
+         *   transport: http(),
+         * }).extend(tempoActions())
+         *
+         * const hash = await client.token.revokeRoles({
+         *   token: '0x...',
+         *   from: '0x...',
+         *   roles: ['issuer'],
+         * })
+         * ```
+         *
+         * @param client - Client.
+         * @param parameters - Parameters.
+         * @returns The transaction hash.
+         */
+        revokeRoles: (parameters: tokenActions.revokeRoles.Parameters<chain, account>) => Promise<tokenActions.revokeRoles.ReturnValue>;
+        /**
+         * Revokes a role for a TIP20 token.
+         *
+         * @example
+         * ```ts
+         * import { createClient, http } from 'viem'
+         * import { privateKeyToAccount } from 'viem/accounts'
+         * import { tempo } from 'tempo.ts/chains'
+         * import { tempoActions } from 'tempo.ts/viem'
+         *
+         * const client = createClient({
+         *   account: privateKeyToAccount('0x...'),
+         *   chain: tempo({ feeToken: '0x20c0000000000000000000000000000000000001' })
+         *   transport: http(),
+         * }).extend(tempoActions())
+         *
+         * const result = await client.token.revokeRolesSync({
+         *   token: '0x...',
+         *   from: '0x...',
+         *   roles: ['issuer'],
+         * })
+         * ```
+         *
+         * @param parameters - Parameters.
+         * @returns The transaction receipt and event data.
+         */
+        revokeRolesSync: (parameters: tokenActions.revokeRolesSync.Parameters<chain, account>) => Promise<tokenActions.revokeRolesSync.ReturnValue>;
+        /**
+         * Sets the supply cap for a TIP20 token.
+         *
+         * @example
+         * ```ts
+         * import { createClient, http } from 'viem'
+         * import { privateKeyToAccount } from 'viem/accounts'
+         * import { tempo } from 'tempo.ts/chains'
+         * import { tempoActions } from 'tempo.ts/viem'
+         *
+         * const client = createClient({
+         *   account: privateKeyToAccount('0x...'),
+         *   chain: tempo({ feeToken: '0x20c0000000000000000000000000000000000001' })
+         *   transport: http(),
+         * }).extend(tempoActions())
+         *
+         * const hash = await client.token.setSupplyCap({
+         *   token: '0x...',
+         *   supplyCap: 1000000n,
+         * })
+         * ```
+         *
+         * @param client - Client.
+         * @param parameters - Parameters.
+         * @returns The transaction hash.
+         */
+        setSupplyCap: (parameters: tokenActions.setSupplyCap.Parameters<chain, account>) => Promise<tokenActions.setSupplyCap.ReturnValue>;
+        /**
+         * Sets the supply cap for a TIP20 token.
+         *
+         * @example
+         * ```ts
+         * import { createClient, http } from 'viem'
+         * import { privateKeyToAccount } from 'viem/accounts'
+         * import { tempo } from 'tempo.ts/chains'
+         * import { tempoActions } from 'tempo.ts/viem'
+         *
+         * const client = createClient({
+         *   account: privateKeyToAccount('0x...'),
+         *   chain: tempo({ feeToken: '0x20c0000000000000000000000000000000000001' })
+         *   transport: http(),
+         * }).extend(tempoActions())
+         *
+         * const result = await client.token.setSupplyCapSync({
+         *   token: '0x...',
+         *   supplyCap: 1000000n,
+         * })
+         * ```
+         *
+         * @param client - Client.
+         * @param parameters - Parameters.
+         * @returns The transaction receipt and event data.
+         */
+        setSupplyCapSync: (parameters: tokenActions.setSupplyCapSync.Parameters<chain, account>) => Promise<tokenActions.setSupplyCapSync.ReturnValue>;
+        /**
+         * Sets the admin role for a specific role in a TIP20 token.
+         *
+         * @example
+         * ```ts
+         * import { createClient, http } from 'viem'
+         * import { privateKeyToAccount } from 'viem/accounts'
+         * import { tempo } from 'tempo.ts/chains'
+         * import { tempoActions } from 'tempo.ts/viem'
+         *
+         * const client = createClient({
+         *   account: privateKeyToAccount('0x...'),
+         *   chain: tempo({ feeToken: '0x20c0000000000000000000000000000000000001' })
+         *   transport: http(),
+         * }).extend(tempoActions())
+         *
+         * const hash = await client.token.setRoleAdmin({
+         *   token: '0x...',
+         *   role: 'issuer',
+         *   adminRole: 'admin',
+         * })
+         * ```
+         *
+         * @param client - Client.
+         * @param parameters - Parameters.
+         * @returns The transaction hash.
+         */
+        setRoleAdmin: (parameters: tokenActions.setRoleAdmin.Parameters<chain, account>) => Promise<tokenActions.setRoleAdmin.ReturnValue>;
+        /**
+         * Sets the admin role for a specific role in a TIP20 token.
+         *
+         * @example
+         * ```ts
+         * import { createClient, http } from 'viem'
+         * import { privateKeyToAccount } from 'viem/accounts'
+         * import { tempo } from 'tempo.ts/chains'
+         * import { tempoActions } from 'tempo.ts/viem'
+         *
+         * const client = createClient({
+         *   account: privateKeyToAccount('0x...'),
+         *   chain: tempo({ feeToken: '0x20c0000000000000000000000000000000000001' })
+         *   transport: http(),
+         * }).extend(tempoActions())
+         *
+         * const result = await client.token.setRoleAdminSync({
+         *   token: '0x...',
+         *   role: 'issuer',
+         *   adminRole: 'admin',
+         * })
+         * ```
+         *
+         * @param client - Client.
+         * @param parameters - Parameters.
+         * @returns The transaction receipt and event data.
+         */
+        setRoleAdminSync: (parameters: tokenActions.setRoleAdminSync.Parameters<chain, account>) => Promise<tokenActions.setRoleAdminSync.ReturnValue>;
+        /**
+         * Transfers TIP20 tokens to another address.
+         *
+         * @example
+         * ```ts
+         * import { createClient, http } from 'viem'
+         * import { privateKeyToAccount } from 'viem/accounts'
+         * import { tempo } from 'tempo.ts/chains'
+         * import { tempoActions } from 'tempo.ts/viem'
+         *
+         * const client = createClient({
+         *   account: privateKeyToAccount('0x...'),
+         *   chain: tempo({ feeToken: '0x20c0000000000000000000000000000000000001' })
+         *   transport: http(),
+         * }).extend(tempoActions())
+         *
+         * const hash = await client.token.transfer({
+         *   to: '0x...',
+         *   amount: 100n,
+         * })
+         * ```
+         *
+         * @param client - Client.
+         * @param parameters - Parameters.
+         * @returns The transaction hash.
+         */
+        transfer: (parameters: tokenActions.transfer.Parameters<chain, account>) => Promise<tokenActions.transfer.ReturnValue>;
+        /**
+         * Transfers TIP20 tokens to another address.
+         *
+         * @example
+         * ```ts
+         * import { createClient, http } from 'viem'
+         * import { privateKeyToAccount } from 'viem/accounts'
+         * import { tempo } from 'tempo.ts/chains'
+         * import { tempoActions } from 'tempo.ts/viem'
+         *
+         * const client = createClient({
+         *   account: privateKeyToAccount('0x...'),
+         *   chain: tempo({ feeToken: '0x20c0000000000000000000000000000000000001' })
+         *   transport: http(),
+         * }).extend(tempoActions())
+         *
+         * const result = await client.token.transferSync({
+         *   to: '0x...',
+         *   amount: 100n,
+         * })
+         * ```
+         *
+         * @param client - Client.
+         * @param parameters - Parameters.
+         * @returns The transaction receipt and event data.
+         */
+        transferSync: (parameters: tokenActions.transferSync.Parameters<chain, account>) => Promise<tokenActions.transferSync.ReturnValue>;
+        /**
+         * Unpauses a TIP20 token.
+         *
+         * @example
+         * ```ts
+         * import { createClient, http } from 'viem'
+         * import { privateKeyToAccount } from 'viem/accounts'
+         * import { tempo } from 'tempo.ts/chains'
+         * import { tempoActions } from 'tempo.ts/viem'
+         *
+         * const client = createClient({
+         *   account: privateKeyToAccount('0x...'),
+         *   chain: tempo({ feeToken: '0x20c0000000000000000000000000000000000001' })
+         *   transport: http(),
+         * }).extend(tempoActions())
+         *
+         * const hash = await client.token.unpause({
+         *   token: '0x...',
+         * })
+         * ```
+         *
+         * @param client - Client.
+         * @param parameters - Parameters.
+         * @returns The transaction hash.
+         */
+        unpause: (parameters: tokenActions.unpause.Parameters<chain, account>) => Promise<tokenActions.unpause.ReturnValue>;
+        /**
+         * Unpauses a TIP20 token.
+         *
+         * @example
+         * ```ts
+         * import { createClient, http } from 'viem'
+         * import { privateKeyToAccount } from 'viem/accounts'
+         * import { tempo } from 'tempo.ts/chains'
+         * import { tempoActions } from 'tempo.ts/viem'
+         *
+         * const client = createClient({
+         *   account: privateKeyToAccount('0x...'),
+         *   chain: tempo({ feeToken: '0x20c0000000000000000000000000000000000001' })
+         *   transport: http(),
+         * }).extend(tempoActions())
+         *
+         * const result = await client.token.unpauseSync({
+         *   token: '0x...',
+         * })
+         * ```
+         *
+         * @param client - Client.
+         * @param parameters - Parameters.
+         * @returns The transaction receipt and event data.
+         */
+        unpauseSync: (parameters: tokenActions.unpauseSync.Parameters<chain, account>) => Promise<tokenActions.unpauseSync.ReturnValue>;
+        /**
+         * Watches for TIP20 token approval events.
+         *
+         * @example
+         * ```ts
+         * import { createClient, http } from 'viem'
+         * import { tempo } from 'tempo.ts/chains'
+         * import { tempoActions } from 'tempo.ts/viem'
+         *
+         * const client = createClient({
+         *   chain: tempo({ feeToken: '0x20c0000000000000000000000000000000000001' })
+         *   transport: http(),
+         * }).extend(tempoActions())
+         *
+         * const unwatch = client.token.watchApprove({
+         *   onApproval: (args, log) => {
+         *     console.log('Approval:', args)
+         *   },
+         * })
+         * ```
+         *
+         * @param client - Client.
+         * @param parameters - Parameters.
+         * @returns A function to unsubscribe from the event.
+         */
+        watchApprove: (parameters: tokenActions.watchApprove.Parameters) => () => void;
+        /**
+         * Watches for TIP20 token burn events.
+         *
+         * @example
+         * ```ts
+         * import { createClient, http } from 'viem'
+         * import { tempo } from 'tempo.ts/chains'
+         * import { tempoActions } from 'tempo.ts/viem'
+         *
+         * const client = createClient({
+         *   chain: tempo({ feeToken: '0x20c0000000000000000000000000000000000001' })
+         *   transport: http(),
+         * }).extend(tempoActions())
+         *
+         * const unwatch = client.token.watchBurn({
+         *   onBurn: (args, log) => {
+         *     console.log('Burn:', args)
+         *   },
+         * })
+         * ```
+         *
+         * @param client - Client.
+         * @param parameters - Parameters.
+         * @returns A function to unsubscribe from the event.
+         */
+        watchBurn: (parameters: tokenActions.watchBurn.Parameters) => () => void;
+        /**
+         * Watches for new TIP20 tokens created.
+         *
+         * @example
+         * ```ts
+         * import { createClient, http } from 'viem'
+         * import { tempo } from 'tempo.ts/chains'
+         * import { tempoActions } from 'tempo.ts/viem'
+         *
+         * const client = createClient({
+         *   chain: tempo({ feeToken: '0x20c0000000000000000000000000000000000001' })
+         *   transport: http(),
+         * }).extend(tempoActions())
+         *
+         * const unwatch = client.token.watchCreate({
+         *   onTokenCreated: (args, log) => {
+         *     console.log('Token created:', args)
+         *   },
+         * })
+         * ```
+         *
+         * @param client - Client.
+         * @param parameters - Parameters.
+         * @returns A function to unsubscribe from the event.
+         */
+        watchCreate: (parameters: tokenActions.watchCreate.Parameters) => () => void;
+        /**
+         * Watches for TIP20 token mint events.
+         *
+         * @example
+         * ```ts
+         * import { createClient, http } from 'viem'
+         * import { tempo } from 'tempo.ts/chains'
+         * import { tempoActions } from 'tempo.ts/viem'
+         *
+         * const client = createClient({
+         *   chain: tempo({ feeToken: '0x20c0000000000000000000000000000000000001' })
+         *   transport: http(),
+         * }).extend(tempoActions())
+         *
+         * const unwatch = client.token.watchMint({
+         *   onMint: (args, log) => {
+         *     console.log('Mint:', args)
+         *   },
+         * })
+         * ```
+         *
+         * @param client - Client.
+         * @param parameters - Parameters.
+         * @returns A function to unsubscribe from the event.
+         */
+        watchMint: (parameters: tokenActions.watchMint.Parameters) => () => void;
+        /**
+         * Watches for TIP20 token role admin updates.
+         *
+         * @example
+         * ```ts
+         * import { createClient, http } from 'viem'
+         * import { tempo } from 'tempo.ts/chains'
+         * import { tempoActions } from 'tempo.ts/viem'
+         *
+         * const client = createClient({
+         *   chain: tempo({ feeToken: '0x20c0000000000000000000000000000000000001' })
+         *   transport: http(),
+         * }).extend(tempoActions())
+         *
+         * const unwatch = client.token.watchAdminRole({
+         *   onRoleAdminUpdated: (args, log) => {
+         *     console.log('Role admin updated:', args)
+         *   },
+         * })
+         * ```
+         *
+         * @param client - Client.
+         * @param parameters - Parameters.
+         * @returns A function to unsubscribe from the event.
+         */
+        watchAdminRole: (parameters: tokenActions.watchAdminRole.Parameters) => () => void;
+        /**
+         * Watches for TIP20 token role membership updates.
+         *
+         * @example
+         * ```ts
+         * import { createClient, http } from 'viem'
+         * import { tempo } from 'tempo.ts/chains'
+         * import { tempoActions } from 'tempo.ts/viem'
+         *
+         * const client = createClient({
+         *   chain: tempo({ feeToken: '0x20c0000000000000000000000000000000000001' })
+         *   transport: http(),
+         * }).extend(tempoActions())
+         *
+         * const unwatch = client.token.watchRole({
+         *   onRoleUpdated: (args, log) => {
+         *     console.log('Role updated:', args)
+         *   },
+         * })
+         * ```
+         *
+         * @param client - Client.
+         * @param parameters - Parameters.
+         * @returns A function to unsubscribe from the event.
+         */
+        watchRole: (parameters: tokenActions.watchRole.Parameters) => () => void;
+        /**
+         * Watches for TIP20 token transfer events.
+         *
+         * @example
+         * ```ts
+         * import { createClient, http } from 'viem'
+         * import { tempo } from 'tempo.ts/chains'
+         * import { tempoActions } from 'tempo.ts/viem'
+         *
+         * const client = createClient({
+         *   chain: tempo({ feeToken: '0x20c0000000000000000000000000000000000001' })
+         *   transport: http(),
+         * }).extend(tempoActions())
+         *
+         * const unwatch = client.token.watchTransfer({
+         *   onTransfer: (args, log) => {
+         *     console.log('Transfer:', args)
+         *   },
+         * })
+         * ```
+         *
+         * @param client - Client.
+         * @param parameters - Parameters.
+         * @returns A function to unsubscribe from the event.
+         */
+        watchTransfer: (parameters: tokenActions.watchTransfer.Parameters) => () => void;
+    };
+};
+export declare function decorator(): <transport extends Transport, chain extends Chain | undefined, account extends Account | undefined>(client: Client<transport, chain, account>) => Decorator<chain, account>;
+//# sourceMappingURL=Decorator.d.ts.map