viem 2.42.0 → 2.43.0

package/_esm/tempo/actions/amm.js

@@ -0,0 +1,818 @@
+import { PoolId, TokenId } from 'ox/tempo';
+import { multicall } from '../../actions/public/multicall.js';
+import { readContract } from '../../actions/public/readContract.js';
+import { watchContractEvent } from '../../actions/public/watchContractEvent.js';
+import { writeContract } from '../../actions/wallet/writeContract.js';
+import { writeContractSync } from '../../actions/wallet/writeContractSync.js';
+import { parseEventLogs } from '../../utils/abi/parseEventLogs.js';
+import * as Abis from '../Abis.js';
+import * as Addresses from '../Addresses.js';
+import { defineCall } from '../internal/utils.js';
+/**
+ * Gets the reserves for a liquidity pool.
+ *
+ * @example
+ * ```ts
+ * import { createClient, http } from 'viem'
+ * import { tempo } from 'tempo.ts/chains'
+ * import { Actions } from 'tempo.ts/viem'
+ *
+ * const client = createClient({
+ *   chain: tempo({ feeToken: '0x20c0000000000000000000000000000000000001' })
+ *   transport: http(),
+ * })
+ *
+ * const pool = await Actions.amm.getPool(client, {
+ *   userToken: '0x...',
+ *   validatorToken: '0x...',
+ * })
+ * ```
+ *
+ * @param client - Client.
+ * @param parameters - Parameters.
+ * @returns The pool reserves.
+ */
+export async function getPool(client, parameters) {
+    const { userToken, validatorToken, ...rest } = parameters;
+    const [pool, totalSupply] = await multicall(client, {
+        ...rest,
+        contracts: getPool.calls({ userToken, validatorToken }),
+        allowFailure: false,
+        deployless: true,
+    });
+    return {
+        reserveUserToken: pool.reserveUserToken,
+        reserveValidatorToken: pool.reserveValidatorToken,
+        totalSupply,
+    };
+}
+(function (getPool) {
+    /**
+     * Defines calls to the `getPool` and `totalSupply` functions.
+     *
+     * @param args - Arguments.
+     * @returns The calls.
+     */
+    function calls(args) {
+        const { userToken, validatorToken } = args;
+        return [
+            defineCall({
+                address: Addresses.feeManager,
+                abi: Abis.feeAmm,
+                args: [TokenId.toAddress(userToken), TokenId.toAddress(validatorToken)],
+                functionName: 'getPool',
+            }),
+            defineCall({
+                address: Addresses.feeManager,
+                abi: Abis.feeAmm,
+                args: [PoolId.from({ userToken, validatorToken })],
+                functionName: 'totalSupply',
+            }),
+        ];
+    }
+    getPool.calls = calls;
+})(getPool || (getPool = {}));
+/**
+ * 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 { Actions } from 'tempo.ts/viem'
+ *
+ * const client = createClient({
+ *   chain: tempo({ feeToken: '0x20c0000000000000000000000000000000000001' })
+ *   transport: http(),
+ * })
+ *
+ * const poolId = await Actions.amm.getPoolId(client, {
+ *   userToken: '0x...',
+ *   validatorToken: '0x...',
+ * })
+ *
+ * const balance = await Actions.amm.getLiquidityBalance(client, {
+ *   poolId,
+ *   address: '0x...',
+ * })
+ * ```
+ *
+ * @param client - Client.
+ * @param parameters - Parameters.
+ * @returns The LP token balance.
+ */
+export async function getLiquidityBalance(client, parameters) {
+    const { address, poolId, userToken, validatorToken, ...rest } = parameters;
+    return readContract(client, {
+        ...rest,
+        ...getLiquidityBalance.call({
+            address,
+            poolId,
+            userToken,
+            validatorToken,
+        }),
+    });
+}
+(function (getLiquidityBalance) {
+    /**
+     * Defines a call to the `liquidityBalances` function.
+     *
+     * @param args - Arguments.
+     * @returns The call.
+     */
+    function call(args) {
+        const { address } = args;
+        const poolId = (() => {
+            if ('poolId' in args && args.poolId)
+                return args.poolId;
+            if ('userToken' in args && 'validatorToken' in args)
+                return PoolId.from({
+                    userToken: args.userToken,
+                    validatorToken: args.validatorToken,
+                });
+            throw new Error('`poolId`, or `userToken` and `validatorToken` must be provided.');
+        })();
+        return defineCall({
+            address: Addresses.feeManager,
+            abi: Abis.feeAmm,
+            args: [poolId, address],
+            functionName: 'liquidityBalances',
+        });
+    }
+    getLiquidityBalance.call = call;
+})(getLiquidityBalance || (getLiquidityBalance = {}));
+/**
+ * Performs a rebalance swap from validator token to user token.
+ *
+ * @example
+ * ```ts
+ * import { createClient, http } from 'viem'
+ * import { tempo } from 'tempo.ts/chains'
+ * import { Actions } from 'tempo.ts/viem'
+ * import { privateKeyToAccount } from 'viem/accounts'
+ *
+ * const client = createClient({
+ *   account: privateKeyToAccount('0x...'),
+ *   chain: tempo({ feeToken: '0x20c0000000000000000000000000000000000001' })
+ *   transport: http(),
+ * })
+ *
+ * const hash = await Actions.amm.rebalanceSwap(client, {
+ *   userToken: '0x...',
+ *   validatorToken: '0x...',
+ *   amountOut: 100n,
+ *   to: '0x...',
+ * })
+ * ```
+ *
+ * @param client - Client.
+ * @param parameters - Parameters.
+ * @returns The transaction hash.
+ */
+export async function rebalanceSwap(client, parameters) {
+    return rebalanceSwap.inner(writeContract, client, parameters);
+}
+(function (rebalanceSwap) {
+    /** @internal */
+    async function inner(action, client, parameters) {
+        const { userToken, validatorToken, amountOut, to, ...rest } = parameters;
+        const call = rebalanceSwap.call({
+            userToken,
+            validatorToken,
+            amountOut,
+            to,
+        });
+        return (await action(client, {
+            ...rest,
+            ...call,
+        }));
+    }
+    rebalanceSwap.inner = inner;
+    /**
+     * Defines a call to the `rebalanceSwap` function.
+     *
+     * Can be passed as a parameter to:
+     * - [`estimateContractGas`](https://viem.sh/docs/contract/estimateContractGas): estimate the gas cost of the call
+     * - [`simulateContract`](https://viem.sh/docs/contract/simulateContract): simulate the call
+     * - [`sendCalls`](https://viem.sh/docs/actions/wallet/sendCalls): send multiple calls
+     *
+     * @example
+     * ```ts
+     * import { createClient, http, walletActions } from 'viem'
+     * import { tempo } from 'tempo.ts/chains'
+     * import { Actions } from 'tempo.ts/viem'
+     *
+     * const client = createClient({
+     *   chain: tempo({ feeToken: '0x20c0000000000000000000000000000000000001' })
+     *   transport: http(),
+     * }).extend(walletActions)
+     *
+     * const { result } = await client.sendCalls({
+     *   calls: [
+     *     actions.amm.rebalanceSwap.call({
+     *       userToken: '0x20c0...beef',
+     *       validatorToken: '0x20c0...babe',
+     *       amountOut: 100n,
+     *       to: '0xfeed...fede',
+     *     }),
+     *     actions.amm.rebalanceSwap.call({
+     *       userToken: '0x20c0...babe',
+     *       validatorToken: '0x20c0...babe',
+     *       amountOut: 100n,
+     *       to: '0xfeed...fede',
+     *     }),
+     *   ]
+     * })
+     * ```
+     *
+     * @param args - Arguments.
+     * @returns The call.
+     */
+    function call(args) {
+        const { userToken, validatorToken, amountOut, to } = args;
+        return defineCall({
+            address: Addresses.feeManager,
+            abi: Abis.feeAmm,
+            functionName: 'rebalanceSwap',
+            args: [
+                TokenId.toAddress(userToken),
+                TokenId.toAddress(validatorToken),
+                amountOut,
+                to,
+            ],
+        });
+    }
+    rebalanceSwap.call = call;
+    /**
+     * Extracts the `RebalanceSwap` event from logs.
+     *
+     * @param logs - The logs.
+     * @returns The `RebalanceSwap` event.
+     */
+    function extractEvent(logs) {
+        const [log] = parseEventLogs({
+            abi: Abis.feeAmm,
+            logs,
+            eventName: 'RebalanceSwap',
+            strict: true,
+        });
+        if (!log)
+            throw new Error('`RebalanceSwap` event not found.');
+        return log;
+    }
+    rebalanceSwap.extractEvent = extractEvent;
+})(rebalanceSwap || (rebalanceSwap = {}));
+/**
+ * Performs a rebalance swap from validator token to user token.
+ *
+ * @example
+ * ```ts
+ * import { createClient, http } from 'viem'
+ * import { tempo } from 'tempo.ts/chains'
+ * import { Actions } from 'tempo.ts/viem'
+ * import { privateKeyToAccount } from 'viem/accounts'
+ *
+ * const client = createClient({
+ *   account: privateKeyToAccount('0x...'),
+ *   chain: tempo({ feeToken: '0x20c0000000000000000000000000000000000001' })
+ *   transport: http(),
+ * })
+ *
+ * const result = await Actions.amm.rebalanceSwapSync(client, {
+ *   userToken: '0x...',
+ *   validatorToken: '0x...',
+ *   amountOut: 100n,
+ *   to: '0x...',
+ * })
+ * ```
+ *
+ * @param client - Client.
+ * @param parameters - Parameters.
+ * @returns The transaction receipt and event data.
+ */
+export async function rebalanceSwapSync(client, parameters) {
+    const { throwOnReceiptRevert = true, ...rest } = parameters;
+    const receipt = await rebalanceSwap.inner(writeContractSync, client, {
+        ...rest,
+        throwOnReceiptRevert,
+    });
+    const { args } = rebalanceSwap.extractEvent(receipt.logs);
+    return {
+        ...args,
+        receipt,
+    };
+}
+/**
+ * Adds liquidity to a pool.
+ *
+ * @example
+ * ```ts
+ * import { createClient, http } from 'viem'
+ * import { tempo } from 'tempo.ts/chains'
+ * import { Actions } from 'tempo.ts/viem'
+ * import { privateKeyToAccount } from 'viem/accounts'
+ *
+ * const client = createClient({
+ *   account: privateKeyToAccount('0x...'),
+ *   chain: tempo({ feeToken: '0x20c0000000000000000000000000000000000001' })
+ *   transport: http(),
+ * })
+ *
+ * const hash = await Actions.amm.mint(client, {
+ *   userTokenAddress: '0x20c0...beef',
+ *   validatorTokenAddress: '0x20c0...babe',
+ *   validatorTokenAmount: 100n,
+ *   to: '0xfeed...fede',
+ * })
+ * ```
+ *
+ * @param client - Client.
+ * @param parameters - Parameters.
+ * @returns The transaction hash.
+ */
+export async function mint(client, parameters) {
+    return mint.inner(writeContract, client, parameters);
+}
+(function (mint) {
+    /** @internal */
+    async function inner(action, client, parameters) {
+        const { to, userTokenAddress, validatorTokenAddress, validatorTokenAmount, ...rest } = parameters;
+        const call = mint.call({
+            to,
+            userTokenAddress,
+            validatorTokenAddress,
+            validatorTokenAmount,
+        });
+        return (await action(client, {
+            ...rest,
+            ...call,
+        }));
+    }
+    mint.inner = inner;
+    /**
+     * Defines a call to the `mint` function.
+     *
+     * Can be passed as a parameter to:
+     * - [`estimateContractGas`](https://viem.sh/docs/contract/estimateContractGas): estimate the gas cost of the call
+     * - [`simulateContract`](https://viem.sh/docs/contract/simulateContract): simulate the call
+     * - [`sendCalls`](https://viem.sh/docs/actions/wallet/sendCalls): send multiple calls
+     *
+     * @example
+     * ```ts
+     * import { createClient, http, walletActions } from 'viem'
+     * import { tempo } from 'tempo.ts/chains'
+     * import { Actions } from 'tempo.ts/viem'
+     *
+     * const client = createClient({
+     *   chain: tempo({ feeToken: '0x20c0000000000000000000000000000000000001' })
+     *   transport: http(),
+     * }).extend(walletActions)
+     *
+     * const { result } = await client.sendCalls({
+     *   calls: [
+     *     actions.amm.mint.call({
+     *       userTokenAddress: '0x20c0...beef',
+     *       validatorTokenAddress: '0x20c0...babe',
+     *       validatorTokenAmount: 100n,
+     *       to: '0xfeed...fede',
+     *     }),
+     *     actions.amm.mint.call({
+     *       userTokenAddress: '0x20c0...babe',
+     *       validatorTokenAddress: '0x20c0...babe',
+     *       validatorTokenAmount: 100n,
+     *       to: '0xfeed...fede',
+     *     }),
+     *   ]
+     * })
+     * ```
+     *
+     * @param args - Arguments.
+     * @returns The call.
+     */
+    function call(args) {
+        const { to, userTokenAddress, validatorTokenAddress, validatorTokenAmount, } = args;
+        return defineCall({
+            address: Addresses.feeManager,
+            abi: Abis.feeAmm,
+            functionName: 'mintWithValidatorToken',
+            args: [
+                TokenId.toAddress(userTokenAddress),
+                TokenId.toAddress(validatorTokenAddress),
+                validatorTokenAmount,
+                to,
+            ],
+        });
+    }
+    mint.call = call;
+    /**
+     * Extracts the `Mint` event from logs.
+     *
+     * @param logs - The logs.
+     * @returns The `Mint` event.
+     */
+    function extractEvent(logs) {
+        const [log] = parseEventLogs({
+            abi: Abis.feeAmm,
+            logs,
+            eventName: 'Mint',
+            strict: true,
+        });
+        if (!log)
+            throw new Error('`Mint` event not found.');
+        return log;
+    }
+    mint.extractEvent = extractEvent;
+})(mint || (mint = {}));
+/**
+ * Adds liquidity to a pool.
+ *
+ * @example
+ * ```ts
+ * import { createClient, http } from 'viem'
+ * import { tempo } from 'tempo.ts/chains'
+ * import { Actions } from 'tempo.ts/viem'
+ * import { privateKeyToAccount } from 'viem/accounts'
+ *
+ * const client = createClient({
+ *   account: privateKeyToAccount('0x...'),
+ *   chain: tempo({ feeToken: '0x20c0000000000000000000000000000000000001' })
+ *   transport: http(),
+ * })
+ *
+ * const hash = await Actions.amm.mint(client, {
+ *   userTokenAddress: '0x20c0...beef',
+ *   validatorTokenAddress: '0x20c0...babe',
+ *   validatorTokenAmount: 100n,
+ *   to: '0xfeed...fede',
+ * })
+ * ```
+ *
+ * @param client - Client.
+ * @param parameters - Parameters.
+ * @returns The transaction receipt and event data.
+ */
+export async function mintSync(client, parameters) {
+    const { throwOnReceiptRevert = true, ...rest } = parameters;
+    const receipt = await mint.inner(writeContractSync, client, {
+        ...rest,
+        throwOnReceiptRevert,
+    });
+    const { args } = mint.extractEvent(receipt.logs);
+    return {
+        ...args,
+        receipt,
+    };
+}
+/**
+ * Removes liquidity from a pool.
+ *
+ * @example
+ * ```ts
+ * import { createClient, http } from 'viem'
+ * import { tempo } from 'tempo.ts/chains'
+ * import { Actions } from 'tempo.ts/viem'
+ * import { privateKeyToAccount } from 'viem/accounts'
+ *
+ * const client = createClient({
+ *   account: privateKeyToAccount('0x...'),
+ *   chain: tempo({ feeToken: '0x20c0000000000000000000000000000000000001' })
+ *   transport: http(),
+ * })
+ *
+ * const hash = await Actions.amm.burn(client, {
+ *   userToken: '0x20c0...beef',
+ *   validatorToken: '0x20c0...babe',
+ *   liquidity: 50n,
+ *   to: '0xfeed...fede',
+ * })
+ * ```
+ *
+ * @param client - Client.
+ * @param parameters - Parameters.
+ * @returns The transaction hash.
+ */
+export async function burn(client, parameters) {
+    return burn.inner(writeContract, client, parameters);
+}
+(function (burn) {
+    /** @internal */
+    async function inner(action, client, parameters) {
+        const { liquidity, to, userToken, validatorToken, ...rest } = parameters;
+        const call = burn.call({ liquidity, to, userToken, validatorToken });
+        return (await action(client, {
+            ...rest,
+            ...call,
+        }));
+    }
+    burn.inner = inner;
+    /**
+     * Defines a call to the `burn` function.
+     *
+     * Can be passed as a parameter to:
+     * - [`estimateContractGas`](https://viem.sh/docs/contract/estimateContractGas): estimate the gas cost of the call
+     * - [`simulateContract`](https://viem.sh/docs/contract/simulateContract): simulate the call
+     * - [`sendCalls`](https://viem.sh/docs/actions/wallet/sendCalls): send multiple calls
+     *
+     * @example
+     * ```ts
+     * import { createClient, http, walletActions } from 'viem'
+     * import { tempo } from 'tempo.ts/chains'
+     * import { Actions } from 'tempo.ts/viem'
+     *
+     * const client = createClient({
+     *   chain: tempo({ feeToken: '0x20c0000000000000000000000000000000000001' })
+     *   transport: http(),
+     * }).extend(walletActions)
+     *
+     * const { result } = await client.sendCalls({
+     *   calls: [
+     *     actions.amm.burn.call({
+     *       liquidity: 100n,
+     *       to: '0xfeed...fede',
+     *       userToken: '0x20c0...beef',
+     *       validatorToken: '0x20c0...babe',
+     *     }),
+     *     actions.amm.burn.call({
+     *       liquidity: 100n,
+     *       to: '0xfeed...fede',
+     *       userToken: '0x20c0...babe',
+     *       validatorToken: '0x20c0...babe',
+     *     }),
+     *   ]
+     * })
+     * ```
+     *
+     * @param args - Arguments.
+     * @returns The call.
+     */
+    function call(args) {
+        const { liquidity, to, userToken, validatorToken } = args;
+        return defineCall({
+            address: Addresses.feeManager,
+            abi: Abis.feeAmm,
+            functionName: 'burn',
+            args: [
+                TokenId.toAddress(userToken),
+                TokenId.toAddress(validatorToken),
+                liquidity,
+                to,
+            ],
+        });
+    }
+    burn.call = call;
+    /**
+     * Extracts the `Burn` event from logs.
+     *
+     * @param logs - The logs.
+     * @returns The `Burn` event.
+     */
+    function extractEvent(logs) {
+        const [log] = parseEventLogs({
+            abi: Abis.feeAmm,
+            logs,
+            eventName: 'Burn',
+            strict: true,
+        });
+        if (!log)
+            throw new Error('`Burn` event not found.');
+        return log;
+    }
+    burn.extractEvent = extractEvent;
+})(burn || (burn = {}));
+/**
+ * Removes liquidity from a pool.
+ *
+ * @example
+ * ```ts
+ * import { createClient, http } from 'viem'
+ * import { tempo } from 'tempo.ts/chains'
+ * import { Actions } from 'tempo.ts/viem'
+ * import { privateKeyToAccount } from 'viem/accounts'
+ *
+ * const client = createClient({
+ *   account: privateKeyToAccount('0x...'),
+ *   chain: tempo({ feeToken: '0x20c0000000000000000000000000000000000001' })
+ *   transport: http(),
+ * })
+ *
+ * const result = await Actions.amm.burnSync(client, {
+ *   userToken: '0x20c0...beef',
+ *   validatorToken: '0x20c0...babe',
+ *   liquidity: 50n,
+ *   to: '0xfeed...fede',
+ * })
+ * ```
+ *
+ * @param client - Client.
+ * @param parameters - Parameters.
+ * @returns The transaction receipt and event data.
+ */
+export async function burnSync(client, parameters) {
+    const { throwOnReceiptRevert = true, ...rest } = parameters;
+    const receipt = await burn.inner(writeContractSync, client, {
+        ...rest,
+        throwOnReceiptRevert,
+    });
+    const { args } = burn.extractEvent(receipt.logs);
+    return {
+        ...args,
+        receipt,
+    };
+}
+/**
+ * Watches for rebalance swap events.
+ *
+ * @example
+ * ```ts
+ * import { createClient, http } from 'viem'
+ * import { tempo } from 'tempo.ts/chains'
+ * import { Actions } from 'tempo.ts/viem'
+ *
+ * const client = createClient({
+ *   chain: tempo({ feeToken: '0x20c0000000000000000000000000000000000001' })
+ *   transport: http(),
+ * })
+ *
+ * const unwatch = actions.amm.watchRebalanceSwap(client, {
+ *   onRebalanceSwap: (args, log) => {
+ *     console.log('Rebalance swap:', args)
+ *   },
+ * })
+ * ```
+ *
+ * @param client - Client.
+ * @param parameters - Parameters.
+ * @returns A function to unsubscribe from the event.
+ */
+export function watchRebalanceSwap(client, parameters) {
+    const { onRebalanceSwap, userToken, validatorToken, ...rest } = parameters;
+    return watchContractEvent(client, {
+        ...rest,
+        address: Addresses.feeManager,
+        abi: Abis.feeAmm,
+        eventName: 'RebalanceSwap',
+        args: userToken !== undefined && validatorToken !== undefined
+            ? {
+                userToken: TokenId.toAddress(userToken),
+                validatorToken: TokenId.toAddress(validatorToken),
+            }
+            : undefined,
+        onLogs: (logs) => {
+            for (const log of logs)
+                onRebalanceSwap(log.args, log);
+        },
+        strict: true,
+    });
+}
+/**
+ * Watches for fee swap events.
+ *
+ * @example
+ * ```ts
+ * import { createClient, http } from 'viem'
+ * import { tempo } from 'tempo.ts/chains'
+ * import { Actions } from 'tempo.ts/viem'
+ *
+ * const client = createClient({
+ *   chain: tempo({ feeToken: '0x20c0000000000000000000000000000000000001' })
+ *   transport: http(),
+ * })
+ *
+ * const unwatch = actions.amm.watchFeeSwap(client, {
+ *   onFeeSwap: (args, log) => {
+ *     console.log('Fee swap:', args)
+ *   },
+ * })
+ * ```
+ *
+ * @param client - Client.
+ * @param parameters - Parameters.
+ * @returns A function to unsubscribe from the event.
+ */
+export function watchFeeSwap(client, parameters) {
+    const { onFeeSwap, userToken, validatorToken, ...rest } = parameters;
+    return watchContractEvent(client, {
+        ...rest,
+        address: Addresses.feeManager,
+        abi: Abis.feeAmm,
+        eventName: 'FeeSwap',
+        args: userToken !== undefined && validatorToken !== undefined
+            ? {
+                userToken: TokenId.toAddress(userToken),
+                validatorToken: TokenId.toAddress(validatorToken),
+            }
+            : undefined,
+        onLogs: (logs) => {
+            for (const log of logs)
+                onFeeSwap(log.args, log);
+        },
+        strict: true,
+    });
+}
+/**
+ * Watches for liquidity mint events.
+ *
+ * @example
+ * ```ts
+ * import { createClient, http } from 'viem'
+ * import { tempo } from 'tempo.ts/chains'
+ * import { Actions } from 'tempo.ts/viem'
+ *
+ * const client = createClient({
+ *   chain: tempo({ feeToken: '0x20c0000000000000000000000000000000000001' })
+ *   transport: http(),
+ * })
+ *
+ * const unwatch = actions.amm.watchMint(client, {
+ *   onMint: (args, log) => {
+ *     console.log('Liquidity added:', args)
+ *   },
+ * })
+ * ```
+ *
+ * @param client - Client.
+ * @param parameters - Parameters.
+ * @returns A function to unsubscribe from the event.
+ */
+export function watchMint(client, parameters) {
+    const { onMint, sender, userToken, validatorToken, ...rest } = parameters;
+    return watchContractEvent(client, {
+        ...rest,
+        address: Addresses.feeManager,
+        abi: Abis.feeAmm,
+        eventName: 'Mint',
+        args: {
+            ...(sender !== undefined && {
+                sender: TokenId.toAddress(sender),
+            }),
+            ...(userToken !== undefined && {
+                userToken: TokenId.toAddress(userToken),
+            }),
+            ...(validatorToken !== undefined && {
+                validatorToken: TokenId.toAddress(validatorToken),
+            }),
+        },
+        onLogs: (logs) => {
+            for (const log of logs)
+                onMint({
+                    liquidity: log.args.liquidity,
+                    sender: log.args.sender,
+                    userToken: {
+                        address: log.args.userToken,
+                        amount: log.args.amountUserToken,
+                    },
+                    validatorToken: {
+                        address: log.args.validatorToken,
+                        amount: log.args.amountValidatorToken,
+                    },
+                }, log);
+        },
+        strict: true,
+    });
+}
+/**
+ * Watches for liquidity burn events.
+ *
+ * @example
+ * ```ts
+ * import { createClient, http } from 'viem'
+ * import { tempo } from 'tempo.ts/chains'
+ * import { Actions } from 'tempo.ts/viem'
+ *
+ * const client = createClient({
+ *   chain: tempo({ feeToken: '0x20c0000000000000000000000000000000000001' })
+ *   transport: http(),
+ * })
+ *
+ * const unwatch = actions.amm.watchBurn(client, {
+ *   onBurn: (args, log) => {
+ *     console.log('Liquidity removed:', args)
+ *   },
+ * })
+ * ```
+ *
+ * @param client - Client.
+ * @param parameters - Parameters.
+ * @returns A function to unsubscribe from the event.
+ */
+export function watchBurn(client, parameters) {
+    const { onBurn, userToken, validatorToken, ...rest } = parameters;
+    return watchContractEvent(client, {
+        ...rest,
+        address: Addresses.feeManager,
+        abi: Abis.feeAmm,
+        eventName: 'Burn',
+        args: userToken !== undefined && validatorToken !== undefined
+            ? {
+                userToken: TokenId.toAddress(userToken),
+                validatorToken: TokenId.toAddress(validatorToken),
+            }
+            : undefined,
+        onLogs: (logs) => {
+            for (const log of logs)
+                onBurn(log.args, log);
+        },
+        strict: true,
+    });
+}
+//# sourceMappingURL=amm.js.map