tempo.ts 0.1.5 → 0.2.1

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

@@ -1,116 +1,39 @@
 import { setTimeout } from 'node:timers/promises'
-import { Abis, Actions, Addresses, createTempoClient } from 'tempo.ts/viem'
-import { parseEther, publicActions } from 'viem'
-import { mnemonicToAccount } from 'viem/accounts'
+import { Abis, Actions } from 'tempo.ts/viem'
+import { parseUnits } from 'viem'
 import { writeContractSync } from 'viem/actions'
 import { describe, expect, test } from 'vitest'
-import { tempoTest } from '../../../test/viem/config.js'
-
-const account = mnemonicToAccount(
-  'test test test test test test test test test test test junk',
-)
-const account2 = mnemonicToAccount(
-  'test test test test test test test test test test test junk',
-  { accountIndex: 1 },
-)
-
-const client = createTempoClient({
-  account,
-  chain: tempoTest,
-  pollingInterval: 100,
-}).extend(publicActions)
-
-async function setupPoolWithLiquidity() {
-  // Create a new token for testing
-  const { token } = await Actions.token.createSync(client, {
-    name: 'Test Token',
-    symbol: 'TEST',
-    currency: 'USD',
-  })
-
-  // Grant issuer role to mint tokens
-  await Actions.token.grantRolesSync(client, {
-    token,
-    roles: ['issuer'],
-    to: client.account.address,
-  })
-
-  // Mint some tokens to account
-  await Actions.token.mintSync(client, {
-    to: account.address,
-    amount: parseEther('1000'),
-    token,
-  })
-
-  // Add liquidity to pool
-  await Actions.amm.mintSync(client, {
-    userToken: {
-      address: token,
-      amount: parseEther('100'),
-    },
-    validatorToken: {
-      address: Addresses.defaultFeeToken,
-      amount: parseEther('100'),
-    },
-    to: account.address,
-  })
-
-  return { tokenAddress: token }
-}
+import {
+  accounts,
+  client,
+  setupPoolWithLiquidity,
+} from '../../../test/viem/config.js'
 
