tempo.ts 0.0.5 → 0.1.0

package/src/viem/{actions → Actions}/amm.test.ts

@@ -1,13 +1,10 @@
 import { setTimeout } from 'node:timers/promises'
-import * as actions from 'tempo.ts/viem/actions'
+import { Abis, Actions, Addresses, createTempoClient } from 'tempo.ts/viem'
 import { parseEther, publicActions } from 'viem'
 import { mnemonicToAccount } from 'viem/accounts'
 import { writeContractSync } from 'viem/actions'
 import { describe, expect, test } from 'vitest'
 import { tempoTest } from '../../../test/viem/config.js'
-import { tip20Abi } from '../abis.js'
-import { usdAddress } from '../addresses.js'
-import { createTempoClient } from '../client.js'
 
 const account = mnemonicToAccount(
   'test test test test test test test test test test test junk',
@@ -25,34 +22,34 @@ const client = createTempoClient({
 
 async function setupPoolWithLiquidity() {
   // Create a new token for testing
-  const { token } = await actions.token.createSync(client, {
+  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, {
+  await Actions.token.grantRolesSync(client, {
     token,
     roles: ['issuer'],
     to: client.account.address,
   })
 
   // Mint some tokens to account
-  await actions.token.mintSync(client, {
+  await Actions.token.mintSync(client, {
     to: account.address,
     amount: parseEther('1000'),
     token,
   })
 
   // Add liquidity to pool
-  await actions.amm.mintSync(client, {
+  await Actions.amm.mintSync(client, {
     userToken: {
       address: token,
       amount: parseEther('100'),
     },
     validatorToken: {
-      address: usdAddress,
+      address: Addresses.defaultFeeToken,
       amount: parseEther('100'),
     },
     to: account.address,
@@ -63,8 +60,8 @@ async function setupPoolWithLiquidity() {
 
 describe('getPoolId', () => {
   test('default', async () => {
-    const poolId = await actions.amm.getPoolId(client, {
-      userToken: usdAddress,
+    const poolId = await Actions.amm.getPoolId(client, {
+      userToken: Addresses.defaultFeeToken,
       validatorToken: '0x20c0000000000000000000000000000000000001',
     })
     expect(poolId).toBeDefined()
@@ -72,7 +69,7 @@ describe('getPoolId', () => {
   })
 
   test('behavior: token id', async () => {
-    const poolId = await actions.amm.getPoolId(client, {
+    const poolId = await Actions.amm.getPoolId(client, {
       userToken: 0n,
       validatorToken: 1n,
     })
@@ -83,8 +80,8 @@ describe('getPoolId', () => {
 
 describe('getPool', () => {
   test('default', async () => {
-    const pool = await actions.amm.getPool(client, {
-      userToken: usdAddress,
+    const pool = await Actions.amm.getPool(client, {
+      userToken: Addresses.defaultFeeToken,
       validatorToken: '0x20c0000000000000000000000000000000000001',
     })
     expect(pool).toMatchObject({
@@ -96,22 +93,22 @@ describe('getPool', () => {
 
 describe('getTotalSupply', () => {
   test('default', async () => {
-    const poolId = await actions.amm.getPoolId(client, {
-      userToken: usdAddress,
+    const poolId = await Actions.amm.getPoolId(client, {
+      userToken: Addresses.defaultFeeToken,
       validatorToken: '0x20c0000000000000000000000000000000000001',
     })
-    const totalSupply = await actions.amm.getTotalSupply(client, { poolId })
+    const totalSupply = await Actions.amm.getTotalSupply(client, { poolId })
     expect(typeof totalSupply).toBe('bigint')
   })
 })
 
 describe('getLiquidityBalance', () => {
   test('default', async () => {
-    const poolId = await actions.amm.getPoolId(client, {
-      userToken: usdAddress,
+    const poolId = await Actions.amm.getPoolId(client, {
+      userToken: Addresses.defaultFeeToken,
       validatorToken: '0x20c0000000000000000000000000000000000001',
     })
-    const balance = await actions.amm.getLiquidityBalance(client, {
+    const balance = await Actions.amm.getLiquidityBalance(client, {
       poolId,
       address: account.address,
     })
@@ -122,28 +119,28 @@ describe('getLiquidityBalance', () => {
 describe('mint', () => {
   test('default', async () => {
     // Create a new token for testing
-    const { token } = await actions.token.createSync(client, {
+    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, {
+    await Actions.token.grantRolesSync(client, {
       token,
       roles: ['issuer'],
       to: client.account.address,
     })
 
     // Mint some tokens to account
-    await actions.token.mintSync(client, {
+    await Actions.token.mintSync(client, {
       to: account.address,
       amount: parseEther('1000'),
       token,
     })
 
     // Add liquidity to pool
-    const { receipt: mintReceipt, ...mintResult } = await actions.amm.mintSync(
+    const { receipt: mintReceipt, ...mintResult } = await Actions.amm.mintSync(
       client,
       {
         userToken: {
@@ -151,7 +148,7 @@ describe('mint', () => {
           amount: parseEther('100'),
         },
         validatorToken: {
-          address: usdAddress,
+          address: Addresses.defaultFeeToken,
           amount: parseEther('100'),
         },
         to: account.address,
@@ -164,25 +161,25 @@ describe('mint', () => {
         "amountValidatorToken": 100000000000000000000n,
         "liquidity": 4999999999999999999999999999999999999000n,
         "sender": "0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266",
-        "userToken": "0x20C0000000000000000000000000000000000001",
-        "validatorToken": "0x20C0000000000000000000000000000000000000",
+        "userToken": "0x20C0000000000000000000000000000000000004",
+        "validatorToken": "0x20C0000000000000000000000000000000000001",
       }
     `)
 
     // Verify pool reserves
-    const pool = await actions.amm.getPool(client, {
+    const pool = await Actions.amm.getPool(client, {
       userToken: token,
-      validatorToken: usdAddress,
+      validatorToken: Addresses.defaultFeeToken,
     })
     expect(pool.reserveUserToken).toBe(parseEther('100'))
     expect(pool.reserveValidatorToken).toBe(parseEther('100'))
 
     // Verify LP token balance
-    const poolId = await actions.amm.getPoolId(client, {
+    const poolId = await Actions.amm.getPoolId(client, {
       userToken: token,
-      validatorToken: usdAddress,
+      validatorToken: Addresses.defaultFeeToken,
     })
-    const lpBalance = await actions.amm.getLiquidityBalance(client, {
+    const lpBalance = await Actions.amm.getLiquidityBalance(client, {
       poolId,
       address: account.address,
     })
@@ -195,21 +192,21 @@ describe('burn', () => {
     const { tokenAddress } = await setupPoolWithLiquidity()
 
     // Get LP balance before burn
-    const poolId = await actions.amm.getPoolId(client, {
+    const poolId = await Actions.amm.getPoolId(client, {
       userToken: tokenAddress,
-      validatorToken: usdAddress,
+      validatorToken: Addresses.defaultFeeToken,
     })
-    const lpBalanceBefore = await actions.amm.getLiquidityBalance(client, {
+    const lpBalanceBefore = await Actions.amm.getLiquidityBalance(client, {
       poolId,
       address: account.address,
     })
 
     // Burn half of LP tokens
-    const { receipt: burnReceipt, ...burnResult } = await actions.amm.burnSync(
+    const { receipt: burnReceipt, ...burnResult } = await Actions.amm.burnSync(
       client,
       {
         userToken: tokenAddress,
-        validatorToken: usdAddress,
+        validatorToken: Addresses.defaultFeeToken,
         liquidity: lpBalanceBefore / 2n,
         to: account.address,
       },
@@ -222,13 +219,13 @@ describe('burn', () => {
         "liquidity": 2499999999999999999999999999999999999500n,
         "sender": "0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266",
         "to": "0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266",
-        "userToken": "0x20C0000000000000000000000000000000000001",
-        "validatorToken": "0x20C0000000000000000000000000000000000000",
+        "userToken": "0x20C0000000000000000000000000000000000004",
+        "validatorToken": "0x20C0000000000000000000000000000000000001",
       }
     `)
 
     // Verify LP balance decreased
-    const lpBalanceAfter = await actions.amm.getLiquidityBalance(client, {
+    const lpBalanceAfter = await Actions.amm.getLiquidityBalance(client, {
       poolId,
       address: account.address,
     })
@@ -236,9 +233,9 @@ describe('burn', () => {
     expect(lpBalanceAfter).toBe(lpBalanceBefore / 2n)
 
     // Verify pool reserves decreased
-    const pool = await actions.amm.getPool(client, {
+    const pool = await Actions.amm.getPool(client, {
       userToken: tokenAddress,
-      validatorToken: usdAddress,
+      validatorToken: Addresses.defaultFeeToken,
     })
     expect(pool.reserveUserToken).toBeLessThan(parseEther('100'))
     expect(pool.reserveValidatorToken).toBeLessThan(parseEther('100'))
@@ -250,16 +247,16 @@ describe('rebalanceSwap', () => {
     const { tokenAddress } = await setupPoolWithLiquidity()
 
     // Get balance before swap
-    const balanceBefore = await actions.token.getBalance(client, {
+    const balanceBefore = await Actions.token.getBalance(client, {
       token: tokenAddress,
       account: account2.address,
     })
 
     // Perform rebalance swap
     const { receipt: swapReceipt, ...swapResult } =
-      await actions.amm.rebalanceSwapSync(client, {
+      await Actions.amm.rebalanceSwapSync(client, {
         userToken: tokenAddress,
-        validatorToken: usdAddress,
+        validatorToken: Addresses.defaultFeeToken,
         amountOut: parseEther('10'),
         to: account2.address,
         account: account,
@@ -270,13 +267,13 @@ describe('rebalanceSwap', () => {
         "amountIn": 9985000000000000001n,
         "amountOut": 10000000000000000000n,
         "swapper": "0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266",
-        "userToken": "0x20C0000000000000000000000000000000000001",
-        "validatorToken": "0x20C0000000000000000000000000000000000000",
+        "userToken": "0x20C0000000000000000000000000000000000004",
+        "validatorToken": "0x20C0000000000000000000000000000000000001",
       }
     `)
 
     // Verify balance increased
-    const balanceAfter = await actions.token.getBalance(client, {
+    const balanceAfter = await Actions.token.getBalance(client, {
       token: tokenAddress,
       account: account2.address,
     })
@@ -289,16 +286,16 @@ describe('watchRebalanceSwap', () => {
     const { tokenAddress } = await setupPoolWithLiquidity()
 
     let eventArgs: any = null
-    const unwatch = actions.amm.watchRebalanceSwap(client, {
+    const unwatch = Actions.amm.watchRebalanceSwap(client, {
       onRebalanceSwap: (args) => {
         eventArgs = args
       },
     })
 
     // Perform rebalance swap
-    await actions.amm.rebalanceSwapSync(client, {
+    await Actions.amm.rebalanceSwapSync(client, {
       userToken: tokenAddress,
-      validatorToken: usdAddress,
+      validatorToken: Addresses.defaultFeeToken,
       amountOut: parseEther('10'),
       to: account2.address,
       account: account,
@@ -309,7 +306,7 @@ describe('watchRebalanceSwap', () => {
     expect(eventArgs).toBeDefined()
     expect(eventArgs.userToken.toLowerCase()).toBe(tokenAddress.toLowerCase())
     expect(eventArgs.validatorToken.toLowerCase()).toBe(
-      usdAddress.toLowerCase(),
+      Addresses.defaultFeeToken.toLowerCase(),
     )
     expect(eventArgs.amountOut).toBe(parseEther('10'))
 
@@ -320,21 +317,21 @@ describe('watchRebalanceSwap', () => {
 describe('watchMint', () => {
   test('default', async () => {
     // Create a new token for testing
-    const { token } = await actions.token.createSync(client, {
+    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, {
+    await Actions.token.grantRolesSync(client, {
       token,
       roles: ['issuer'],
       to: client.account.address,
     })
 
     // Mint some tokens to account
-    await actions.token.mintSync(client, {
+    await Actions.token.mintSync(client, {
       to: account.address,
       amount: parseEther('1000'),
       token,
@@ -342,27 +339,27 @@ describe('watchMint', () => {
 
     // Mint USD to account
     await writeContractSync(client, {
-      abi: tip20Abi,
-      address: usdAddress,
+      abi: Abis.tip20,
+      address: Addresses.defaultFeeToken,
       functionName: 'transfer',
       args: [account.address, parseEther('1000')],
     })
 
     let eventArgs: any = null
-    const unwatch = actions.amm.watchMint(client, {
+    const unwatch = Actions.amm.watchMint(client, {
       onMint: (args) => {
         eventArgs = args
       },
     })
 
     // Add liquidity to pool
-    await actions.amm.mintSync(client, {
+    await Actions.amm.mintSync(client, {
       userToken: {
         address: token,
         amount: parseEther('100'),
       },
       validatorToken: {
-        address: usdAddress,
+        address: Addresses.defaultFeeToken,
         amount: parseEther('100'),
       },
       to: account.address,
@@ -373,7 +370,7 @@ describe('watchMint', () => {
     expect(eventArgs).toBeDefined()
     expect(eventArgs.userToken.address.toLowerCase()).toBe(token.toLowerCase())
     expect(eventArgs.validatorToken.address.toLowerCase()).toBe(
-      usdAddress.toLowerCase(),
+      Addresses.defaultFeeToken.toLowerCase(),
     )
     expect(eventArgs.userToken.amount).toBe(parseEther('100'))
     expect(eventArgs.validatorToken.amount).toBe(parseEther('100'))
@@ -387,26 +384,26 @@ describe('watchBurn', () => {
     const { tokenAddress } = await setupPoolWithLiquidity()
 
     // Get LP balance
-    const poolId = await actions.amm.getPoolId(client, {
+    const poolId = await Actions.amm.getPoolId(client, {
       userToken: tokenAddress,
-      validatorToken: usdAddress,
+      validatorToken: Addresses.defaultFeeToken,
     })
-    const lpBalance = await actions.amm.getLiquidityBalance(client, {
+    const lpBalance = await Actions.amm.getLiquidityBalance(client, {
       poolId,
       address: account.address,
     })
 
     let eventArgs: any = null
-    const unwatch = actions.amm.watchBurn(client, {
+    const unwatch = Actions.amm.watchBurn(client, {
       onBurn: (args) => {
         eventArgs = args
       },
     })
 
     // Burn LP tokens
-    await actions.amm.burnSync(client, {
+    await Actions.amm.burnSync(client, {
       userToken: tokenAddress,
-      validatorToken: usdAddress,
+      validatorToken: Addresses.defaultFeeToken,
       liquidity: lpBalance / 2n,
       to: account.address,
     })
@@ -416,7 +413,7 @@ describe('watchBurn', () => {
     expect(eventArgs).toBeDefined()
     expect(eventArgs.userToken.toLowerCase()).toBe(tokenAddress.toLowerCase())
     expect(eventArgs.validatorToken.toLowerCase()).toBe(
-      usdAddress.toLowerCase(),
+      Addresses.defaultFeeToken.toLowerCase(),
     )
     expect(eventArgs.liquidity).toBe(lpBalance / 2n)