tempo.ts 0.1.2 → 0.1.3

package/dist/viem/Actions/amm.js

@@ -0,0 +1,900 @@
+import { parseEventLogs, } from 'viem';
+import { readContract, watchContractEvent, writeContract, writeContractSync, } from 'viem/actions';
+import * as TokenId from '../../ox/TokenId.js';
+import * as Abis from '../Abis.js';
+import * as Addresses from '../Addresses.js';
+import { defineCall } from '../internal/utils.js';
+/**
+ * Gets the pool ID for a token pair.
+ *
+ * @example
+ * ```ts
+ * import { createClient, http } from 'viem'
+ * import { tempo } from 'tempo.ts/chains'
+ * import * as actions from 'tempo.ts/viem/actions'
+ *
+ * const client = createClient({
+ *   chain: tempo,
+ *   transport: http(),
+ * })
+ *
+ * const poolId = await actions.amm.getPoolId(client, {
+ *   userToken: '0x...',
+ *   validatorToken: '0x...',
+ * })
+ * ```
+ *
+ * @param client - Client.
+ * @param parameters - Parameters.
+ * @returns The pool ID.
+ */
+export async function getPoolId(client, parameters) {
+    const { userToken, validatorToken, ...rest } = parameters;
+    return readContract(client, {
+        ...rest,
+        ...getPoolId.call({ userToken, validatorToken }),
+    });
+}
+(function (getPoolId) {
+    /**
+     * Defines a call to the `getPoolId` function.
+     *
+     * @param args - Arguments.
+     * @returns The call.
+     */
+    function call(args) {
+        const { userToken, validatorToken } = args;
+        return defineCall({
+            address: Addresses.feeManager,
+            abi: Abis.feeAmm,
+            args: [TokenId.toAddress(userToken), TokenId.toAddress(validatorToken)],
+            functionName: 'getPoolId',
+        });
+    }
+    getPoolId.call = call;
+})(getPoolId || (getPoolId = {}));
+/**
+ * Gets the reserves for a liquidity pool.
+ *
+ * @example
+ * ```ts
+ * import { createClient, http } from 'viem'
+ * import { tempo } from 'tempo.ts/chains'
+ * import * as actions from 'tempo.ts/viem/actions'
+ *
+ * const client = createClient({
+ *   chain: tempo,
+ *   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;
+    return readContract(client, {
+        ...rest,
+        ...getPool.call({ userToken, validatorToken }),
+    });
+}
+(function (getPool) {
+    /**
+     * Defines a call to the `getPool` function.
+     *
+     * @param args - Arguments.
+     * @returns The call.
+     */
+    function call(args) {
+        const { userToken, validatorToken } = args;
+        return defineCall({
+            address: Addresses.feeManager,
+            abi: Abis.feeAmm,
+            args: [TokenId.toAddress(userToken), TokenId.toAddress(validatorToken)],
+            functionName: 'getPool',
+        });
+    }
+    getPool.call = call;
+})(getPool || (getPool = {}));
+/**
+ * Gets the total supply of LP tokens for a pool.
+ *
+ * @example
+ * ```ts
+ * import { createClient, http } from 'viem'
+ * import { tempo } from 'tempo.ts/chains'
+ * import * as actions from 'tempo.ts/viem/actions'
+ *
+ * const client = createClient({
+ *   chain: tempo,
+ *   transport: http(),
+ * })
+ *
+ * const poolId = await actions.amm.getPoolId(client, {
+ *   userToken: '0x...',
+ *   validatorToken: '0x...',
+ * })
+ *
+ * const totalSupply = await actions.amm.getTotalSupply(client, { poolId })
+ * ```
+ *
+ * @param client - Client.
+ * @param parameters - Parameters.
+ * @returns The total supply of LP tokens.
+ */
+export async function getTotalSupply(client, parameters) {
+    const { poolId, ...rest } = parameters;
+    return readContract(client, {
+        ...rest,
+        ...getTotalSupply.call({ poolId }),
+    });
+}
+(function (getTotalSupply) {
+    /**
+     * Defines a call to the `totalSupply` function.
+     *
+     * @param args - Arguments.
+     * @returns The call.
+     */
+    function call(args) {
+        const { poolId } = args;
+        return defineCall({
+            address: Addresses.feeManager,
+            abi: Abis.feeAmm,
+            args: [poolId],
+            functionName: 'totalSupply',
+        });
+    }
+    getTotalSupply.call = call;
+})(getTotalSupply || (getTotalSupply = {}));
+/**
+ * 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 * as actions from 'tempo.ts/viem/actions'
+ *
+ * const client = createClient({
+ *   chain: tempo,
+ *   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, ...rest } = parameters;
+    return readContract(client, {
+        ...rest,
+        ...getLiquidityBalance.call({ address, poolId }),
+    });
+}
+(function (getLiquidityBalance) {
+    /**
+     * Defines a call to the `liquidityBalances` function.
+     *
+     * @param args - Arguments.
+     * @returns The call.
+     */
+    function call(args) {
+        const { address, poolId } = args;
+        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 * as actions from 'tempo.ts/viem/actions'
+ * import { privateKeyToAccount } from 'viem/accounts'
+ *
+ * const client = createClient({
+ *   account: privateKeyToAccount('0x...'),
+ *   chain: tempo,
+ *   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 * as actions from 'tempo.ts/viem/actions'
+     *
+     * const client = createClient({
+     *   chain: tempo,
+     *   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 * as actions from 'tempo.ts/viem/actions'
+ * import { privateKeyToAccount } from 'viem/accounts'
+ *
+ * const client = createClient({
+ *   account: privateKeyToAccount('0x...'),
+ *   chain: tempo,
+ *   transport: http(),
+ * })
+ *
+ * const result = await actions.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 * as actions from 'tempo.ts/viem/actions'
+ * import { privateKeyToAccount } from 'viem/accounts'
+ *
+ * const client = createClient({
+ *   account: privateKeyToAccount('0x...'),
+ *   chain: tempo,
+ *   transport: http(),
+ * })
+ *
+ * const hash = await actions.amm.mint(client, {
+ *   userToken: {
+ *     address: '0x20c0...beef',
+ *     amount: 100n,
+ *   },
+ *   validatorToken: {
+ *     address: '0x20c0...babe',
+ *     amount: 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, userToken, validatorToken, ...rest } = parameters;
+        const call = mint.call({ to, userToken, validatorToken });
+        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 * as actions from 'tempo.ts/viem/actions'
+     *
+     * const client = createClient({
+     *   chain: tempo,
+     *   transport: http(),
+     * }).extend(walletActions)
+     *
+     * const { result } = await client.sendCalls({
+     *   calls: [
+     *     actions.amm.mint.call({
+     *       userToken: {
+     *         address: '0x20c0...beef',
+     *         amount: 100n,
+     *       },
+     *       validatorToken: {
+     *         address: '0x20c0...babe',
+     *         amount: 100n,
+     *       },
+     *       to: '0xfeed...fede',
+     *     }),
+     *     actions.amm.mint.call({
+     *       userToken: {
+     *         address: '0x20c0...babe',
+     *         amount: 100n,
+     *       },
+     *       validatorToken: {
+     *         address: '0x20c0...babe',
+     *         amount: 100n,
+     *       },
+     *       to: '0xfeed...fede',
+     *     }),
+     *   ]
+     * })
+     * ```
+     *
+     * @param args - Arguments.
+     * @returns The call.
+     */
+    function call(args) {
+        const { to, userToken, validatorToken } = args;
+        return defineCall({
+            address: Addresses.feeManager,
+            abi: Abis.feeAmm,
+            functionName: 'mint',
+            args: [
+                TokenId.toAddress(userToken.address),
+                TokenId.toAddress(validatorToken.address),
+                userToken.amount,
+                validatorToken.amount,
+                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 * as actions from 'tempo.ts/viem/actions'
+ * import { privateKeyToAccount } from 'viem/accounts'
+ *
+ * const client = createClient({
+ *   account: privateKeyToAccount('0x...'),
+ *   chain: tempo,
+ *   transport: http(),
+ * })
+ *
+ * const hash = await actions.amm.mint(client, {
+ *   userToken: {
+ *     address: '0x20c0...beef',
+ *     amount: 100n,
+ *   },
+ *   validatorToken: {
+ *     address: '0x20c0...babe',
+ *     amount: 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 * as actions from 'tempo.ts/viem/actions'
+ * import { privateKeyToAccount } from 'viem/accounts'
+ *
+ * const client = createClient({
+ *   account: privateKeyToAccount('0x...'),
+ *   chain: tempo,
+ *   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 * as actions from 'tempo.ts/viem/actions'
+     *
+     * const client = createClient({
+     *   chain: tempo,
+     *   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 * as actions from 'tempo.ts/viem/actions'
+ * import { privateKeyToAccount } from 'viem/accounts'
+ *
+ * const client = createClient({
+ *   account: privateKeyToAccount('0x...'),
+ *   chain: tempo,
+ *   transport: http(),
+ * })
+ *
+ * const result = await actions.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 * as actions from 'tempo.ts/viem/actions'
+ *
+ * const client = createClient({
+ *   chain: tempo,
+ *   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 * as actions from 'tempo.ts/viem/actions'
+ *
+ * const client = createClient({
+ *   chain: tempo,
+ *   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 * as actions from 'tempo.ts/viem/actions'
+ *
+ * const client = createClient({
+ *   chain: tempo,
+ *   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 * as actions from 'tempo.ts/viem/actions'
+ *
+ * const client = createClient({
+ *   chain: tempo,
+ *   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