-describe('getPoolId', () => {
-  test('default', async () => {
-    const poolId = await Actions.amm.getPoolId(client, {
-      userToken: Addresses.defaultFeeToken,
-      validatorToken: '0x20c0000000000000000000000000000000000001',
-    })
-    expect(poolId).toBeDefined()
-    expect(typeof poolId).toBe('string')
-  })
-
-  test('behavior: token id', async () => {
-    const poolId = await Actions.amm.getPoolId(client, {
-      userToken: 0n,
-      validatorToken: 1n,
-    })
-    expect(poolId).toBeDefined()
-    expect(typeof poolId).toBe('string')
-  })
-})
+const account = accounts[0]
+const account2 = accounts[1]
 
 describe('getPool', () => {
   test('default', async () => {
     const pool = await Actions.amm.getPool(client, {
-      userToken: Addresses.defaultFeeToken,
-      validatorToken: '0x20c0000000000000000000000000000000000001',
-    })
-    expect(pool).toMatchObject({
-      reserveUserToken: expect.any(BigInt),
-      reserveValidatorToken: expect.any(BigInt),
-    })
-  })
-})
-
-describe('getTotalSupply', () => {
-  test('default', async () => {
-    const poolId = await Actions.amm.getPoolId(client, {
-      userToken: Addresses.defaultFeeToken,
+      userToken: 1n,
       validatorToken: '0x20c0000000000000000000000000000000000001',
     })
-    const totalSupply = await Actions.amm.getTotalSupply(client, { poolId })
-    expect(typeof totalSupply).toBe('bigint')
+    expect(pool).toMatchInlineSnapshot(`
+      {
+        "reserveUserToken": 0n,
+        "reserveValidatorToken": 0n,
+        "totalSupply": 0n,
+      }
+    `)
   })
 })
 
 describe('getLiquidityBalance', () => {
   test('default', async () => {
-    const poolId = await Actions.amm.getPoolId(client, {
-      userToken: Addresses.defaultFeeToken,
-      validatorToken: '0x20c0000000000000000000000000000000000001',
-    })
     const balance = await Actions.amm.getLiquidityBalance(client, {
-      poolId,
       address: account.address,
+      userToken: 1n,
+      validatorToken: '0x20c0000000000000000000000000000000000001',
     })
     expect(typeof balance).toBe('bigint')
   })
@@ -135,7 +58,7 @@ describe('mint', () => {
     // Mint some tokens to account
     await Actions.token.mintSync(client, {
       to: account.address,
-      amount: parseEther('1000'),
+      amount: parseUnits('1000', 6),
       token,
     })
 
@@ -145,11 +68,11 @@ describe('mint', () => {
       {
         userToken: {
           address: token,
-          amount: parseEther('100'),
+          amount: parseUnits('100', 6),
         },
         validatorToken: {
-          address: Addresses.defaultFeeToken,
-          amount: parseEther('100'),
+          address: 1n,
+          amount: parseUnits('100', 6),
         },
         to: account.address,
       },
@@ -157,9 +80,9 @@ describe('mint', () => {
     expect(mintReceipt).toBeDefined()
     expect(mintResult).toMatchInlineSnapshot(`
       {
-        "amountUserToken": 100000000000000000000n,
-        "amountValidatorToken": 100000000000000000000n,
-        "liquidity": 4999999999999999999999999999999999999000n,
+        "amountUserToken": 100000000n,
+        "amountValidatorToken": 100000000n,
+        "liquidity": 4999999999999000n,
         "sender": "0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266",
         "userToken": "0x20C0000000000000000000000000000000000004",
         "validatorToken": "0x20C0000000000000000000000000000000000001",
@@ -169,65 +92,141 @@ describe('mint', () => {
     // Verify pool reserves
     const pool = await Actions.amm.getPool(client, {
       userToken: token,
-      validatorToken: Addresses.defaultFeeToken,
+      validatorToken: 1n,
     })
-    expect(pool.reserveUserToken).toBe(parseEther('100'))
-    expect(pool.reserveValidatorToken).toBe(parseEther('100'))
+    expect(pool).toMatchInlineSnapshot(`
+      {
+        "reserveUserToken": 100000000n,
+        "reserveValidatorToken": 100000000n,
+        "totalSupply": 5000000000000000n,
+      }
+    `)
 
     // Verify LP token balance
-    const poolId = await Actions.amm.getPoolId(client, {
-      userToken: token,
-      validatorToken: Addresses.defaultFeeToken,
-    })
     const lpBalance = await Actions.amm.getLiquidityBalance(client, {
-      poolId,
       address: account.address,
+      userToken: token,
+      validatorToken: 1n,
     })
     expect(lpBalance).toBeGreaterThan(0n)
   })
+
+  test('behavior: single-sided mint (mintWithValidatorToken)', async () => {
+    // Create a new token for testing
+    const { token } = await Actions.token.createSync(client, {
+      name: 'Test Token 2',
+      symbol: 'TEST2',
+      currency: 'USD',
+    })
+
+    // Grant issuer role to mint tokens
+    await Actions.token.grantRolesSync(client, {
+      token,
+      roles: ['issuer'],
+      to: client.account.address,
+    })
+
+    // Mint some tokens to account
+    await Actions.token.mintSync(client, {
+      to: account.address,
+      amount: parseUnits('1000', 6),
+      token,
+    })
+
+    // First, establish initial liquidity with two-sided mint
+    await Actions.amm.mintSync(client, {
+      userToken: {
+        address: token,
+        amount: parseUnits('100', 6),
+      },
+      validatorToken: {
+        address: 1n,
+        amount: parseUnits('100', 6),
+      },
+      to: account.address,
+    })
+
+    // Get initial pool state
+    const poolBefore = await Actions.amm.getPool(client, {
+      userToken: token,
+      validatorToken: 1n,
+    })
+
+    // Add single-sided liquidity (only validatorToken)
+    const { receipt: mintReceipt, ...mintResult } = await Actions.amm.mintSync(
+      client,
+      {
+        userToken: {
+          address: token,
+        },
+        validatorToken: {
+          address: 1n,
+          amount: parseUnits('50', 6),
+        },
+        to: account.address,
+      },
+    )
+
+    expect(mintReceipt).toBeDefined()
+    // amountUserToken should be 0 for single-sided mint
+    expect(mintResult.amountUserToken).toBe(0n)
+    expect(mintResult.amountValidatorToken).toBe(parseUnits('50', 6))
+    expect(mintResult.liquidity).toBeGreaterThan(0n)
+
+    // Verify pool reserves - only validatorToken should increase
+    const poolAfter = await Actions.amm.getPool(client, {
+      userToken: token,
+      validatorToken: 1n,
+    })
+
+    expect(poolAfter.reserveUserToken).toBe(poolBefore.reserveUserToken)
+    expect(poolAfter.reserveValidatorToken).toBe(
+      poolBefore.reserveValidatorToken + parseUnits('50', 6),
+    )
+    expect(poolAfter.totalSupply).toBeGreaterThan(poolBefore.totalSupply)
+  })
 })
 
 describe('burn', () => {
   test('default', async () => {
-    const { tokenAddress } = await setupPoolWithLiquidity()
+    const { tokenAddress } = await setupPoolWithLiquidity(client)
 
     // Get LP balance before burn
-    const poolId = await Actions.amm.getPoolId(client, {
-      userToken: tokenAddress,
-      validatorToken: Addresses.defaultFeeToken,
-    })
     const lpBalanceBefore = await Actions.amm.getLiquidityBalance(client, {
-      poolId,
       address: account.address,
+      userToken: tokenAddress,
+      validatorToken: 1n,
     })
 
     // Burn half of LP tokens
-    const { receipt: burnReceipt, ...burnResult } = await Actions.amm.burnSync(
-      client,
-      {
-        userToken: tokenAddress,
-        validatorToken: Addresses.defaultFeeToken,
-        liquidity: lpBalanceBefore / 2n,
-        to: account.address,
-      },
-    )
+    const {
+      receipt: burnReceipt,
+      userToken,
+      ...burnResult
+    } = await Actions.amm.burnSync(client, {
+      userToken: tokenAddress,
+      validatorToken: 1n,
+      liquidity: lpBalanceBefore / 2n,
+      to: account.address,
+    })
     expect(burnReceipt).toBeDefined()
+    expect(userToken).toBe(tokenAddress)
     expect(burnResult).toMatchInlineSnapshot(`
       {
-        "amountUserToken": 49999999999999999999n,
-        "amountValidatorToken": 49999999999999999999n,
-        "liquidity": 2499999999999999999999999999999999999500n,
+        "amountUserToken": 49999999n,
+        "amountValidatorToken": 49999999n,
+        "liquidity": 2499999999999500n,
         "sender": "0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266",
         "to": "0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266",
-        "userToken": "0x20C0000000000000000000000000000000000004",
         "validatorToken": "0x20C0000000000000000000000000000000000001",
       }
     `)
 
     // Verify LP balance decreased
     const lpBalanceAfter = await Actions.amm.getLiquidityBalance(client, {
-      poolId,
       address: account.address,
+      userToken: tokenAddress,
+      validatorToken: 1n,
     })
     expect(lpBalanceAfter).toBeLessThan(lpBalanceBefore)
     expect(lpBalanceAfter).toBe(lpBalanceBefore / 2n)
@@ -235,16 +234,21 @@ describe('burn', () => {
     // Verify pool reserves decreased
     const pool = await Actions.amm.getPool(client, {
       userToken: tokenAddress,
-      validatorToken: Addresses.defaultFeeToken,
+      validatorToken: 1n,
     })
-    expect(pool.reserveUserToken).toBeLessThan(parseEther('100'))
-    expect(pool.reserveValidatorToken).toBeLessThan(parseEther('100'))
+    expect(pool).toMatchInlineSnapshot(`
+      {
+        "reserveUserToken": 50000001n,
+        "reserveValidatorToken": 50000001n,
+        "totalSupply": 2500000000000500n,
+      }
+    `)
   })
 })
 
 describe('rebalanceSwap', () => {
   test('default', async () => {
-    const { tokenAddress } = await setupPoolWithLiquidity()
+    const { tokenAddress } = await setupPoolWithLiquidity(client)
 
     // Get balance before swap
     const balanceBefore = await Actions.token.getBalance(client, {
@@ -253,21 +257,24 @@ describe('rebalanceSwap', () => {
     })
 
     // Perform rebalance swap
-    const { receipt: swapReceipt, ...swapResult } =
-      await Actions.amm.rebalanceSwapSync(client, {
-        userToken: tokenAddress,
-        validatorToken: Addresses.defaultFeeToken,
-        amountOut: parseEther('10'),
-        to: account2.address,
-        account: account,
-      })
+    const {
+      receipt: swapReceipt,
+      userToken,
+      ...swapResult
+    } = await Actions.amm.rebalanceSwapSync(client, {
+      userToken: tokenAddress,
+      validatorToken: 1n,
+      amountOut: parseUnits('10', 6),
+      to: account2.address,
+      account: account,
+    })
     expect(swapReceipt).toBeDefined()
+    expect(userToken).toBe(tokenAddress)
     expect(swapResult).toMatchInlineSnapshot(`
       {
-        "amountIn": 9985000000000000001n,
-        "amountOut": 10000000000000000000n,
+        "amountIn": 9985001n,
+        "amountOut": 10000000n,
         "swapper": "0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266",
-        "userToken": "0x20C0000000000000000000000000000000000004",
         "validatorToken": "0x20C0000000000000000000000000000000000001",
       }
     `)
@@ -277,13 +284,13 @@ describe('rebalanceSwap', () => {
       token: tokenAddress,
       account: account2.address,
     })
-    expect(balanceAfter).toBe(balanceBefore + parseEther('10'))
+    expect(balanceAfter).toBe(balanceBefore + parseUnits('10', 6))
   })
 })
 
 describe('watchRebalanceSwap', () => {
   test('default', async () => {
-    const { tokenAddress } = await setupPoolWithLiquidity()
+    const { tokenAddress } = await setupPoolWithLiquidity(client)
 
     let eventArgs: any = null
     const unwatch = Actions.amm.watchRebalanceSwap(client, {
@@ -295,8 +302,8 @@ describe('watchRebalanceSwap', () => {
     // Perform rebalance swap
     await Actions.amm.rebalanceSwapSync(client, {
       userToken: tokenAddress,
-      validatorToken: Addresses.defaultFeeToken,
-      amountOut: parseEther('10'),
+      validatorToken: 1n,
+      amountOut: parseUnits('10', 6),
       to: account2.address,
       account: account,
     })
@@ -306,9 +313,9 @@ describe('watchRebalanceSwap', () => {
     expect(eventArgs).toBeDefined()
     expect(eventArgs.userToken.toLowerCase()).toBe(tokenAddress.toLowerCase())
     expect(eventArgs.validatorToken.toLowerCase()).toBe(
-      Addresses.defaultFeeToken.toLowerCase(),
+      '0x20c0000000000000000000000000000000000001',
     )
-    expect(eventArgs.amountOut).toBe(parseEther('10'))
+    expect(eventArgs.amountOut).toBe(parseUnits('10', 6))
 
     unwatch()
   })
@@ -333,16 +340,16 @@ describe('watchMint', () => {
     // Mint some tokens to account
     await Actions.token.mintSync(client, {
       to: account.address,
-      amount: parseEther('1000'),
+      amount: parseUnits('1000', 6),
       token,
     })
 
     // Mint USD to account
     await writeContractSync(client, {
       abi: Abis.tip20,
-      address: Addresses.defaultFeeToken,
+      address: '0x20c0000000000000000000000000000000000001',
       functionName: 'transfer',
-      args: [account.address, parseEther('1000')],
+      args: [account.address, parseUnits('1000', 6)],
     })
 
     let eventArgs: any = null
@@ -356,11 +363,11 @@ describe('watchMint', () => {
     await Actions.amm.mintSync(client, {
       userToken: {
         address: token,
-        amount: parseEther('100'),
+        amount: parseUnits('100', 6),
       },
       validatorToken: {
-        address: Addresses.defaultFeeToken,
-        amount: parseEther('100'),
+        address: 1n,
+        amount: parseUnits('100', 6),
       },
       to: account.address,
     })
@@ -370,10 +377,10 @@ describe('watchMint', () => {
     expect(eventArgs).toBeDefined()
     expect(eventArgs.userToken.address.toLowerCase()).toBe(token.toLowerCase())
     expect(eventArgs.validatorToken.address.toLowerCase()).toBe(
-      Addresses.defaultFeeToken.toLowerCase(),
+      '0x20c0000000000000000000000000000000000001',
     )
-    expect(eventArgs.userToken.amount).toBe(parseEther('100'))
-    expect(eventArgs.validatorToken.amount).toBe(parseEther('100'))
+    expect(eventArgs.userToken.amount).toBe(parseUnits('100', 6))
+    expect(eventArgs.validatorToken.amount).toBe(parseUnits('100', 6))
 
     unwatch()
   })
@@ -381,15 +388,12 @@ describe('watchMint', () => {
 
 describe('watchBurn', () => {
   test('default', async () => {
-    const { tokenAddress } = await setupPoolWithLiquidity()
+    const { tokenAddress } = await setupPoolWithLiquidity(client)
 
     // Get LP balance
-    const poolId = await Actions.amm.getPoolId(client, {
-      userToken: tokenAddress,
-      validatorToken: Addresses.defaultFeeToken,
-    })
     const lpBalance = await Actions.amm.getLiquidityBalance(client, {
-      poolId,
+      userToken: tokenAddress,
+      validatorToken: 1n,
       address: account.address,
     })
 
@@ -403,7 +407,7 @@ describe('watchBurn', () => {
     // Burn LP tokens
     await Actions.amm.burnSync(client, {
       userToken: tokenAddress,
-      validatorToken: Addresses.defaultFeeToken,
+      validatorToken: 1n,
       liquidity: lpBalance / 2n,
       to: account.address,
     })
@@ -413,7 +417,7 @@ describe('watchBurn', () => {
     expect(eventArgs).toBeDefined()
     expect(eventArgs.userToken.toLowerCase()).toBe(tokenAddress.toLowerCase())
     expect(eventArgs.validatorToken.toLowerCase()).toBe(
-      Addresses.defaultFeeToken.toLowerCase(),
+      '0x20c0000000000000000000000000000000000001',
     )
     expect(eventArgs.liquidity).toBe(lpBalance / 2n)