tempo.ts 0.0.5 → 0.1.0

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

@@ -1,14 +1,13 @@
 import { setTimeout } from 'node:timers/promises'
 import { Hex } from 'ox'
-import * as actions from 'tempo.ts/viem/actions'
+import { Abis, Addresses, TokenIds } from 'tempo.ts/viem'
 import { parseEther, publicActions } from 'viem'
 import { mnemonicToAccount } from 'viem/accounts'
 import { getCode, writeContractSync } from 'viem/actions'
 import { describe, expect, test } from 'vitest'
 import { tempoTest } from '../../../test/viem/config.js'
-import { tip20Abi } from '../abis.js'
-import { usdAddress, usdId } from '../addresses.js'
-import { createTempoClient } from '../client.js'
+import { createTempoClient } from '../Client.js'
+import * as actions from './index.js'
 
 const account = mnemonicToAccount(
   'test test test test test test test test test test test junk',
@@ -56,8 +55,8 @@ describe('approve', () => {
 
     // transfer tokens for gas
     await writeContractSync(client, {
-      abi: tip20Abi,
-      address: usdAddress,
+      abi: Abis.tip20,
+      address: Addresses.defaultFeeToken,
       functionName: 'transfer',
       args: [account2.address, parseEther('1')],
     })
@@ -90,7 +89,7 @@ describe('approve', () => {
       // approve
       const { receipt, ...result } = await actions.token.approveSync(client, {
         amount: parseEther('100'),
-        token: usdAddress,
+        token: Addresses.defaultFeeToken,
         spender: account2.address,
       })
       expect(receipt).toBeDefined()
@@ -106,7 +105,7 @@ describe('approve', () => {
     {
       // check allowance
       const allowance = await actions.token.getAllowance(client, {
-        token: usdAddress,
+        token: Addresses.defaultFeeToken,
         spender: account2.address,
       })
       expect(allowance).toBe(parseEther('100'))
@@ -114,8 +113,8 @@ describe('approve', () => {
 
     // transfer tokens for gas
     await writeContractSync(client, {
-      abi: tip20Abi,
-      address: usdAddress,
+      abi: Abis.tip20,
+      address: Addresses.defaultFeeToken,
       functionName: 'transfer',
       args: [account2.address, parseEther('1')],
     })
@@ -126,14 +125,14 @@ describe('approve', () => {
       account: account2,
       from: account.address,
       to: '0x0000000000000000000000000000000000000001',
-      token: usdAddress,
+      token: Addresses.defaultFeeToken,
     })
 
     {
       // verify updated allowance
       const allowance = await actions.token.getAllowance(client, {
         spender: account2.address,
-        token: usdAddress,
+        token: Addresses.defaultFeeToken,
       })
       expect(allowance).toBe(parseEther('50'))
     }
@@ -141,7 +140,7 @@ describe('approve', () => {
     // verify balance
     const balance = await actions.token.getBalance(client, {
       account: '0x0000000000000000000000000000000000000001',
-      token: usdAddress,
+      token: Addresses.defaultFeeToken,
     })
     expect(balance).toBe(parseEther('50'))
   })
@@ -151,7 +150,7 @@ describe('approve', () => {
       // approve
       const { receipt, ...result } = await actions.token.approveSync(client, {
         amount: parseEther('100'),
-        token: usdId,
+        token: TokenIds.defaultFeeToken,
         spender: account2.address,
       })
       expect(receipt).toBeDefined()
@@ -167,7 +166,7 @@ describe('approve', () => {
     {
       // check allowance
       const allowance = await actions.token.getAllowance(client, {
-        token: usdId,
+        token: TokenIds.defaultFeeToken,
         spender: account2.address,
       })
       expect(allowance).toBe(parseEther('100'))
@@ -175,8 +174,8 @@ describe('approve', () => {
 
     // transfer tokens for gas
     await writeContractSync(client, {
-      abi: tip20Abi,
-      address: usdAddress,
+      abi: Abis.tip20,
+      address: Addresses.defaultFeeToken,
       functionName: 'transfer',
       args: [account2.address, parseEther('1')],
     })
@@ -187,14 +186,14 @@ describe('approve', () => {
       account: account2,
       from: account.address,
       to: '0x0000000000000000000000000000000000000001',
-      token: usdId,
+      token: TokenIds.defaultFeeToken,
     })
 
     {
       // verify updated allowance
       const allowance = await actions.token.getAllowance(client, {
         spender: account2.address,
-        token: usdId,
+        token: TokenIds.defaultFeeToken,
       })
       expect(allowance).toBe(parseEther('50'))
     }
@@ -202,7 +201,7 @@ describe('approve', () => {
     // verify balance
     const balance = await actions.token.getBalance(client, {
       account: '0x0000000000000000000000000000000000000001',
-      token: usdId,
+      token: TokenIds.defaultFeeToken,
     })
     expect(balance).toBe(parseEther('50'))
   })
@@ -217,15 +216,15 @@ describe('create', () => {
     })
 
     expect(result).toMatchInlineSnapshot(`
-        {
-          "admin": "0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266",
-          "currency": "USD",
-          "name": "Test USD",
-          "symbol": "TUSD",
-          "token": "0x20C0000000000000000000000000000000000001",
-          "tokenId": 1n,
-        }
-      `)
+      {
+        "admin": "0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266",
+        "currency": "USD",
+        "name": "Test USD",
+        "symbol": "TUSD",
+        "token": "0x20C0000000000000000000000000000000000004",
+        "tokenId": 4n,
+      }
+    `)
     expect(receipt).toBeDefined()
 
     const code = await getCode(client, {
@@ -239,8 +238,8 @@ describe('getAllowance', () => {
   test('default', async () => {
     // First, approve some allowance
     await writeContractSync(client, {
-      abi: tip20Abi,
-      address: usdAddress,
+      abi: Abis.tip20,
+      address: Addresses.defaultFeeToken,
       functionName: 'approve',
       args: [account2.address, parseEther('50')],
     })
@@ -256,7 +255,7 @@ describe('getAllowance', () => {
     {
       // Test with token address
       const allowance = await actions.token.getAllowance(client, {
-        token: usdAddress,
+        token: Addresses.defaultFeeToken,
         spender: account2.address,
       })
 
@@ -266,7 +265,7 @@ describe('getAllowance', () => {
     {
       // Test with token ID
       const allowance = await actions.token.getAllowance(client, {
-        token: usdId,
+        token: TokenIds.defaultFeeToken,
         spender: account2.address,
       })
 
@@ -286,7 +285,7 @@ describe('getBalance', () => {
     {
       // Test with token address
       const balance = await actions.token.getBalance(client, {
-        token: usdAddress,
+        token: Addresses.defaultFeeToken,
       })
 
       expect(balance).toBeGreaterThan(0n)
@@ -295,7 +294,7 @@ describe('getBalance', () => {
     {
       // Test with token ID & different account
       const balance = await actions.token.getBalance(client, {
-        token: usdId,
+        token: TokenIds.defaultFeeToken,
         account: Hex.random(20),
       })
 
@@ -312,12 +311,13 @@ describe('getMetadata', () => {
       {
         "currency": "USD",
         "decimals": 6,
-        "name": "TestUSD",
+        "name": "AlphaUSD",
         "paused": false,
+        "quoteToken": "0x20C0000000000000000000000000000000000000",
         "supplyCap": 115792089237316195423570985008687907853269984665640564039457584007913129639935n,
-        "symbol": "TestUSD",
-        "totalSupply": 340282366920938463647842048168863727605n,
-        "transferPolicy": "always-allow",
+        "symbol": "AlphaUSD",
+        "totalSupply": 340282366920938463481821351505477763070n,
+        "transferPolicyId": 1n,
       }
     `)
   })
@@ -339,10 +339,11 @@ describe('getMetadata', () => {
         "decimals": 6,
         "name": "Test USD",
         "paused": false,
+        "quoteToken": "0x20C0000000000000000000000000000000000000",
         "supplyCap": 115792089237316195423570985008687907853269984665640564039457584007913129639935n,
         "symbol": "TUSD",
         "totalSupply": 0n,
-        "transferPolicy": "always-allow",
+        "transferPolicyId": 1n,
       }
     `)
   })
@@ -364,10 +365,11 @@ describe('getMetadata', () => {
         "decimals": 6,
         "name": "Test USD",
         "paused": false,
+        "quoteToken": "0x20C0000000000000000000000000000000000000",
         "supplyCap": 115792089237316195423570985008687907853269984665640564039457584007913129639935n,
         "symbol": "TUSD",
         "totalSupply": 0n,
-        "transferPolicy": "always-allow",
+        "transferPolicyId": 1n,
       }
     `)
   })
@@ -573,8 +575,8 @@ describe('transfer', () => {
 
     // Transfer tokens for gas
     await writeContractSync(client, {
-      abi: tip20Abi,
-      address: usdAddress,
+      abi: Abis.tip20,
+      address: Addresses.defaultFeeToken,
       functionName: 'transfer',
       args: [account2.address, parseEther('1')],
     })
@@ -684,8 +686,8 @@ describe('burn', () => {
 
     // Transfer gas to account2
     await writeContractSync(client, {
-      abi: tip20Abi,
-      address: usdAddress,
+      abi: Abis.tip20,
+      address: Addresses.defaultFeeToken,
       functionName: 'transfer',
       args: [account2.address, parseEther('1')],
     })
@@ -748,8 +750,8 @@ describe('pause', () => {
 
     // Transfer gas
     await writeContractSync(client, {
-      abi: tip20Abi,
-      address: usdAddress,
+      abi: Abis.tip20,
+      address: Addresses.defaultFeeToken,
       functionName: 'transfer',
       args: [account2.address, parseEther('1')],
     })
@@ -815,8 +817,8 @@ describe('pause', () => {
 
     // Transfer gas to account2
     await writeContractSync(client, {
-      abi: tip20Abi,
-      address: usdAddress,
+      abi: Abis.tip20,
+      address: Addresses.defaultFeeToken,
       functionName: 'transfer',
       args: [account2.address, parseEther('1')],
     })
@@ -916,8 +918,8 @@ describe('unpause', () => {
 
     // Transfer gas to account2
     await writeContractSync(client, {
-      abi: tip20Abi,
-      address: usdAddress,
+      abi: Abis.tip20,
+      address: Addresses.defaultFeeToken,
       functionName: 'transfer',
       args: [account2.address, parseEther('1')],
     })
@@ -1001,8 +1003,8 @@ describe('unpause', () => {
 
     // Transfer gas to account2
     await writeContractSync(client, {
-      abi: tip20Abi,
-      address: usdAddress,
+      abi: Abis.tip20,
+      address: Addresses.defaultFeeToken,
       functionName: 'transfer',
       args: [account2.address, parseEther('1')],
     })
@@ -1044,15 +1046,15 @@ describe('unpause', () => {
 
     // Transfer gas to both accounts
     await writeContractSync(client, {
-      abi: tip20Abi,
-      address: usdAddress,
+      abi: Abis.tip20,
+      address: Addresses.defaultFeeToken,
       functionName: 'transfer',
       args: [account2.address, parseEther('1')],
     })
 
     await writeContractSync(client, {
-      abi: tip20Abi,
-      address: usdAddress,
+      abi: Abis.tip20,
+      address: Addresses.defaultFeeToken,
       functionName: 'transfer',
       args: [account3.address, parseEther('1')],
     })
@@ -1085,6 +1087,230 @@ describe('unpause', () => {
   })
 })
 
+describe('updateQuoteToken', () => {
+  test('default', async () => {
+    // Create two tokens - one to be the new quote token
+    const { token: quoteTokenAddress } = await actions.token.createSync(
+      client,
+      {
+        currency: 'USD',
+        name: 'Quote Token',
+        symbol: 'LINK',
+      },
+    )
+
+    const { token: address } = await actions.token.createSync(client, {
+      currency: 'USD',
+      name: 'Main Token',
+      symbol: 'MAIN',
+    })
+
+    // Update quote token
+    const { receipt: updateReceipt, ...updateResult } =
+      await actions.token.updateQuoteTokenSync(client, {
+        token: address,
+        quoteToken: quoteTokenAddress,
+      })
+
+    expect(updateReceipt).toBeDefined()
+    expect(updateResult).toMatchInlineSnapshot(`
+      {
+        "newQuoteToken": "0x20C0000000000000000000000000000000000004",
+        "updater": "0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266",
+      }
+    `)
+
+    // Verify the event was emitted with correct quote token
+    expect(updateResult.newQuoteToken).toBe(quoteTokenAddress)
+  })
+
+  test('behavior: requires admin role', async () => {
+    // Create quote token
+    const { token: quoteTokenAddress } = await actions.token.createSync(
+      client,
+      {
+        currency: 'USD',
+        name: 'Quote Token 2',
+        symbol: 'LINK2',
+      },
+    )
+
+    // Create main token where client.account is admin
+    const { token: address } = await actions.token.createSync(client, {
+      currency: 'USD',
+      name: 'Restricted Token',
+      symbol: 'RESTR',
+    })
+
+    // Transfer gas to account2
+    await writeContractSync(client, {
+      abi: Abis.tip20,
+      address: Addresses.defaultFeeToken,
+      functionName: 'transfer',
+      args: [account2.address, parseEther('1')],
+    })
+
+    // Try to update quote token from account2 (not admin) - should fail
+    await expect(
+      actions.token.updateQuoteTokenSync(client, {
+        account: account2,
+        token: address,
+        quoteToken: quoteTokenAddress,
+      }),
+    ).rejects.toThrow()
+  })
+
+  test('behavior: with token ID', async () => {
+    // Create quote token
+    const { token: quoteTokenAddress } = await actions.token.createSync(
+      client,
+      {
+        currency: 'USD',
+        name: 'Quote Token 3',
+        symbol: 'LINK3',
+      },
+    )
+
+    // Create main token using token ID
+    const { tokenId: mainTokenId } = await actions.token.createSync(client, {
+      currency: 'USD',
+      name: 'Main Token ID',
+      symbol: 'MAINID',
+    })
+
+    // Update quote token using token ID for main token, address for quote token
+    const { receipt: updateReceipt, ...updateResult } =
+      await actions.token.updateQuoteTokenSync(client, {
+        token: mainTokenId,
+        quoteToken: quoteTokenAddress,
+      })
+
+    expect(updateReceipt.status).toBe('success')
+    expect(updateResult.updater).toBe(client.account.address)
+  })
+})
+
+describe('finalizeUpdateQuoteToken', () => {
+  test('default', async () => {
+    // Create quote token
+    const { token: quoteTokenAddress } = await actions.token.createSync(
+      client,
+      {
+        currency: 'USD',
+        name: 'Quote Token',
+        symbol: 'LINK',
+      },
+    )
+
+    // Create main token
+    const { token: address } = await actions.token.createSync(client, {
+      currency: 'USD',
+      name: 'Main Token',
+      symbol: 'MAIN',
+    })
+
+    // Update quote token (step 1)
+    await actions.token.updateQuoteTokenSync(client, {
+      token: address,
+      quoteToken: quoteTokenAddress,
+    })
+
+    // Finalize the update (step 2)
+    const { receipt: finalizeReceipt, ...finalizeResult } =
+      await actions.token.finalizeUpdateQuoteTokenSync(client, {
+        token: address,
+      })
+
+    expect(finalizeReceipt).toBeDefined()
+    expect(finalizeResult).toMatchInlineSnapshot(`
+      {
+        "newQuoteToken": "0x20C0000000000000000000000000000000000004",
+        "updater": "0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266",
+      }
+    `)
+
+    // Verify the quote token was updated
+    expect(finalizeResult.newQuoteToken).toBe(quoteTokenAddress)
+
+    // Verify it's reflected in metadata
+    const metadata = await actions.token.getMetadata(client, {
+      token: address,
+    })
+    expect(metadata.quoteToken).toBe(quoteTokenAddress)
+  })
+
+  test('behavior: requires admin role', async () => {
+    // Create quote token
+    const { token: quoteTokenAddress } = await actions.token.createSync(
+      client,
+      {
+        currency: 'USD',
+        name: 'Quote Token 2',
+        symbol: 'LINK2',
+      },
+    )
+
+    // Create main token
+    const { token: address } = await actions.token.createSync(client, {
+      currency: 'USD',
+      name: 'Restricted Token',
+      symbol: 'RESTR',
+    })
+
+    // Update quote token as admin
+    await actions.token.updateQuoteTokenSync(client, {
+      token: address,
+      quoteToken: quoteTokenAddress,
+    })
+
+    // Transfer gas to account2
+    await writeContractSync(client, {
+      abi: Abis.tip20,
+      address: Addresses.defaultFeeToken,
+      functionName: 'transfer',
+      args: [account2.address, parseEther('1')],
+    })
+
+    // Try to finalize as non-admin - should fail
+    await expect(
+      actions.token.finalizeUpdateQuoteTokenSync(client, {
+        account: account2,
+        token: address,
+      }),
+    ).rejects.toThrow()
+  })
+
+  test('behavior: prevents circular references', async () => {
+    // Create token B
+    const { token: tokenBAddress } = await actions.token.createSync(client, {
+      currency: 'USD',
+      name: 'Token B',
+      symbol: 'TKB',
+    })
+
+    // Create token A that links to token B
+    const { token: tokenAAddress } = await actions.token.createSync(client, {
+      currency: 'USD',
+      name: 'Token A',
+      symbol: 'TKA',
+      quoteToken: tokenBAddress,
+    })
+
+    // Try to make token B link to token A (would create A -> B -> A loop)
+    await actions.token.updateQuoteTokenSync(client, {
+      token: tokenBAddress,
+      quoteToken: tokenAAddress,
+    })
+
+    // Finalize should fail due to circular reference detection
+    await expect(
+      actions.token.finalizeUpdateQuoteTokenSync(client, {
+        token: tokenBAddress,
+      }),
+    ).rejects.toThrow()
+  })
+})
+
 describe.todo('setTokenSupplyCap')
 
 describe('hasRole', () => {
@@ -1422,8 +1648,8 @@ describe('watchCreate', () => {
           "currency": "USD",
           "name": "Watch Test Token 1",
           "symbol": "WATCH1",
-          "token": "0x20C0000000000000000000000000000000000001",
-          "tokenId": 1n,
+          "token": "0x20C0000000000000000000000000000000000004",
+          "tokenId": 4n,
         }
       `)
       expect(receivedTokens.at(1)!.args).toMatchInlineSnapshot(`
@@ -1432,8 +1658,8 @@ describe('watchCreate', () => {
           "currency": "USD",
           "name": "Watch Test Token 2",
           "symbol": "WATCH2",
-          "token": "0x20C0000000000000000000000000000000000002",
-          "tokenId": 2n,
+          "token": "0x20c0000000000000000000000000000000000005",
+          "tokenId": 5n,
         }
       `)
     } finally {
@@ -1503,8 +1729,8 @@ describe('watchCreate', () => {
           "currency": "USD",
           "name": "Filtered Watch Token 2",
           "symbol": "FWATCH2",
-          "token": "0x20C0000000000000000000000000000000000003",
-          "tokenId": 3n,
+          "token": "0x20C0000000000000000000000000000000000006",
+          "tokenId": 6n,
         }
       `)
 
@@ -1856,8 +2082,8 @@ describe('watchBurn', () => {
 
       // Transfer gas to account2
       await writeContractSync(client, {
-        abi: tip20Abi,
-        address: usdAddress,
+        abi: Abis.tip20,
+        address: Addresses.defaultFeeToken,
         functionName: 'transfer',
         args: [account2.address, parseEther('1')],
       })
@@ -1950,8 +2176,8 @@ describe('watchBurn', () => {
 
       // Transfer gas to account2
       await writeContractSync(client, {
-        abi: tip20Abi,
-        address: usdAddress,
+        abi: Abis.tip20,
+        address: Addresses.defaultFeeToken,
         functionName: 'transfer',
         args: [account2.address, parseEther('1')],
       })
@@ -2360,3 +2586,116 @@ describe('watchTransfer', () => {
     }
   })
 })
+
+describe('watchUpdateQuoteToken', () => {
+  test('default', async () => {
+    // Create quote token
+    const { token: quoteTokenAddress } = await actions.token.createSync(
+      client,
+      {
+        currency: 'USD',
+        name: 'Watch Quote Token',
+        symbol: 'WLINK',
+      },
+    )
+
+    // Create main token
+    const { token: address } = await actions.token.createSync(client, {
+      currency: 'USD',
+      name: 'Watch Main Token',
+      symbol: 'WMAIN',
+    })
+
+    const receivedUpdates: Array<{
+      args: actions.token.watchUpdateQuoteToken.Args
+      log: actions.token.watchUpdateQuoteToken.Log
+    }> = []
+
+    // Start watching for quote token update events
+    const unwatch = actions.token.watchUpdateQuoteToken(client, {
+      token: address,
+      onUpdateQuoteToken: (args, log) => {
+        receivedUpdates.push({ args, log })
+      },
+    })
+
+    try {
+      // Step 1: Update quote token (should emit UpdateQuoteToken)
+      await actions.token.updateQuoteTokenSync(client, {
+        token: address,
+        quoteToken: quoteTokenAddress,
+      })
+
+      // Step 2: Finalize the update (should emit QuoteTokenUpdateFinalized)
+      await actions.token.finalizeUpdateQuoteTokenSync(client, {
+        token: address,
+      })
+
+      await setTimeout(100)
+
+      // Should receive 2 events: one for update, one for finalized
+      expect(receivedUpdates).toHaveLength(2)
+
+      // First event: update proposed (not finalized)
+      expect(receivedUpdates.at(0)!.args.finalized).toBe(false)
+      expect(receivedUpdates.at(0)!.args.newQuoteToken).toBe(quoteTokenAddress)
+      expect(receivedUpdates.at(0)!.args.updater).toBe(client.account.address)
+
+      // Second event: update finalized
+      expect(receivedUpdates.at(1)!.args.finalized).toBe(true)
+      expect(receivedUpdates.at(1)!.args.newQuoteToken).toBe(quoteTokenAddress)
+      expect(receivedUpdates.at(1)!.args.updater).toBe(client.account.address)
+    } finally {
+      if (unwatch) unwatch()
+    }
+  })
+
+  test('behavior: only proposed updates', async () => {
+    // Create quote token
+    const { token: quoteTokenAddress } = await actions.token.createSync(
+      client,
+      {
+        currency: 'USD',
+        name: 'Proposed Quote Token',
+        symbol: 'PLINK',
+      },
+    )
+
+    // Create main token
+    const { token: address } = await actions.token.createSync(client, {
+      currency: 'USD',
+      name: 'Proposed Main Token',
+      symbol: 'PMAIN',
+    })
+
+    const receivedUpdates: Array<{
+      args: actions.token.watchUpdateQuoteToken.Args
+      log: actions.token.watchUpdateQuoteToken.Log
+    }> = []
+
+    // Start watching
+    const unwatch = actions.token.watchUpdateQuoteToken(client, {
+      token: address,
+      onUpdateQuoteToken: (args, log) => {
+        receivedUpdates.push({ args, log })
+      },
+    })
+
+    try {
+      // Only update (don't finalize)
+      await actions.token.updateQuoteTokenSync(client, {
+        token: address,
+        quoteToken: quoteTokenAddress,
+      })
+
+      await setTimeout(100)
+
+      // Should only receive 1 event (not finalized)
+      expect(receivedUpdates).toHaveLength(1)
+      expect(receivedUpdates.at(0)!.args.finalized).toBe(false)
+      expect(receivedUpdates.at(0)!.args.newQuoteToken).toBe(quoteTokenAddress)
+    } finally {
+      if (unwatch) unwatch()
+    }
+  })
+})