tempo.ts 0.6.1 → 0.7.0

package/src/viem/Actions/amm.ts

@@ -220,486 +220,7 @@ export namespace 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<
-  chain extends Chain | undefined,
-  account extends Account | undefined,
->(
-  client: Client<Transport, chain, account>,
-  parameters: rebalanceSwap.Parameters<chain, account>,
-): Promise<rebalanceSwap.ReturnValue> {
-  return rebalanceSwap.inner(writeContract, client, parameters)
-}
-
-export namespace rebalanceSwap {
-  export type Parameters<
-    chain extends Chain | undefined = Chain | undefined,
-    account extends Account | undefined = Account | undefined,
-  > = WriteParameters<chain, account> & Args
-
-  export type Args = {
-    /** Amount of user token to receive. */
-    amountOut: bigint
-    /** Address to send the user token to. */
-    to: Address
-    /** Address or ID of the user token. */
-    userToken: TokenId.TokenIdOrAddress
-    /** Address or ID of the validator token. */
-    validatorToken: TokenId.TokenIdOrAddress
-  }
-
-  export type ReturnValue = WriteContractReturnType
-
-  /** @internal */
-  export async function inner<
-    action extends typeof writeContract | typeof writeContractSync,
-    chain extends Chain | undefined,
-    account extends Account | undefined,
-  >(
-    action: action,
-    client: Client<Transport, chain, account>,
-    parameters: rebalanceSwap.Parameters<chain, account>,
-  ): Promise<ReturnType<action>> {
-    const { userToken, validatorToken, amountOut, to, ...rest } = parameters
-    const call = rebalanceSwap.call({
-      userToken,
-      validatorToken,
-      amountOut,
-      to,
-    })
-    return (await action(client, {
-      ...rest,
-      ...call,
-    } as never)) as never
-  }
-
-  /**
-   * 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.
-   */
-  export function call(args: 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,
-      ],
-    })
-  }
-
-  /**
-   * Extracts the `RebalanceSwap` event from logs.
-   *
-   * @param logs - The logs.
-   * @returns The `RebalanceSwap` event.
-   */
-  export function extractEvent(logs: Log[]) {
-    const [log] = parseEventLogs({
-      abi: Abis.feeAmm,
-      logs,
-      eventName: 'RebalanceSwap',
-      strict: true,
-    })
-    if (!log) throw new Error('`RebalanceSwap` event not found.')
-    return log
-  }
-}
-
-/**
- * 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<
-  chain extends Chain | undefined,
-  account extends Account | undefined,
->(
-  client: Client<Transport, chain, account>,
-  parameters: rebalanceSwapSync.Parameters<chain, account>,
-): Promise<rebalanceSwapSync.ReturnValue> {
-  const { throwOnReceiptRevert = true, ...rest } = parameters
-  const receipt = await rebalanceSwap.inner(writeContractSync, client, {
-    ...rest,
-    throwOnReceiptRevert,
-  } as never)
-  const { args } = rebalanceSwap.extractEvent(receipt.logs)
-  return {
-    ...args,
-    receipt,
-  } as never
-}
-
-export namespace rebalanceSwapSync {
-  export type Parameters<
-    chain extends Chain | undefined = Chain | undefined,
-    account extends Account | undefined = Account | undefined,
-  > = rebalanceSwap.Parameters<chain, account>
-
-  export type Args = rebalanceSwap.Args
-
-  export type ReturnValue = Compute<
-    GetEventArgs<
-      typeof Abis.feeAmm,
-      'RebalanceSwap',
-      { IndexedOnly: false; Required: true }
-    > & {
-      /** Transaction receipt. */
-      receipt: TransactionReceipt
-    }
-  >
-}
-
-/**
- * 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, {
- *   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<
-  chain extends Chain | undefined,
-  account extends Account | undefined,
->(
-  client: Client<Transport, chain, account>,
-  parameters: mint.Parameters<chain, account>,
-): Promise<mint.ReturnValue> {
-  return mint.inner(writeContract, client, parameters)
-}
-
-export namespace mint {
-  export type Parameters<
-    chain extends Chain | undefined = Chain | undefined,
-    account extends Account | undefined = Account | undefined,
-  > = WriteParameters<chain, account> & Args
-
-  export type Args = {
-    /** Address to mint LP tokens to. */
-    to: Address
-    /** User token address and amount. */
-    userToken: {
-      /** Address or ID of the user token. */
-      address: TokenId.TokenIdOrAddress
-      /** Amount of user token to add. */
-      amount?: bigint | undefined
-    }
-    /** Validator token address and amount. */
-    validatorToken: {
-      /** Address or ID of the validator token. */
-      address: TokenId.TokenIdOrAddress
-      /** Amount of validator token to add. */
-      amount: bigint
-    }
-  }
-
-  export type ReturnValue = WriteContractReturnType
-
-  /** @internal */
-  export async function inner<
-    action extends typeof writeContract | typeof writeContractSync,
-    chain extends Chain | undefined,
-    account extends Account | undefined,
-  >(
-    action: action,
-    client: Client<Transport, chain, account>,
-    parameters: mint.Parameters<chain, account>,
-  ): Promise<ReturnType<action>> {
-    const { to, userToken, validatorToken, ...rest } = parameters
-    const call = mint.call({ to, userToken, validatorToken })
-    return (await action(client, {
-      ...rest,
-      ...call,
-    } as never)) as never
-  }
-
-  /**
-   * 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({
-   *       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.
-   */
-  export function call(args: Args) {
-    const { to, userToken, validatorToken } = args
-    const callArgs = (() => {
-      if (userToken.amount)
-        return {
-          functionName: 'mint',
-          args: [
-            TokenId.toAddress(userToken.address),
-            TokenId.toAddress(validatorToken.address),
-            userToken.amount,
-            validatorToken.amount,
-            to,
-          ],
-        } as const
-      return {
-        functionName: 'mintWithValidatorToken',
-        args: [
-          TokenId.toAddress(userToken.address),
-          TokenId.toAddress(validatorToken.address),
-          validatorToken.amount,
-          to,
-        ],
-      } as const
-    })()
-    return defineCall({
-      address: Addresses.feeManager,
-      abi: Abis.feeAmm,
-      ...callArgs,
-    })
-  }
-
-  /**
-   * Extracts the `Mint` event from logs.
-   *
-   * @param logs - The logs.
-   * @returns The `Mint` event.
-   */
-  export function extractEvent(logs: Log[]) {
-    const [log] = parseEventLogs({
-      abi: Abis.feeAmm,
-      logs,
-      eventName: 'Mint',
-      strict: true,
-    })
-    if (!log) throw new Error('`Mint` event not found.')
-    return log
-  }
-}
-
-/**
- * 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, {
- *   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<
-  chain extends Chain | undefined,
-  account extends Account | undefined,
->(
-  client: Client<Transport, chain, account>,
-  parameters: mintSync.Parameters<chain, account>,
-): Promise<mintSync.ReturnValue> {
-  const { throwOnReceiptRevert = true, ...rest } = parameters
-  const receipt = await mint.inner(writeContractSync, client, {
-    ...rest,
-    throwOnReceiptRevert,
-  } as never)
-  const { args } = mint.extractEvent(receipt.logs)
-  return {
-    ...args,
-    receipt,
-  } as never
-}
-
-export namespace mintSync {
-  export type Parameters<
-    chain extends Chain | undefined = Chain | undefined,
-    account extends Account | undefined = Account | undefined,
-  > = mint.Parameters<chain, account>
-
-  export type Args = mint.Args
-
-  export type ReturnValue = Compute<
-    GetEventArgs<
-      typeof Abis.feeAmm,
-      'Mint',
-      { IndexedOnly: false; Required: true }
-    > & {
-      /** Transaction receipt. */
-      receipt: TransactionReceipt
-    }
-  >
-}
-
-/**
- * Removes liquidity from a pool.
+ * Adds liquidity to a pool.
  *
  * @example
  * ```ts
@@ -714,10 +235,15 @@ export namespace mintSync {
  *   transport: http(),
  * })
  *
- * const hash = await Actions.amm.burn(client, {
- *   userToken: '0x20c0...beef',
- *   validatorToken: '0x20c0...babe',
- *   liquidity: 50n,
+ * const hash = await Actions.amm.mint(client, {
+ *   userToken: {
+ *     address: '0x20c0...beef',
+ *     amount: 100n,
+ *   },
+ *   validatorToken: {
+ *     address: '0x20c0...babe',
+ *     amount: 100n,
+ *   },
  *   to: '0xfeed...fede',
  * })
  * ```
@@ -726,31 +252,31 @@ export namespace mintSync {
  * @param parameters - Parameters.
  * @returns The transaction hash.
  */
