tempo.ts 0.7.5 → 0.7.6

package/src/viem/Decorator.ts

@@ -100,6 +100,66 @@ export type Decorator<
     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.
      *
@@ -117,14 +177,9 @@ export type Decorator<
      * }).extend(tempoActions())
      *
      * const hash = await client.amm.mint({
-     *   userToken: {
-     *     address: '0x...',
-     *     amount: 100n,
-     *   },
-     *   validatorToken: {
-     *     address: '0x...',
-     *     amount: 100n,
-     *   },
+     *   userTokenAddress: '0x...',
+     *   validatorTokenAddress: '0x...',
+     *   validatorTokenAmount: 100n,
      *   to: '0x...',
      * })
      * ```
@@ -152,14 +207,9 @@ export type Decorator<
      * }).extend(tempoActions())
      *
      * const result = await client.amm.mintSync({
-     *   userToken: {
-     *     address: '0x...',
-     *     amount: 100n,
-     *   },
-     *   validatorToken: {
-     *     address: '0x...',
-     *     amount: 100n,
-     *   },
+     *   userTokenAddress: '0x...',
+     *   validatorTokenAddress: '0x...',
+     *   validatorTokenAmount: 100n,
      *   to: '0x...',
      * })
      * ```
@@ -170,6 +220,116 @@ export type Decorator<
     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.
      *
@@ -195,6 +355,33 @@ export type Decorator<
      * @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: {
     /**
@@ -2706,9 +2893,20 @@ export function decorator() {
         getPool: (parameters) => ammActions.getPool(client, parameters),
         getLiquidityBalance: (parameters) =>
           ammActions.getLiquidityBalance(client, parameters),
+        burn: (parameters) => ammActions.burn(client, parameters),
+        burnSync: (parameters) => ammActions.burnSync(client, parameters),
         mint: (parameters) => ammActions.mint(client, parameters),
         mintSync: (parameters) => ammActions.mintSync(client, parameters),
+        rebalanceSwap: (parameters) =>
+          ammActions.rebalanceSwap(client, parameters),
+        rebalanceSwapSync: (parameters) =>
+          ammActions.rebalanceSwapSync(client, parameters),
+        watchBurn: (parameters) => ammActions.watchBurn(client, parameters),
+        watchFeeSwap: (parameters) =>
+          ammActions.watchFeeSwap(client, parameters),
         watchMint: (parameters) => ammActions.watchMint(client, parameters),
+        watchRebalanceSwap: (parameters) =>
+          ammActions.watchRebalanceSwap(client, parameters),
       },
       dex: {
         buy: (parameters) => dexActions.buy(client, parameters),

package/src/wagmi/Actions/amm.test.ts

@@ -1,8 +1,8 @@
-import { connect } from '@wagmi/core'
+import { connect, getConnectorClient } from '@wagmi/core'
 import { parseUnits } from 'viem'
 import { describe, expect, test } from 'vitest'
 import { addresses } from '../../../test/config.js'
-import { accounts } from '../../../test/viem/config.js'
+import { accounts, setupPoolWithLiquidity } from '../../../test/viem/config.js'
 import { config, queryClient } from '../../../test/wagmi/config.js'
 import * as ammActions from './amm.js'
 import * as tokenActions from './token.js'
@@ -115,3 +115,94 @@ describe('mintSync', () => {
     `)
   })
 })
+
+describe('burnSync', () => {
+  test('default', async () => {
+    await connect(config, {
+      connector: config.connectors[0]!,
+    })
+
+    const client = await getConnectorClient(config)
+    const { tokenAddress } = await setupPoolWithLiquidity(client)
+
+    const account2 = accounts[1]
+
+    // Get LP balance before burn
+    const lpBalanceBefore = await ammActions.getLiquidityBalance(config, {
+      userToken: tokenAddress,
+      validatorToken: addresses.alphaUsd,
+      address: account.address,
+    })
+
+    // TODO(TEMPO-1183): Remove this janky fix to get some user token in the pool
+    await tokenActions.transferSync(config, {
+      to: account2.address,
+      amount: 600n,
+      token: tokenAddress,
+      feeToken: tokenAddress,
+    })
+
+    // Burn half of LP tokens
+    const { receipt: burnReceipt, ...burnResult } = await ammActions.burnSync(
+      config,
+      {
+        userToken: tokenAddress,
+        validatorToken: addresses.alphaUsd,
+        liquidity: lpBalanceBefore / 2n,
+        to: account.address,
+      },
+    )
+    expect(burnReceipt).toBeDefined()
+    expect(burnResult).toMatchInlineSnapshot(`
+      {
+        "amountUserToken": 337n,
+        "amountValidatorToken": 49998664n,
+        "liquidity": 24999500n,
+        "sender": "0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266",
+        "to": "0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266",
+        "userToken": "0x20c0000000000000000000000000000000000005",
+        "validatorToken": "0x20C0000000000000000000000000000000000001",
+      }
+    `)
+  })
+})
+
+describe('rebalanceSwapSync', () => {
+  test('default', async () => {
+    await connect(config, {
+      connector: config.connectors[0]!,
+    })
+
+    const client = await getConnectorClient(config)
+    const { tokenAddress } = await setupPoolWithLiquidity(client)
+
+    const account2 = accounts[1]
+
+    // TODO(TEMPO-1183): Remove this janky fix to get some user token in the pool
+    await tokenActions.transferSync(config, {
+      to: account2.address,
+      amount: 600n,
+      token: tokenAddress,
+      feeToken: tokenAddress,
+    })
+
+    // Perform rebalance swap
+    const { receipt: swapReceipt, ...swapResult } =
+      await ammActions.rebalanceSwapSync(config, {
+        userToken: tokenAddress,
+        validatorToken: addresses.alphaUsd,
+        amountOut: 100n,
+        to: account2.address,
+      })
+    expect(swapReceipt).toBeDefined()
+    expect(swapResult).toMatchInlineSnapshot(`
+      {
+        "amountIn": 100n,
+        "amountOut": 100n,
+        "swapper": "0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266",
+        "userToken": "0x20C0000000000000000000000000000000000006",
+        "validatorToken": "0x20C0000000000000000000000000000000000001",
+      }
+    `)
+  })
+})

package/src/wagmi/Actions/amm.ts

@@ -322,14 +322,9 @@ export declare namespace rebalanceSwapSync {
  * })
  *
  * const hash = await Actions.amm.mint(config, {
- *   userToken: {
- *     address: '0x20c0...beef',
- *     amount: 100n,
- *   },
- *   validatorToken: {
- *     address: '0x20c0...babe',
- *     amount: 100n,
- *   },
+ *   userTokenAddress: '0x20c0...beef',
+ *   validatorTokenAddress: '0x20c0...babe',
+ *   validatorTokenAmount: 100n,
  *   to: '0xfeed...fede',
  * })
  * ```
@@ -382,14 +377,9 @@ export declare namespace mint {
  * })
  *
  * const result = await Actions.amm.mintSync(config, {
- *   userToken: {
- *     address: '0x20c0...beef',
- *     amount: 100n,
- *   },
- *   validatorToken: {
- *     address: '0x20c0...babe',
- *     amount: 100n,
- *   },
+ *   userTokenAddress: '0x20c0...beef',
+ *   validatorTokenAddress: '0x20c0...babe',
+ *   validatorTokenAmount: 100n,
  *   to: '0xfeed...fede',
  * })
  * ```