tempo.ts 0.1.5 → 0.2.1

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

@@ -1,31 +1,21 @@
 import { setTimeout } from 'node:timers/promises'
 import { Hex } from 'ox'
+import { TokenRole } from 'tempo.ts/ox'
 import { Abis, Addresses, TokenIds } from 'tempo.ts/viem'
-import { parseEther, publicActions } from 'viem'
-import { mnemonicToAccount } from 'viem/accounts'
+import { parseUnits } from 'viem'
 import { getCode, writeContractSync } from 'viem/actions'
-import { describe, expect, test } from 'vitest'
-import { tempoTest } from '../../../test/viem/config.js'
-import { createTempoClient } from '../Client.js'
+import { beforeAll, describe, expect, test } from 'vitest'
+import {
+  accounts,
+  addresses,
+  client,
+  rpcUrl,
+} from '../../../test/viem/config.js'
 import * as actions from './index.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 account3 = mnemonicToAccount(
-  'test test test test test test test test test test test junk',
-  { accountIndex: 2 },
-)
-
-const client = createTempoClient({
-  account,
-  chain: tempoTest,
-  pollingInterval: 100,
-}).extend(publicActions)
+const account = accounts[0]
+const account2 = accounts[1]
+const account3 = accounts[2]
 
 describe('approve', () => {
   test('default', async () => {
@@ -33,12 +23,13 @@ describe('approve', () => {
       // approve
       const { receipt, ...result } = await actions.token.approveSync(client, {
         spender: account2.address,
-        amount: parseEther('100'),
+        amount: parseUnits('100', 6),
+        token: addresses.alphaUsd,
       })
       expect(receipt).toBeDefined()
       expect(result).toMatchInlineSnapshot(`
         {
-          "amount": 100000000000000000000n,
+          "amount": 100000000n,
           "owner": "0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266",
           "spender": "0x8C8d35429F74ec245F8Ef2f4Fd1e551cFF97d650",
         }
@@ -49,53 +40,62 @@ describe('approve', () => {
       // check allowance
       const allowance = await actions.token.getAllowance(client, {
         spender: account2.address,
+        token: addresses.alphaUsd,
       })
-      expect(allowance).toBe(parseEther('100'))
+      expect(allowance).toBe(parseUnits('100', 6))
     }
 
     // transfer tokens for gas
     await writeContractSync(client, {
       abi: Abis.tip20,
-      address: Addresses.defaultFeeToken,
+      address: addresses.alphaUsd,
       functionName: 'transfer',
-      args: [account2.address, parseEther('1')],
+      args: [account2.address, parseUnits('1', 6)],
     })
 
     // transfer tokens from approved account
     await actions.token.transferSync(client, {
-      amount: parseEther('50'),
+      amount: parseUnits('50', 6),
       account: account2,
       from: account.address,
       to: '0x0000000000000000000000000000000000000001',
+      token: addresses.alphaUsd,
     })
 
     {
       // verify updated allowance
       const allowance = await actions.token.getAllowance(client, {
         spender: account2.address,
+        token: addresses.alphaUsd,
       })
-      expect(allowance).toBe(parseEther('50'))
+      expect(allowance).toBe(parseUnits('50', 6))
     }
 
     // verify balance
     const balance = await actions.token.getBalance(client, {
       account: '0x0000000000000000000000000000000000000001',
+      token: addresses.alphaUsd,
     })
-    expect(balance).toBe(parseEther('50'))
+    expect(balance).toBe(parseUnits('50', 6))
   })
 
   test('behavior: token address', async () => {
+    const balanceBefore = await actions.token.getBalance(client, {
+      account: '0x0000000000000000000000000000000000000001',
+      token: addresses.alphaUsd,
+    })
+
     {
       // approve
       const { receipt, ...result } = await actions.token.approveSync(client, {
-        amount: parseEther('100'),
-        token: Addresses.defaultFeeToken,
+        amount: parseUnits('100', 6),
+        token: addresses.alphaUsd,
         spender: account2.address,
       })
       expect(receipt).toBeDefined()
       expect(result).toMatchInlineSnapshot(`
         {
-          "amount": 100000000000000000000n,
+          "amount": 100000000n,
           "owner": "0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266",
           "spender": "0x8C8d35429F74ec245F8Ef2f4Fd1e551cFF97d650",
         }
@@ -105,58 +105,63 @@ describe('approve', () => {
     {
       // check allowance
       const allowance = await actions.token.getAllowance(client, {
-        token: Addresses.defaultFeeToken,
+        token: addresses.alphaUsd,
         spender: account2.address,
       })
-      expect(allowance).toBe(parseEther('100'))
+      expect(allowance).toBe(parseUnits('100', 6))
     }
 
     // transfer tokens for gas
     await writeContractSync(client, {
       abi: Abis.tip20,
-      address: Addresses.defaultFeeToken,
+      address: addresses.alphaUsd,
       functionName: 'transfer',
-      args: [account2.address, parseEther('1')],
+      args: [account2.address, parseUnits('1', 6)],
     })
 
     // transfer tokens from approved account
     await actions.token.transferSync(client, {
-      amount: parseEther('50'),
+      amount: parseUnits('50', 6),
       account: account2,
       from: account.address,
       to: '0x0000000000000000000000000000000000000001',
-      token: Addresses.defaultFeeToken,
+      token: addresses.alphaUsd,
     })
 
     {
       // verify updated allowance
       const allowance = await actions.token.getAllowance(client, {
         spender: account2.address,
-        token: Addresses.defaultFeeToken,
+        token: addresses.alphaUsd,
       })
-      expect(allowance).toBe(parseEther('50'))
+      expect(allowance).toBe(parseUnits('50', 6))
     }
 
     // verify balance
     const balance = await actions.token.getBalance(client, {
       account: '0x0000000000000000000000000000000000000001',
-      token: Addresses.defaultFeeToken,
+      token: addresses.alphaUsd,
     })
-    expect(balance).toBe(parseEther('50'))
+    expect(balance).toBe(balanceBefore + parseUnits('50', 6))
   })
 
   test('behavior: token address', async () => {
+    const balanceBefore = await actions.token.getBalance(client, {
+      account: '0x0000000000000000000000000000000000000001',
+      token: addresses.alphaUsd,
+    })
+
     {
       // approve
       const { receipt, ...result } = await actions.token.approveSync(client, {
-        amount: parseEther('100'),
-        token: TokenIds.defaultFeeToken,
+        amount: parseUnits('100', 6),
+        token: addresses.alphaUsd,
         spender: account2.address,
       })
       expect(receipt).toBeDefined()
       expect(result).toMatchInlineSnapshot(`
         {
-          "amount": 100000000000000000000n,
+          "amount": 100000000n,
           "owner": "0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266",
           "spender": "0x8C8d35429F74ec245F8Ef2f4Fd1e551cFF97d650",
         }
@@ -166,69 +171,71 @@ describe('approve', () => {
     {
       // check allowance
       const allowance = await actions.token.getAllowance(client, {
-        token: TokenIds.defaultFeeToken,
+        token: addresses.alphaUsd,
         spender: account2.address,
       })
-      expect(allowance).toBe(parseEther('100'))
+      expect(allowance).toBe(parseUnits('100', 6))
     }
 
     // transfer tokens for gas
     await writeContractSync(client, {
       abi: Abis.tip20,
-      address: Addresses.defaultFeeToken,
+      address: addresses.alphaUsd,
       functionName: 'transfer',
-      args: [account2.address, parseEther('1')],
+      args: [account2.address, parseUnits('1', 6)],
     })
 
     // transfer tokens from approved account
     await actions.token.transferSync(client, {
-      amount: parseEther('50'),
+      amount: parseUnits('50', 6),
       account: account2,
       from: account.address,
       to: '0x0000000000000000000000000000000000000001',
-      token: TokenIds.defaultFeeToken,
+      token: addresses.alphaUsd,
     })
 
     {
       // verify updated allowance
       const allowance = await actions.token.getAllowance(client, {
         spender: account2.address,
-        token: TokenIds.defaultFeeToken,
+        token: addresses.alphaUsd,
       })
-      expect(allowance).toBe(parseEther('50'))
+      expect(allowance).toBe(parseUnits('50', 6))
     }
 
     // verify balance
     const balance = await actions.token.getBalance(client, {
       account: '0x0000000000000000000000000000000000000001',
-      token: TokenIds.defaultFeeToken,
+      token: addresses.alphaUsd,
     })
-    expect(balance).toBe(parseEther('50'))
+    expect(balance).toBe(balanceBefore + parseUnits('50', 6))
   })
 })
 
 describe('create', () => {
   test('default', async () => {
-    const { receipt, ...result } = await actions.token.createSync(client, {
-      currency: 'USD',
-      name: 'Test USD',
-      symbol: 'TUSD',
-    })
+    const { receipt, token, tokenId, ...result } =
+      await actions.token.createSync(client, {
+        currency: 'USD',
+        name: 'Test USD',
+        symbol: 'TUSD',
+      })
 
     expect(result).toMatchInlineSnapshot(`
       {
         "admin": "0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266",
         "currency": "USD",
         "name": "Test USD",
+        "quoteToken": "0x20C0000000000000000000000000000000000000",
         "symbol": "TUSD",
-        "token": "0x20C0000000000000000000000000000000000004",
-        "tokenId": 4n,
       }
     `)
+    expect(token).toBeDefined()
+    expect(tokenId).toBeDefined()
     expect(receipt).toBeDefined()
 
     const code = await getCode(client, {
-      address: result.token,
+      address: token,
     })
     expect(code).toBe('0xef')
   })
@@ -239,53 +246,48 @@ describe('getAllowance', () => {
     // First, approve some allowance
     await writeContractSync(client, {
       abi: Abis.tip20,
-      address: Addresses.defaultFeeToken,
+      address: addresses.alphaUsd,
       functionName: 'approve',
-      args: [account2.address, parseEther('50')],
+      args: [account2.address, parseUnits('50', 6)],
     })
 
     {
       // Test with default token
       const allowance = await actions.token.getAllowance(client, {
         spender: account2.address,
+        token: addresses.alphaUsd,
       })
-      expect(allowance).toBe(parseEther('50'))
+      expect(allowance).toBe(parseUnits('50', 6))
     }
 
     {
       // Test with token address
       const allowance = await actions.token.getAllowance(client, {
-        token: Addresses.defaultFeeToken,
+        token: addresses.alphaUsd,
         spender: account2.address,
       })
 
-      expect(allowance).toBe(parseEther('50'))
+      expect(allowance).toBe(parseUnits('50', 6))
     }
 
     {
       // Test with token ID
       const allowance = await actions.token.getAllowance(client, {
-        token: TokenIds.defaultFeeToken,
+        token: addresses.alphaUsd,
         spender: account2.address,
       })
 
-      expect(allowance).toBe(parseEther('50'))
+      expect(allowance).toBe(parseUnits('50', 6))
     }
   })
 })
 
 describe('getBalance', () => {
   test('default', async () => {
-    {
-      // Test with default token
-      const balance = await actions.token.getBalance(client)
-      expect(balance).toBeGreaterThan(0n)
-    }
-
     {
       // Test with token address
       const balance = await actions.token.getBalance(client, {
-        token: Addresses.defaultFeeToken,
+        token: addresses.alphaUsd,
       })
 
       expect(balance).toBeGreaterThan(0n)
@@ -294,7 +296,7 @@ describe('getBalance', () => {
     {
       // Test with token ID & different account
       const balance = await actions.token.getBalance(client, {
-        token: TokenIds.defaultFeeToken,
+        token: addresses.alphaUsd,
         account: Hex.random(20),
       })
 
@@ -305,7 +307,9 @@ describe('getBalance', () => {
 
 describe('getMetadata', () => {
   test('default', async () => {
-    const metadata = await actions.token.getMetadata(client)
+    const metadata = await actions.token.getMetadata(client, {
+      token: addresses.alphaUsd,
+    })
 
     expect(metadata).toMatchInlineSnapshot(`
       {
@@ -314,9 +318,9 @@ describe('getMetadata', () => {
         "name": "AlphaUSD",
         "paused": false,
         "quoteToken": "0x20C0000000000000000000000000000000000000",
-        "supplyCap": 115792089237316195423570985008687907853269984665640564039457584007913129639935n,
+        "supplyCap": 340282366920938463463374607431768211455n,
         "symbol": "AlphaUSD",
-        "totalSupply": 340282366920938463481821351505477763070n,
+        "totalSupply": 36893488147419103230n,
         "transferPolicyId": 1n,
       }
     `)
@@ -351,34 +355,34 @@ describe('getMetadata', () => {
   test('behavior: quote token', async () => {
     {
       const metadata = await actions.token.getMetadata(client, {
-        token: TokenIds.defaultQuoteToken,
+        token: TokenIds.linkingUsd,
       })
 
       expect(metadata).toMatchInlineSnapshot(`
-      {
-        "currency": "USD",
-        "decimals": 6,
-        "name": "linkingUSD",
-        "symbol": "linkingUSD",
-        "totalSupply": 0n,
-      }
-    `)
+        {
+          "currency": "USD",
+          "decimals": 6,
+          "name": "linkingUSD",
+          "symbol": "linkingUSD",
+          "totalSupply": 18446744073709551615n,
+        }
+      `)
     }
 
     {
       const metadata = await actions.token.getMetadata(client, {
-        token: Addresses.defaultQuoteToken,
+        token: Addresses.linkingUsd,
       })
 
       expect(metadata).toMatchInlineSnapshot(`
-      {
-        "currency": "USD",
-        "decimals": 6,
-        "name": "linkingUSD",
-        "symbol": "linkingUSD",
-        "totalSupply": 0n,
-      }
-    `)
+        {
+          "currency": "USD",
+          "decimals": 6,
+          "name": "linkingUSD",
+          "symbol": "linkingUSD",
+          "totalSupply": 18446744073709551615n,
+        }
+      `)
     }
   })
 
@@ -437,12 +441,12 @@ describe('mint', () => {
       await actions.token.mintSync(client, {
         token,
         to: account2.address,
-        amount: parseEther('1000'),
+        amount: parseUnits('1000', 6),
       })
     expect(mintReceipt).toBeDefined()
     expect(mintResult).toMatchInlineSnapshot(`
       {
-        "amount": 1000000000000000000000n,
+        "amount": 1000000000n,
         "to": "0x8C8d35429F74ec245F8Ef2f4Fd1e551cFF97d650",
       }
     `)
@@ -452,13 +456,13 @@ describe('mint', () => {
       token,
       account: account2.address,
     })
-    expect(balanceAfter).toBe(parseEther('1000'))
+    expect(balanceAfter).toBe(parseUnits('1000', 6))
 
     // Check total supply
     const metadata = await actions.token.getMetadata(client, {
       token,
     })
-    expect(metadata.totalSupply).toBe(parseEther('1000'))
+    expect(metadata.totalSupply).toBe(parseUnits('1000', 6))
   })
 
   // TODO: fix
@@ -483,7 +487,7 @@ describe('mint', () => {
       await actions.token.mintSync(client, {
         token,
         to: account2.address,
-        amount: parseEther('500'),
+        amount: parseUnits('500', 6),
         memo: Hex.fromString('test'),
       })
     expect(mintMemoReceipt.status).toBe('success')
@@ -499,32 +503,33 @@ describe('mint', () => {
       token,
       account: account2.address,
     })
-    expect(balance).toBe(parseEther('500'))
+    expect(balance).toBe(parseUnits('500', 6))
   })
 })
 
-describe.todo('permitToken')
-
 describe('transfer', () => {
   test('default', async () => {
     // Get initial balances
     const senderBalanceBefore = await actions.token.getBalance(client, {
       account: account.address,
+      token: addresses.alphaUsd,
     })
     const receiverBalanceBefore = await actions.token.getBalance(client, {
       account: account2.address,
+      token: addresses.alphaUsd,
     })
 
     // Transfer tokens
     const { receipt: transferReceipt, ...transferResult } =
       await actions.token.transferSync(client, {
         to: account2.address,
-        amount: parseEther('10'),
+        amount: parseUnits('10', 6),
+        token: addresses.alphaUsd,
       })
     expect(transferReceipt).toBeDefined()
     expect(transferResult).toMatchInlineSnapshot(`
       {
-        "amount": 10000000000000000000n,
+        "amount": 10000000n,
         "from": "0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266",
         "to": "0x8C8d35429F74ec245F8Ef2f4Fd1e551cFF97d650",
       }
@@ -533,15 +538,19 @@ describe('transfer', () => {
     // Verify balances
     const senderBalanceAfter = await actions.token.getBalance(client, {
       account: account.address,
+      token: addresses.alphaUsd,
     })
     const receiverBalanceAfter = await actions.token.getBalance(client, {
       account: account2.address,
+      token: addresses.alphaUsd,
     })
 
     expect(senderBalanceAfter - senderBalanceBefore).toBeLessThan(
-      parseEther('10'),
+      parseUnits('10', 6),
+    )
+    expect(receiverBalanceAfter - receiverBalanceBefore).toBe(
+      parseUnits('10', 6),
     )
-    expect(receiverBalanceAfter - receiverBalanceBefore).toBe(parseEther('10'))
   })
 
   test('behavior: with custom token', async () => {
@@ -562,14 +571,14 @@ describe('transfer', () => {
     await actions.token.mintSync(client, {
       token,
       to: client.account.address,
-      amount: parseEther('1000'),
+      amount: parseUnits('1000', 6),
     })
 
     // Transfer custom tokens
     await actions.token.transferSync(client, {
       token,
       to: account2.address,
-      amount: parseEther('100'),
+      amount: parseUnits('100', 6),
     })
 
     // Verify balance
@@ -577,7 +586,7 @@ describe('transfer', () => {
       token,
       account: account2.address,
     })
-    expect(balance).toBe(parseEther('100'))
+    expect(balance).toBe(parseUnits('100', 6))
   })
 
   test('behavior: with memo', async () => {
@@ -586,14 +595,15 @@ describe('transfer', () => {
     const { receipt: transferMemoReceipt, ...transferMemoResult } =
       await actions.token.transferSync(client, {
         to: account2.address,
-        amount: parseEther('5'),
+        amount: parseUnits('5', 6),
         memo,
+        token: addresses.alphaUsd,
       })
 
     expect(transferMemoReceipt.status).toBe('success')
     expect(transferMemoResult).toMatchInlineSnapshot(`
       {
-        "amount": 5000000000000000000n,
+        "amount": 5000000n,
         "from": "0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266",
         "to": "0x8C8d35429F74ec245F8Ef2f4Fd1e551cFF97d650",
       }
@@ -604,20 +614,22 @@ describe('transfer', () => {
     // First approve account2 to spend tokens
     await actions.token.approveSync(client, {
       spender: account2.address,
-      amount: parseEther('50'),
+      amount: parseUnits('50', 6),
+      token: addresses.alphaUsd,
     })
 
     // Transfer tokens for gas
     await writeContractSync(client, {
       abi: Abis.tip20,
-      address: Addresses.defaultFeeToken,
+      address: addresses.alphaUsd,
       functionName: 'transfer',
-      args: [account2.address, parseEther('1')],
+      args: [account2.address, parseUnits('1', 6)],
     })
 
     // Get initial balance
     const balanceBefore = await actions.token.getBalance(client, {
       account: account3.address,
+      token: addresses.alphaUsd,
     })
 
     // Account2 transfers from account to account3
@@ -625,20 +637,23 @@ describe('transfer', () => {
       account: account2,
       from: account.address,
       to: account3.address,
-      amount: parseEther('25'),
+      amount: parseUnits('25', 6),
+      token: addresses.alphaUsd,
     })
 
     // Verify balance
     const balanceAfter = await actions.token.getBalance(client, {
       account: account3.address,
+      token: addresses.alphaUsd,
     })
-    expect(balanceAfter - balanceBefore).toBe(parseEther('25'))
+    expect(balanceAfter - balanceBefore).toBe(parseUnits('25', 6))
 
     // Verify allowance was reduced
     const allowance = await actions.token.getAllowance(client, {
       spender: account2.address,
+      token: addresses.alphaUsd,
     })
-    expect(allowance).toBe(parseEther('25'))
+    expect(allowance).toBe(parseUnits('25', 6))
   })
 })
 
@@ -662,30 +677,30 @@ describe('burn', () => {
     await actions.token.mintSync(client, {
       token,
       to: client.account.address,
-      amount: parseEther('1000'),
+      amount: parseUnits('1000', 6),
     })
 
     // Check balance before burn
     const balanceBefore = await actions.token.getBalance(client, {
       token,
     })
-    expect(balanceBefore).toBe(parseEther('1000'))
+    expect(balanceBefore).toBe(parseUnits('1000', 6))
 
     // Check total supply before
     const metadataBefore = await actions.token.getMetadata(client, {
       token,
     })
-    expect(metadataBefore.totalSupply).toBe(parseEther('1000'))
+    expect(metadataBefore.totalSupply).toBe(parseUnits('1000', 6))
 
     // Burn tokens
     const { receipt, ...result } = await actions.token.burnSync(client, {
       token,
-      amount: parseEther('100'),
+      amount: parseUnits('100', 6),
     })
     expect(receipt).toBeDefined()
     expect(result).toMatchInlineSnapshot(`
       {
-        "amount": 100000000000000000000n,
+        "amount": 100000000n,
         "from": "0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266",
       }
     `)
@@ -694,13 +709,13 @@ describe('burn', () => {
     const balanceAfter = await actions.token.getBalance(client, {
       token,
     })
-    expect(balanceAfter).toBe(parseEther('900'))
+    expect(balanceAfter).toBe(parseUnits('900', 6))
 
     // Check total supply after
     const metadataAfter = await actions.token.getMetadata(client, {
       token,
     })
-    expect(metadataAfter.totalSupply).toBe(parseEther('900'))
+    expect(metadataAfter.totalSupply).toBe(parseUnits('900', 6))
   })
 
   test('behavior: requires issuer role', async () => {
@@ -721,23 +736,24 @@ describe('burn', () => {
     // Transfer gas to account2
     await writeContractSync(client, {
       abi: Abis.tip20,
-      address: Addresses.defaultFeeToken,
+      address: addresses.alphaUsd,
       functionName: 'transfer',
-      args: [account2.address, parseEther('1')],
+      args: [account2.address, parseUnits('1', 6)],
     })
 
     await actions.token.mintSync(client, {
       account: account2,
+      feeToken: addresses.alphaUsd,
       token,
       to: client.account.address,
-      amount: parseEther('100'),
+      amount: parseUnits('100', 6),
     })
 
     // Try to burn without issuer role - should fail
     await expect(
       actions.token.burnSync(client, {
         token,
-        amount: parseEther('10'),
+        amount: parseUnits('10', 6),
       }),
     ).rejects.toThrow()
   })
@@ -773,7 +789,7 @@ describe('pause', () => {
     await actions.token.mintSync(client, {
       token,
       to: account2.address,
-      amount: parseEther('1000'),
+      amount: parseUnits('1000', 6),
     })
 
     // Verify token is not paused
@@ -785,16 +801,16 @@ describe('pause', () => {
     // Transfer gas
     await writeContractSync(client, {
       abi: Abis.tip20,
-      address: Addresses.defaultFeeToken,
+      address: addresses.alphaUsd,
       functionName: 'transfer',
-      args: [account2.address, parseEther('1')],
+      args: [account2.address, parseUnits('1', 6)],
     })
 
     await actions.token.transferSync(client, {
       account: account2,
       token,
       to: account3.address,
-      amount: parseEther('100'),
+      amount: parseUnits('100', 6),
     })
 
     // Pause the token
@@ -822,7 +838,7 @@ describe('pause', () => {
         account: account2,
         token,
         to: account3.address,
-        amount: parseEther('100'),
+        amount: parseUnits('100', 6),
       }),
     ).rejects.toThrow()
   })
@@ -852,13 +868,14 @@ describe('pause', () => {
     // Transfer gas to account2
     await writeContractSync(client, {
       abi: Abis.tip20,
-      address: Addresses.defaultFeeToken,
+      address: addresses.alphaUsd,
       functionName: 'transfer',
-      args: [account2.address, parseEther('1')],
+      args: [account2.address, parseUnits('1', 6)],
     })
 
     await actions.token.pauseSync(client, {
       account: account2,
+      feeToken: addresses.alphaUsd,
       token,
     })
 
@@ -936,7 +953,7 @@ describe('unpause', () => {
     await actions.token.mintSync(client, {
       token: address,
       to: account2.address,
-      amount: parseEther('1000'),
+      amount: parseUnits('1000', 6),
     })
 
     // First pause the token
@@ -953,9 +970,9 @@ describe('unpause', () => {
     // Transfer gas to account2
     await writeContractSync(client, {
       abi: Abis.tip20,
-      address: Addresses.defaultFeeToken,
+      address: addresses.alphaUsd,
       functionName: 'transfer',
-      args: [account2.address, parseEther('1')],
+      args: [account2.address, parseUnits('1', 6)],
     })
 
     // Verify transfers fail when paused
@@ -964,7 +981,7 @@ describe('unpause', () => {
         account: account2,
         token: address,
         to: account3.address,
-        amount: parseEther('100'),
+        amount: parseUnits('100', 6),
       }),
     ).rejects.toThrow()
 
@@ -992,14 +1009,14 @@ describe('unpause', () => {
       account: account2,
       token: address,
       to: account3.address,
-      amount: parseEther('100'),
+      amount: parseUnits('100', 6),
     })
 
     const balance = await actions.token.getBalance(client, {
       token: address,
       account: account3.address,
     })
-    expect(balance).toBe(parseEther('100'))
+    expect(balance).toBe(parseUnits('100', 6))
   })
 
   test('behavior: requires unpause role', async () => {
@@ -1038,14 +1055,15 @@ describe('unpause', () => {
     // Transfer gas to account2
     await writeContractSync(client, {
       abi: Abis.tip20,
-      address: Addresses.defaultFeeToken,
+      address: addresses.alphaUsd,
       functionName: 'transfer',
-      args: [account2.address, parseEther('1')],
+      args: [account2.address, parseUnits('1', 6)],
     })
 
     // Now account2 should be able to unpause
     await actions.token.unpauseSync(client, {
       account: account2,
+      feeToken: addresses.alphaUsd,
       token: address,
     })
 
@@ -1081,21 +1099,22 @@ describe('unpause', () => {
     // Transfer gas to both accounts
     await writeContractSync(client, {
       abi: Abis.tip20,
-      address: Addresses.defaultFeeToken,
+      address: addresses.alphaUsd,
       functionName: 'transfer',
-      args: [account2.address, parseEther('1')],
+      args: [account2.address, parseUnits('1', 6)],
     })
 
     await writeContractSync(client, {
       abi: Abis.tip20,
-      address: Addresses.defaultFeeToken,
+      address: addresses.alphaUsd,
       functionName: 'transfer',
-      args: [account3.address, parseEther('1')],
+      args: [account3.address, parseUnits('1', 6)],
     })
 
     // Account2 can pause
     await actions.token.pauseSync(client, {
       account: account2,
+      feeToken: addresses.alphaUsd,
       token: address,
     })
 
@@ -1110,6 +1129,7 @@ describe('unpause', () => {
     // Account3 can unpause
     await actions.token.unpauseSync(client, {
       account: account3,
+      feeToken: addresses.alphaUsd,
       token: address,
     })
 
@@ -1121,7 +1141,7 @@ describe('unpause', () => {
   })
 })
 
-describe('updateQuoteToken', () => {
+describe('prepareUpdateQuoteToken', () => {
   test('default', async () => {
     // Create two tokens - one to be the new quote token
     const { token: quoteTokenAddress } = await actions.token.createSync(
@@ -1140,22 +1160,24 @@ describe('updateQuoteToken', () => {
     })
 
     // Update quote token
-    const { receipt: updateReceipt, ...updateResult } =
-      await actions.token.updateQuoteTokenSync(client, {
-        token: address,
-        quoteToken: quoteTokenAddress,
-      })
+    const {
+      receipt: updateReceipt,
+      nextQuoteToken,
+      ...updateResult
+    } = await actions.token.prepareUpdateQuoteTokenSync(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)
+    expect(nextQuoteToken).toBe(quoteTokenAddress)
   })
 
   test('behavior: requires admin role', async () => {
@@ -1179,14 +1201,14 @@ describe('updateQuoteToken', () => {
     // Transfer gas to account2
     await writeContractSync(client, {
       abi: Abis.tip20,
-      address: Addresses.defaultFeeToken,
+      address: addresses.alphaUsd,
       functionName: 'transfer',
-      args: [account2.address, parseEther('1')],
+      args: [account2.address, parseUnits('1', 6)],
     })
 
     // Try to update quote token from account2 (not admin) - should fail
     await expect(
-      actions.token.updateQuoteTokenSync(client, {
+      actions.token.prepareUpdateQuoteTokenSync(client, {
         account: account2,
         token: address,
         quoteToken: quoteTokenAddress,
@@ -1213,14 +1235,22 @@ describe('updateQuoteToken', () => {
     })
 
     // 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,
-      })
+    const {
+      receipt: updateReceipt,
+      nextQuoteToken,
+      ...updateResult
+    } = await actions.token.prepareUpdateQuoteTokenSync(client, {
+      token: mainTokenId,
+      quoteToken: quoteTokenAddress,
+    })
 
+    expect(updateResult).toMatchInlineSnapshot(`
+      {
+        "updater": "0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266",
+      }
+    `)
+    expect(nextQuoteToken).toBe(quoteTokenAddress)
     expect(updateReceipt.status).toBe('success')
-    expect(updateResult.updater).toBe(client.account.address)
   })
 })
 
@@ -1243,28 +1273,30 @@ describe('finalizeUpdateQuoteToken', () => {
       symbol: 'MAIN',
     })
 
-    // Update quote token (step 1)
-    await actions.token.updateQuoteTokenSync(client, {
+    // Prepare update quote token (step 1)
+    await actions.token.prepareUpdateQuoteTokenSync(client, {
       token: address,
       quoteToken: quoteTokenAddress,
     })
 
     // Finalize the update (step 2)
-    const { receipt: finalizeReceipt, ...finalizeResult } =
-      await actions.token.finalizeUpdateQuoteTokenSync(client, {
-        token: address,
-      })
+    const {
+      receipt: finalizeReceipt,
+      newQuoteToken,
+      ...finalizeResult
+    } = await actions.token.updateQuoteTokenSync(client, {
+      token: address,
+    })
 
     expect(finalizeReceipt).toBeDefined()
     expect(finalizeResult).toMatchInlineSnapshot(`
       {
-        "newQuoteToken": "0x20C0000000000000000000000000000000000004",
         "updater": "0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266",
       }
     `)
 
     // Verify the quote token was updated
-    expect(finalizeResult.newQuoteToken).toBe(quoteTokenAddress)
+    expect(newQuoteToken).toBe(quoteTokenAddress)
 
     // Verify it's reflected in metadata
     const metadata = await actions.token.getMetadata(client, {
@@ -1292,7 +1324,7 @@ describe('finalizeUpdateQuoteToken', () => {
     })
 
     // Update quote token as admin
-    await actions.token.updateQuoteTokenSync(client, {
+    await actions.token.prepareUpdateQuoteTokenSync(client, {
       token: address,
       quoteToken: quoteTokenAddress,
     })
@@ -1300,14 +1332,14 @@ describe('finalizeUpdateQuoteToken', () => {
     // Transfer gas to account2
     await writeContractSync(client, {
       abi: Abis.tip20,
-      address: Addresses.defaultFeeToken,
+      address: addresses.alphaUsd,
       functionName: 'transfer',
-      args: [account2.address, parseEther('1')],
+      args: [account2.address, parseUnits('1', 6)],
     })
 
     // Try to finalize as non-admin - should fail
     await expect(
-      actions.token.finalizeUpdateQuoteTokenSync(client, {
+      actions.token.updateQuoteTokenSync(client, {
         account: account2,
         token: address,
       }),
@@ -1331,14 +1363,14 @@ describe('finalizeUpdateQuoteToken', () => {
     })
 
     // Try to make token B link to token A (would create A -> B -> A loop)
-    await actions.token.updateQuoteTokenSync(client, {
+    await actions.token.prepareUpdateQuoteTokenSync(client, {
       token: tokenBAddress,
       quoteToken: tokenAAddress,
     })
 
     // Finalize should fail due to circular reference detection
     await expect(
-      actions.token.finalizeUpdateQuoteTokenSync(client, {
+      actions.token.updateQuoteTokenSync(client, {
         token: tokenBAddress,
       }),
     ).rejects.toThrow()
@@ -1537,6 +1569,119 @@ describe('hasRole', () => {
   })
 })
 
+describe('getRoleAdmin', () => {
+  test('default', async () => {
+    // Create a new token where we're the admin
+    const { token: address } = await actions.token.createSync(client, {
+      currency: 'USD',
+      name: 'GetRoleAdmin Test Token',
+      symbol: 'GRATEST',
+    })
+
+    // Get admin role for issuer role (should be defaultAdmin)
+    const issuerAdminRole = await actions.token.getRoleAdmin(client, {
+      token: address,
+      role: 'issuer',
+    })
+    expect(issuerAdminRole).toBe(
+      '0x0000000000000000000000000000000000000000000000000000000000000000',
+    )
+
+    // Get admin role for pause role (should be defaultAdmin)
+    const pauseAdminRole = await actions.token.getRoleAdmin(client, {
+      token: address,
+      role: 'pause',
+    })
+    expect(pauseAdminRole).toBe(
+      '0x0000000000000000000000000000000000000000000000000000000000000000',
+    )
+
+    // Get admin role for unpause role (should be defaultAdmin)
+    const unpauseAdminRole = await actions.token.getRoleAdmin(client, {
+      token: address,
+      role: 'unpause',
+    })
+    expect(unpauseAdminRole).toBe(
+      '0x0000000000000000000000000000000000000000000000000000000000000000',
+    )
+  })
+
+  test('behavior: after setting role admin', async () => {
+    // Create a new token
+    const { token: address } = await actions.token.createSync(client, {
+      currency: 'USD',
+      name: 'GetRoleAdmin After Set',
+      symbol: 'GRASET',
+    })
+
+    // Get initial admin role for issuer
+    const initialAdminRole = await actions.token.getRoleAdmin(client, {
+      token: address,
+      role: 'issuer',
+    })
+    expect(initialAdminRole).toBe(
+      '0x0000000000000000000000000000000000000000000000000000000000000000',
+    )
+
+    // Set pause as admin role for issuer
+    await actions.token.setRoleAdminSync(client, {
+      token: address,
+      role: 'issuer',
+      adminRole: 'pause',
+    })
+
+    // Get updated admin role for issuer
+    const updatedAdminRole = await actions.token.getRoleAdmin(client, {
+      token: address,
+      role: 'issuer',
+    })
+    expect(updatedAdminRole).toBe(TokenRole.serialize('pause'))
+  })
+
+  test('behavior: with token ID', async () => {
+    // Create a new token
+    const { token: address, tokenId } = await actions.token.createSync(client, {
+      currency: 'USD',
+      name: 'GetRoleAdmin Token ID',
+      symbol: 'GRATID',
+    })
+
+    // Get admin role using token ID
+    const adminRoleWithId = await actions.token.getRoleAdmin(client, {
+      token: tokenId,
+      role: 'issuer',
+    })
+    expect(adminRoleWithId).toBe(
+      '0x0000000000000000000000000000000000000000000000000000000000000000',
+    )
+
+    // Get admin role using address
+    const adminRoleWithAddress = await actions.token.getRoleAdmin(client, {
+      token: address,
+      role: 'issuer',
+    })
+    expect(adminRoleWithAddress).toBe(adminRoleWithId)
+  })
+
+  test('behavior: defaultAdmin role admin', async () => {
+    // Create a new token
+    const { token: address } = await actions.token.createSync(client, {
+      currency: 'USD',
+      name: 'GetRoleAdmin DefaultAdmin',
+      symbol: 'GRADMIN',
+    })
+
+    // Get admin role for defaultAdmin role (should be itself - 0x00)
+    const defaultAdminAdminRole = await actions.token.getRoleAdmin(client, {
+      token: address,
+      role: 'defaultAdmin',
+    })
+    expect(defaultAdminAdminRole).toBe(
+      '0x0000000000000000000000000000000000000000000000000000000000000000',
+    )
+  })
+})
+
 describe('grantRoles', () => {
   test('default', async () => {
     // Create a new token where we're the admin
@@ -1556,16 +1701,16 @@ describe('grantRoles', () => {
       })
 
     expect(grantReceipt.status).toBe('success')
-    expect(grantValue).toMatchInlineSnapshot(`
-      [
-        {
-          "account": "0x8C8d35429F74ec245F8Ef2f4Fd1e551cFF97d650",
-          "hasRole": true,
-          "role": "0x114e74f6ea3bd819998f78687bfcb11b140da08e9b7d222fa9c1f1ba1f2aa122",
-          "sender": "0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266",
-        },
-      ]
+    expect(grantValue).toHaveLength(1)
+    const { role, ...restGrant } = grantValue[0]!
+    expect(restGrant).toMatchInlineSnapshot(`
+      {
+        "account": "0x8C8d35429F74ec245F8Ef2f4Fd1e551cFF97d650",
+        "hasRole": true,
+        "sender": "0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266",
+      }
     `)
+    expect(role).toBeDefined()
   })
 })
 
@@ -1592,16 +1737,16 @@ describe('revokeTokenRole', async () => {
       })
 
     expect(revokeReceipt.status).toBe('success')
-    expect(revokeValue).toMatchInlineSnapshot(`
-      [
-        {
-          "account": "0x8C8d35429F74ec245F8Ef2f4Fd1e551cFF97d650",
-          "hasRole": false,
-          "role": "0x114e74f6ea3bd819998f78687bfcb11b140da08e9b7d222fa9c1f1ba1f2aa122",
-          "sender": "0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266",
-        },
-      ]
+    expect(revokeValue).toHaveLength(1)
+    const { role, ...restRevoke } = revokeValue[0]!
+    expect(restRevoke).toMatchInlineSnapshot(`
+      {
+        "account": "0x8C8d35429F74ec245F8Ef2f4Fd1e551cFF97d650",
+        "hasRole": false,
+        "sender": "0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266",
+      }
     `)
+    expect(role).toBeDefined()
   })
 })
 
@@ -1631,16 +1776,16 @@ describe('renounceTokenRole', async () => {
       })
 
     expect(renounceReceipt.status).toBe('success')
-    expect(renounceValue).toMatchInlineSnapshot(`
-      [
-        {
-          "account": "0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266",
-          "hasRole": false,
-          "role": "0x114e74f6ea3bd819998f78687bfcb11b140da08e9b7d222fa9c1f1ba1f2aa122",
-          "sender": "0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266",
-        },
-      ]
+    expect(renounceValue).toHaveLength(1)
+    const { role, ...restRenounce } = renounceValue[0]!
+    expect(restRenounce).toMatchInlineSnapshot(`
+      {
+        "account": "0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266",
+        "hasRole": false,
+        "sender": "0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266",
+      }
     `)
+    expect(role).toBeDefined()
   })
 })
 
@@ -1676,26 +1821,39 @@ describe('watchCreate', () => {
 
       expect(receivedTokens).toHaveLength(2)
 
-      expect(receivedTokens.at(0)!.args).toMatchInlineSnapshot(`
+      const {
+        token: token1,
+        tokenId: tokenId1,
+        ...rest1
+      } = receivedTokens.at(0)!.args
+      expect(rest1).toMatchInlineSnapshot(`
         {
           "admin": "0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266",
           "currency": "USD",
           "name": "Watch Test Token 1",
+          "quoteToken": "0x20C0000000000000000000000000000000000000",
           "symbol": "WATCH1",
-          "token": "0x20C0000000000000000000000000000000000004",
-          "tokenId": 4n,
         }
       `)
-      expect(receivedTokens.at(1)!.args).toMatchInlineSnapshot(`
+      expect(token1).toBeDefined()
+      expect(tokenId1).toBeDefined()
+
+      const {
+        token: token2,
+        tokenId: tokenId2,
+        ...rest2
+      } = receivedTokens.at(1)!.args
+      expect(rest2).toMatchInlineSnapshot(`
         {
           "admin": "0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266",
           "currency": "USD",
           "name": "Watch Test Token 2",
+          "quoteToken": "0x20C0000000000000000000000000000000000000",
           "symbol": "WATCH2",
-          "token": "0x20c0000000000000000000000000000000000005",
-          "tokenId": 5n,
         }
       `)
+      expect(token2).toBeDefined()
+      expect(tokenId2).toBeDefined()
     } finally {
       // Clean up watcher
       if (unwatch) unwatch()
@@ -1757,19 +1915,19 @@ describe('watchCreate', () => {
 
       expect(receivedTokens.at(0)!.args.tokenId).toBe(targetTokenId)
       expect(receivedTokens.at(0)!.args.tokenId).toBe(id2)
-      expect(receivedTokens.at(0)!.args).toMatchInlineSnapshot(`
+
+      const { token, tokenId, ...rest } = receivedTokens.at(0)!.args
+      expect(rest).toMatchInlineSnapshot(`
         {
           "admin": "0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266",
           "currency": "USD",
           "name": "Filtered Watch Token 2",
+          "quoteToken": "0x20C0000000000000000000000000000000000000",
           "symbol": "FWATCH2",
-          "token": "0x20C0000000000000000000000000000000000006",
-          "tokenId": 6n,
         }
       `)
-
-      // Verify the received token has the expected tokenId
-      expect(receivedTokens.at(0)!.args.tokenId).toBe(targetTokenId)
+      expect(token).toBeDefined()
+      expect(tokenId).toBe(targetTokenId)
     } finally {
       if (unwatch) unwatch()
     }
@@ -1810,14 +1968,14 @@ describe('watchMint', () => {
       await actions.token.mintSync(client, {
         token: address,
         to: account2.address,
-        amount: parseEther('100'),
+        amount: parseUnits('100', 6),
       })
 
       // Mint second batch
       await actions.token.mintSync(client, {
         token: address,
         to: account3.address,
-        amount: parseEther('50'),
+        amount: parseUnits('50', 6),
       })
 
       await setTimeout(100)
@@ -1826,13 +1984,13 @@ describe('watchMint', () => {
 
       expect(receivedMints.at(0)!.args).toMatchInlineSnapshot(`
         {
-          "amount": 100000000000000000000n,
+          "amount": 100000000n,
           "to": "0x8C8d35429F74ec245F8Ef2f4Fd1e551cFF97d650",
         }
       `)
       expect(receivedMints.at(1)!.args).toMatchInlineSnapshot(`
         {
-          "amount": 50000000000000000000n,
+          "amount": 50000000n,
           "to": "0x98e503f35D0a019cB0a251aD243a4cCFCF371F46",
         }
       `)
@@ -1877,21 +2035,21 @@ describe('watchMint', () => {
       await actions.token.mintSync(client, {
         token: address,
         to: account2.address,
-        amount: parseEther('100'),
+        amount: parseUnits('100', 6),
       })
 
       // Mint to account3 (should NOT be captured)
       await actions.token.mintSync(client, {
         token: address,
         to: account3.address,
-        amount: parseEther('50'),
+        amount: parseUnits('50', 6),
       })
 
       // Mint to account2 again (should be captured)
       await actions.token.mintSync(client, {
         token: address,
         to: account2.address,
-        amount: parseEther('75'),
+        amount: parseUnits('75', 6),
       })
 
       await setTimeout(100)
@@ -1901,13 +2059,13 @@ describe('watchMint', () => {
 
       expect(receivedMints.at(0)!.args).toMatchInlineSnapshot(`
         {
-          "amount": 100000000000000000000n,
+          "amount": 100000000n,
           "to": "0x8C8d35429F74ec245F8Ef2f4Fd1e551cFF97d650",
         }
       `)
       expect(receivedMints.at(1)!.args).toMatchInlineSnapshot(`
         {
-          "amount": 75000000000000000000n,
+          "amount": 75000000n,
           "to": "0x8C8d35429F74ec245F8Ef2f4Fd1e551cFF97d650",
         }
       `)
@@ -1949,14 +2107,14 @@ describe('watchApprove', () => {
       await actions.token.approveSync(client, {
         token: address,
         spender: account2.address,
-        amount: parseEther('100'),
+        amount: parseUnits('100', 6),
       })
 
       // Approve account3
       await actions.token.approveSync(client, {
         token: address,
         spender: account3.address,
-        amount: parseEther('50'),
+        amount: parseUnits('50', 6),
       })
 
       await setTimeout(100)
@@ -1965,14 +2123,14 @@ describe('watchApprove', () => {
 
       expect(receivedApprovals.at(0)!.args).toMatchInlineSnapshot(`
         {
-          "amount": 100000000000000000000n,
+          "amount": 100000000n,
           "owner": "0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266",
           "spender": "0x8C8d35429F74ec245F8Ef2f4Fd1e551cFF97d650",
         }
       `)
       expect(receivedApprovals.at(1)!.args).toMatchInlineSnapshot(`
         {
-          "amount": 50000000000000000000n,
+          "amount": 50000000n,
           "owner": "0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266",
           "spender": "0x98e503f35D0a019cB0a251aD243a4cCFCF371F46",
         }
@@ -2011,21 +2169,21 @@ describe('watchApprove', () => {
       await actions.token.approveSync(client, {
         token: address,
         spender: account2.address,
-        amount: parseEther('100'),
+        amount: parseUnits('100', 6),
       })
 
       // Approve account3 (should NOT be captured)
       await actions.token.approveSync(client, {
         token: address,
         spender: account3.address,
-        amount: parseEther('50'),
+        amount: parseUnits('50', 6),
       })
 
       // Approve account2 again (should be captured)
       await actions.token.approveSync(client, {
         token: address,
         spender: account2.address,
-        amount: parseEther('75'),
+        amount: parseUnits('75', 6),
       })
 
       await setTimeout(100)
@@ -2035,14 +2193,14 @@ describe('watchApprove', () => {
 
       expect(receivedApprovals.at(0)!.args).toMatchInlineSnapshot(`
         {
-          "amount": 100000000000000000000n,
+          "amount": 100000000n,
           "owner": "0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266",
           "spender": "0x8C8d35429F74ec245F8Ef2f4Fd1e551cFF97d650",
         }
       `)
       expect(receivedApprovals.at(1)!.args).toMatchInlineSnapshot(`
         {
-          "amount": 75000000000000000000n,
+          "amount": 75000000n,
           "owner": "0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266",
           "spender": "0x8C8d35429F74ec245F8Ef2f4Fd1e551cFF97d650",
         }
@@ -2085,13 +2243,13 @@ describe('watchBurn', () => {
     await actions.token.mintSync(client, {
       token: address,
       to: client.account.address,
-      amount: parseEther('200'),
+      amount: parseUnits('200', 6),
     })
 
     await actions.token.mintSync(client, {
       token: address,
       to: account2.address,
-      amount: parseEther('100'),
+      amount: parseUnits('100', 6),
     })
 
     const receivedBurns: Array<{
@@ -2111,22 +2269,22 @@ describe('watchBurn', () => {
       // Burn first batch
       await actions.token.burnSync(client, {
         token: address,
-        amount: parseEther('50'),
+        amount: parseUnits('50', 6),
       })
 
       // Transfer gas to account2
       await writeContractSync(client, {
         abi: Abis.tip20,
-        address: Addresses.defaultFeeToken,
+        address: addresses.alphaUsd,
         functionName: 'transfer',
-        args: [account2.address, parseEther('1')],
+        args: [account2.address, parseUnits('1', 6)],
       })
 
       // Burn second batch from account2
       await actions.token.burnSync(client, {
         account: account2,
         token: address,
-        amount: parseEther('25'),
+        amount: parseUnits('25', 6),
       })
 
       await setTimeout(100)
@@ -2135,13 +2293,13 @@ describe('watchBurn', () => {
 
       expect(receivedBurns.at(0)!.args).toMatchInlineSnapshot(`
         {
-          "amount": 50000000000000000000n,
+          "amount": 50000000n,
           "from": "0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266",
         }
       `)
       expect(receivedBurns.at(1)!.args).toMatchInlineSnapshot(`
         {
-          "amount": 25000000000000000000n,
+          "amount": 25000000n,
           "from": "0x8C8d35429F74ec245F8Ef2f4Fd1e551cFF97d650",
         }
       `)
@@ -2176,13 +2334,13 @@ describe('watchBurn', () => {
     await actions.token.mintSync(client, {
       token: address,
       to: client.account.address,
-      amount: parseEther('200'),
+      amount: parseUnits('200', 6),
     })
 
     await actions.token.mintSync(client, {
       token: address,
       to: account2.address,
-      amount: parseEther('200'),
+      amount: parseUnits('200', 6),
     })
 
     const receivedBurns: Array<{
@@ -2205,28 +2363,28 @@ describe('watchBurn', () => {
       // Burn from client.account (should be captured)
       await actions.token.burnSync(client, {
         token: address,
-        amount: parseEther('50'),
+        amount: parseUnits('50', 6),
       })
 
       // Transfer gas to account2
       await writeContractSync(client, {
         abi: Abis.tip20,
-        address: Addresses.defaultFeeToken,
+        address: addresses.alphaUsd,
         functionName: 'transfer',
-        args: [account2.address, parseEther('1')],
+        args: [account2.address, parseUnits('1', 6)],
       })
 
       // Burn from account2 (should NOT be captured)
       await actions.token.burnSync(client, {
         account: account2,
         token: address,
-        amount: parseEther('25'),
+        amount: parseUnits('25', 6),
       })
 
       // Burn from client.account again (should be captured)
       await actions.token.burnSync(client, {
         token: address,
-        amount: parseEther('75'),
+        amount: parseUnits('75', 6),
       })
 
       await setTimeout(100)
@@ -2236,13 +2394,13 @@ describe('watchBurn', () => {
 
       expect(receivedBurns.at(0)!.args).toMatchInlineSnapshot(`
         {
-          "amount": 50000000000000000000n,
+          "amount": 50000000n,
           "from": "0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266",
         }
       `)
       expect(receivedBurns.at(1)!.args).toMatchInlineSnapshot(`
         {
-          "amount": 75000000000000000000n,
+          "amount": 75000000n,
           "from": "0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266",
         }
       `)
@@ -2281,20 +2439,24 @@ describe('watchAdminRole', () => {
 
     try {
       // Set role admin for issuer role
-      const { receipt: setRoleAdmin1Receipt, ...setRoleAdmin1Result } =
-        await actions.token.setRoleAdminSync(client, {
-          token: address,
-          role: 'issuer',
-          adminRole: 'pause',
-        })
+      const {
+        receipt: setRoleAdmin1Receipt,
+        role,
+        newAdminRole,
+        ...setRoleAdmin1Result
+      } = await actions.token.setRoleAdminSync(client, {
+        token: address,
+        role: 'issuer',
+        adminRole: 'pause',
+      })
       expect(setRoleAdmin1Receipt).toBeDefined()
       expect(setRoleAdmin1Result).toMatchInlineSnapshot(`
         {
-          "newAdminRole": "0x139c2898040ef16910dc9f44dc697df79363da767d8bc92f2e310312b816e46d",
-          "role": "0x114e74f6ea3bd819998f78687bfcb11b140da08e9b7d222fa9c1f1ba1f2aa122",
           "sender": "0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266",
         }
       `)
+      expect(role).toBeDefined()
+      expect(newAdminRole).toBeDefined()
 
       // Set role admin for pause role
       await actions.token.setRoleAdminSync(client, {
@@ -2458,6 +2620,10 @@ describe('watchRole', () => {
 })
 
 describe('watchTransfer', () => {
+  beforeAll(async () => {
+    await fetch(`${rpcUrl}/restart`)
+  })
+
   test('default', async () => {
     // Create a new token for testing
     const { token: address } = await actions.token.createSync(client, {
@@ -2477,7 +2643,7 @@ describe('watchTransfer', () => {
     await actions.token.mintSync(client, {
       token: address,
       to: client.account.address,
-      amount: parseEther('500'),
+      amount: parseUnits('500', 6),
     })
 
     const receivedTransfers: Array<{
@@ -2498,30 +2664,30 @@ describe('watchTransfer', () => {
       await actions.token.transferSync(client, {
         token: address,
         to: account2.address,
-        amount: parseEther('100'),
+        amount: parseUnits('100', 6),
       })
 
       // Transfer to account3
       await actions.token.transferSync(client, {
         token: address,
         to: account3.address,
-        amount: parseEther('50'),
+        amount: parseUnits('50', 6),
       })
 
       await setTimeout(200)
 
-      expect(receivedTransfers).toHaveLength(2)
+      expect(receivedTransfers.length).toBeGreaterThanOrEqual(2)
 
       expect(receivedTransfers.at(0)!.args).toMatchInlineSnapshot(`
         {
-          "amount": 100000000000000000000n,
+          "amount": 100000000n,
           "from": "0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266",
           "to": "0x8C8d35429F74ec245F8Ef2f4Fd1e551cFF97d650",
         }
       `)
       expect(receivedTransfers.at(1)!.args).toMatchInlineSnapshot(`
         {
-          "amount": 50000000000000000000n,
+          "amount": 50000000n,
           "from": "0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266",
           "to": "0x98e503f35D0a019cB0a251aD243a4cCFCF371F46",
         }
@@ -2550,7 +2716,7 @@ describe('watchTransfer', () => {
     await actions.token.mintSync(client, {
       token: address,
       to: client.account.address,
-      amount: parseEther('500'),
+      amount: parseUnits('500', 6),
     })
 
     const receivedTransfers: Array<{
@@ -2574,21 +2740,21 @@ describe('watchTransfer', () => {
       await actions.token.transferSync(client, {
         token: address,
         to: account2.address,
-        amount: parseEther('100'),
+        amount: parseUnits('100', 6),
       })
 
       // Transfer to account3 (should NOT be captured)
       await actions.token.transferSync(client, {
         token: address,
         to: account3.address,
-        amount: parseEther('50'),
+        amount: parseUnits('50', 6),
       })
 
       // Transfer to account2 again (should be captured)
       await actions.token.transferSync(client, {
         token: address,
         to: account2.address,
-        amount: parseEther('75'),
+        amount: parseUnits('75', 6),
       })
 
       await setTimeout(100)
@@ -2598,14 +2764,14 @@ describe('watchTransfer', () => {
 
       expect(receivedTransfers.at(0)!.args).toMatchInlineSnapshot(`
         {
-          "amount": 100000000000000000000n,
+          "amount": 100000000n,
           "from": "0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266",
           "to": "0x8C8d35429F74ec245F8Ef2f4Fd1e551cFF97d650",
         }
       `)
       expect(receivedTransfers.at(1)!.args).toMatchInlineSnapshot(`
         {
-          "amount": 75000000000000000000n,
+          "amount": 75000000n,
           "from": "0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266",
           "to": "0x8C8d35429F74ec245F8Ef2f4Fd1e551cFF97d650",
         }
@@ -2654,14 +2820,14 @@ describe('watchUpdateQuoteToken', () => {
     })
 
     try {
-      // Step 1: Update quote token (should emit UpdateQuoteToken)
-      await actions.token.updateQuoteTokenSync(client, {
+      // Step 1: Prepare update quote token (should emit NextQuoteTokenSet)
+      await actions.token.prepareUpdateQuoteTokenSync(client, {
         token: address,
         quoteToken: quoteTokenAddress,
       })
 
       // Step 2: Finalize the update (should emit QuoteTokenUpdateFinalized)
-      await actions.token.finalizeUpdateQuoteTokenSync(client, {
+      await actions.token.updateQuoteTokenSync(client, {
         token: address,
       })
 
@@ -2671,12 +2837,12 @@ describe('watchUpdateQuoteToken', () => {
       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.completed).toBe(false)
+      expect(receivedUpdates.at(0)!.args.nextQuoteToken).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.completed).toBe(true)
       expect(receivedUpdates.at(1)!.args.newQuoteToken).toBe(quoteTokenAddress)
       expect(receivedUpdates.at(1)!.args.updater).toBe(client.account.address)
     } finally {
@@ -2717,7 +2883,7 @@ describe('watchUpdateQuoteToken', () => {
 
     try {
       // Only update (don't finalize)
-      await actions.token.updateQuoteTokenSync(client, {
+      await actions.token.prepareUpdateQuoteTokenSync(client, {
         token: address,
         quoteToken: quoteTokenAddress,
       })
@@ -2726,8 +2892,8 @@ describe('watchUpdateQuoteToken', () => {
 
       // 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)
+      expect(receivedUpdates.at(0)!.args.completed).toBe(false)
+      expect(receivedUpdates.at(0)!.args.nextQuoteToken).toBe(quoteTokenAddress)
     } finally {
       if (unwatch) unwatch()
     }