-export async function burn<
+export async function mint<
   chain extends Chain | undefined,
   account extends Account | undefined,
 >(
   client: Client<Transport, chain, account>,
-  parameters: burn.Parameters<chain, account>,
-): Promise<burn.ReturnValue> {
-  return burn.inner(writeContract, client, parameters)
+  parameters: mint.Parameters<chain, account>,
+): Promise<mint.ReturnValue> {
+  return mint.inner(writeContract, client, parameters)
 }
 
-export namespace burn {
+export namespace mint {
   export type Parameters<
     chain extends Chain | undefined = Chain | undefined,
     account extends Account | undefined = Account | undefined,
   > = WriteParameters<chain, account> & Args
 
   export type Args = {
-    /** Amount of LP tokens to burn. */
-    liquidity: bigint
-    /** Address to send tokens to. */
+    /** Address to mint LP tokens to. */
     to: Address
-    /** Address or ID of the user token. */
-    userToken: TokenId.TokenIdOrAddress
-    /** Address or ID of the validator token. */
-    validatorToken: TokenId.TokenIdOrAddress
+    /** User token address. */
+    userTokenAddress: TokenId.TokenIdOrAddress
+    /** Validator token address. */
+    validatorTokenAddress: TokenId.TokenIdOrAddress
+    /** Amount of validator token to add. */
+    validatorTokenAmount: bigint
   }
 
   export type ReturnValue = WriteContractReturnType
@@ -763,10 +289,21 @@ export namespace burn {
   >(
     action: action,
     client: Client<Transport, chain, account>,
-    parameters: burn.Parameters<chain, account>,
+    parameters: mint.Parameters<chain, account>,
   ): Promise<ReturnType<action>> {
-    const { liquidity, to, userToken, validatorToken, ...rest } = parameters
-    const call = burn.call({ liquidity, to, userToken, validatorToken })
+    const {
+      to,
+      userTokenAddress,
+      validatorTokenAddress,
+      validatorTokenAmount,
+      ...rest
+    } = parameters
+    const call = mint.call({
+      to,
+      userTokenAddress,
+      validatorTokenAddress,
+      validatorTokenAmount,
+    })
     return (await action(client, {
       ...rest,
       ...call,
@@ -774,7 +311,7 @@ export namespace burn {
   }
 
   /**
-   * Defines a call to the `burn` function.
+   * 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
@@ -794,17 +331,27 @@ export namespace burn {
    *
    * const { result } = await client.sendCalls({
    *   calls: [
-   *     actions.amm.burn.call({
-   *       liquidity: 100n,
+   *     actions.amm.mint.call({
+   *       userToken: {
+   *         address: '0x20c0...beef',
+   *         amount: 100n,
+   *       },
+   *       validatorToken: {
+   *         address: '0x20c0...babe',
+   *         amount: 100n,
+   *       },
    *       to: '0xfeed...fede',
-   *       userToken: '0x20c0...beef',
-   *       validatorToken: '0x20c0...babe',
    *     }),
-   *     actions.amm.burn.call({
-   *       liquidity: 100n,
+   *     actions.amm.mint.call({
+   *       userToken: {
+   *         address: '0x20c0...babe',
+   *         amount: 100n,
+   *       },
+   *       validatorToken: {
+   *         address: '0x20c0...babe',
+   *         amount: 100n,
+   *       },
    *       to: '0xfeed...fede',
-   *       userToken: '0x20c0...babe',
-   *       validatorToken: '0x20c0...babe',
    *     }),
    *   ]
    * })
@@ -814,40 +361,45 @@ export namespace burn {
    * @returns The call.
    */
   export function call(args: Args) {
-    const { liquidity, to, userToken, validatorToken } = args
+    const {
+      to,
+      userTokenAddress,
+      validatorTokenAddress,
+      validatorTokenAmount,
+    } = args
     return defineCall({
       address: Addresses.feeManager,
       abi: Abis.feeAmm,
-      functionName: 'burn',
+      functionName: 'mintWithValidatorToken',
       args: [
-        TokenId.toAddress(userToken),
-        TokenId.toAddress(validatorToken),
-        liquidity,
+        TokenId.toAddress(userTokenAddress),
+        TokenId.toAddress(validatorTokenAddress),
+        validatorTokenAmount,
         to,
       ],
     })
   }
 
   /**
-   * Extracts the `Burn` event from logs.
+   * Extracts the `Mint` event from logs.
    *
    * @param logs - The logs.
-   * @returns The `Burn` event.
+   * @returns The `Mint` event.
    */
   export function extractEvent(logs: Log[]) {
     const [log] = parseEventLogs({
       abi: Abis.feeAmm,
       logs,
-      eventName: 'Burn',
+      eventName: 'Mint',
       strict: true,
     })
-    if (!log) throw new Error('`Burn` event not found.')
+    if (!log) throw new Error('`Mint` event not found.')
     return log
   }
 }
 
 /**
- * Removes liquidity from a pool.
+ * Adds liquidity to a pool.
  *
  * @example
  * ```ts
@@ -862,10 +414,15 @@ export namespace burn {
  *   transport: http(),
  * })
  *
- * const result = await Actions.amm.burnSync(client, {
- *   userToken: '0x20c0...beef',
- *   validatorToken: '0x20c0...babe',
- *   liquidity: 50n,
+ * const hash = await Actions.amm.mint(client, {
+ *   userToken: {
+ *     address: '0x20c0...beef',
+ *     amount: 100n,
+ *   },
+ *   validatorToken: {
+ *     address: '0x20c0...babe',
+ *     amount: 100n,
+ *   },
  *   to: '0xfeed...fede',
  * })
  * ```
@@ -874,37 +431,37 @@ export namespace burn {
  * @param parameters - Parameters.
  * @returns The transaction receipt and event data.
  */
-export async function burnSync<
+export async function mintSync<
   chain extends Chain | undefined,
   account extends Account | undefined,
 >(
   client: Client<Transport, chain, account>,
-  parameters: burnSync.Parameters<chain, account>,
-): Promise<burnSync.ReturnValue> {
+  parameters: mintSync.Parameters<chain, account>,
+): Promise<mintSync.ReturnValue> {
   const { throwOnReceiptRevert = true, ...rest } = parameters
-  const receipt = await burn.inner(writeContractSync, client, {
+  const receipt = await mint.inner(writeContractSync, client, {
     ...rest,
     throwOnReceiptRevert,
   } as never)
-  const { args } = burn.extractEvent(receipt.logs)
+  const { args } = mint.extractEvent(receipt.logs)
   return {
     ...args,
     receipt,
   } as never
 }
 
-export namespace burnSync {
+export namespace mintSync {
   export type Parameters<
     chain extends Chain | undefined = Chain | undefined,
     account extends Account | undefined = Account | undefined,
-  > = burn.Parameters<chain, account>
+  > = mint.Parameters<chain, account>
 
-  export type Args = burn.Args
+  export type Args = mint.Args
 
   export type ReturnValue = Compute<
     GetEventArgs<
       typeof Abis.feeAmm,
-      'Burn',
+      'Mint',
       { IndexedOnly: false; Required: true }
     > & {
       /** Transaction receipt. */
@@ -913,166 +470,6 @@ export namespace burnSync {
   >
 }
 
-/**
- * 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<
-  chain extends Chain | undefined,
-  account extends Account | undefined,
->(
-  client: Client<Transport, chain, account>,
-  parameters: watchRebalanceSwap.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,
-  })
-}
-
-export declare namespace watchRebalanceSwap {
-  export type Args = GetEventArgs<
-    typeof Abis.feeAmm,
-    'RebalanceSwap',
-    { IndexedOnly: false; Required: true }
-  >
-
-  export type Log = viem_Log<
-    bigint,
-    number,
-    false,
-    ExtractAbiItem<typeof Abis.feeAmm, 'RebalanceSwap'>,
-    true
-  >
-
-  export type Parameters = UnionOmit<
-    WatchContractEventParameters<typeof Abis.feeAmm, 'RebalanceSwap', true>,
-    'abi' | 'address' | 'batch' | 'eventName' | 'onLogs' | 'strict'
-  > & {
-    /** Callback to invoke when a rebalance swap occurs. */
-    onRebalanceSwap: (args: Args, log: Log) => void
-    /** Address or ID of the user token to filter events. */
-    userToken?: TokenId.TokenIdOrAddress | undefined
-    /** Address or ID of the validator token to filter events. */
-    validatorToken?: TokenId.TokenIdOrAddress | undefined
-  }
-}
-
-/**
- * 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<
-  chain extends Chain | undefined,
-  account extends Account | undefined,
->(
-  client: Client<Transport, chain, account>,
-  parameters: watchFeeSwap.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,
-  })
-}
-
-export declare namespace watchFeeSwap {
-  export type Args = GetEventArgs<
-    typeof Abis.feeAmm,
-    'FeeSwap',
-    { IndexedOnly: false; Required: true }
-  >
-
-  export type Log = viem_Log<
-    bigint,
-    number,
-    false,
-    ExtractAbiItem<typeof Abis.feeAmm, 'FeeSwap'>,
-    true
-  >
-
-  export type Parameters = UnionOmit<
-    WatchContractEventParameters<typeof Abis.feeAmm, 'FeeSwap', true>,
-    'abi' | 'address' | 'batch' | 'eventName' | 'onLogs' | 'strict'
-  > & {
-    /** Callback to invoke when a fee swap occurs. */
-    onFeeSwap: (args: Args, log: Log) => void
-    /** Address or ID of the user token to filter events. */
-    userToken?: TokenId.TokenIdOrAddress | undefined
-    /** Address or ID of the validator token to filter events. */
-    validatorToken?: TokenId.TokenIdOrAddress | undefined
-  }
-}
-
 /**
  * Watches for liquidity mint events.
  *
@@ -1177,80 +574,3 @@ export declare namespace watchMint {
     validatorToken?: TokenId.TokenIdOrAddress | undefined
   }
 }
-
-/**
- * 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<
-  chain extends Chain | undefined,
-  account extends Account | undefined,
->(client: Client<Transport, chain, account>, parameters: watchBurn.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,
-  })
-}
-
-export declare namespace watchBurn {
-  export type Args = GetEventArgs<
-    typeof Abis.feeAmm,
-    'Burn',
-    { IndexedOnly: false; Required: true }
-  >
-
-  export type Log = viem_Log<
-    bigint,
-    number,
-    false,
-    ExtractAbiItem<typeof Abis.feeAmm, 'Burn'>,
-    true
-  >
-
-  export type Parameters = UnionOmit<
-    WatchContractEventParameters<typeof Abis.feeAmm, 'Burn', true>,
-    'abi' | 'address' | 'batch' | 'eventName' | 'onLogs' | 'strict'
-  > & {
-    /** Callback to invoke when liquidity is removed. */
-    onBurn: (args: Args, log: Log) => void
-    /** Address or ID of the user token to filter events. */
-    userToken?: TokenId.TokenIdOrAddress | undefined
-    /** Address or ID of the validator token to filter events. */
-    validatorToken?: TokenId.TokenIdOrAddress | undefined
-  }
-}