tempo.ts 0.7.5 → 0.8.0

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

@@ -3,9 +3,14 @@ import { Abis, Actions } from 'tempo.ts/viem'
 import { parseUnits } from 'viem'
 import { writeContractSync } from 'viem/actions'
 import { describe, expect, test } from 'vitest'
-import { accounts, clientWithAccount } from '../../../test/viem/config.js'
+import {
+  accounts,
+  clientWithAccount,
+  setupPoolWithLiquidity,
+} from '../../../test/viem/config.js'
 
 const account = accounts[0]
+const account2 = accounts[1]
 
 describe('getPool', () => {
   test('default', async () => {
@@ -102,6 +107,173 @@ describe('mint', () => {
   })
 })
 
+describe.skip('burn', () => {
+  test('default', async () => {
+    const { tokenAddress } = await setupPoolWithLiquidity(clientWithAccount)
+
+    // Get LP balance before burn
+    const lpBalanceBefore = await Actions.amm.getLiquidityBalance(
+      clientWithAccount,
+      {
+        address: account.address,
+        userToken: tokenAddress,
+        validatorToken: 1n,
+      },
+    )
+
+    // TODO(TEMPO-1183): Remove this janky fix to get some user token in the pool
+    await Actions.token.transferSync(clientWithAccount, {
+      to: '0x30D861999070Ae03B9548501DBd573E11A9f59Ee',
+      amount: 600n,
+      token: tokenAddress,
+      feeToken: tokenAddress,
+    })
+
+    // Burn half of LP tokens
+    const {
+      receipt: burnReceipt,
+      userToken,
+      ...burnResult
+    } = await Actions.amm.burnSync(clientWithAccount, {
+      userToken: tokenAddress,
+      validatorToken: 1n,
+      liquidity: lpBalanceBefore / 2n,
+      to: account2.address,
+    })
+    const { sender, to, ...rest } = burnResult
+
+    expect(burnReceipt).toBeDefined()
+    expect(userToken).toBe(tokenAddress)
+    expect(sender).toBe(account.address)
+    expect(to).toBe(account2.address)
+    expect(rest).toMatchInlineSnapshot(`
+      {
+        "amountUserToken": 337n,
+        "amountValidatorToken": 49998664n,
+        "liquidity": 24999500n,
+        "validatorToken": "0x20C0000000000000000000000000000000000001",
+      }
+    `)
+
+    // Verify LP balance decreased
+    const lpBalanceAfter = await Actions.amm.getLiquidityBalance(
+      clientWithAccount,
+      {
+        address: account.address,
+        userToken: tokenAddress,
+        validatorToken: 1n,
+      },
+    )
+    expect(lpBalanceAfter).toBeLessThan(lpBalanceBefore)
+    expect(lpBalanceAfter).toBe(lpBalanceBefore / 2n)
+
+    // Verify pool reserves decreased
+    const pool = await Actions.amm.getPool(clientWithAccount, {
+      userToken: tokenAddress,
+      validatorToken: 1n,
+    })
+    expect(pool).toMatchInlineSnapshot(`
+      {
+        "reserveUserToken": 338n,
+        "reserveValidatorToken": 50000664n,
+        "totalSupply": 25000500n,
+      }
+    `)
+  })
+})
+
+describe.skip('rebalanceSwap', () => {
+  test('default', async () => {
+    const { tokenAddress } = await setupPoolWithLiquidity(clientWithAccount)
+
+    // TODO(TEMPO-1183): Remove this janky fix to get some user token in the pool
+    await Actions.token.transferSync(clientWithAccount, {
+      to: '0x30D861999070Ae03B9548501DBd573E11A9f59Ee',
+      amount: 600n,
+      token: tokenAddress,
+      feeToken: tokenAddress,
+    })
+
+    // Get balance before swap
+    const balanceBefore = await Actions.token.getBalance(clientWithAccount, {
+      token: tokenAddress,
+      account: account2.address,
+    })
+
+    // Perform rebalance swap
+    const {
+      receipt: swapReceipt,
+      swapper,
+      userToken,
+      ...swapResult
+    } = await Actions.amm.rebalanceSwapSync(clientWithAccount, {
+      userToken: tokenAddress,
+      validatorToken: 1n,
+      amountOut: 100n,
+      to: account2.address,
+      account: account,
+    })
+    expect(swapReceipt).toBeDefined()
+    expect(userToken).toBe(tokenAddress)
+    expect(swapper).toBe(account.address)
+    expect(swapResult).toMatchInlineSnapshot(`
+      {
+        "amountIn": 100n,
+        "amountOut": 100n,
+        "validatorToken": "0x20C0000000000000000000000000000000000001",
+      }
+    `)
+
+    // Verify balance increased
+    const balanceAfter = await Actions.token.getBalance(clientWithAccount, {
+      token: tokenAddress,
+      account: account2.address,
+    })
+    expect(balanceAfter).toBe(balanceBefore + 100n)
+  })
+})
+
+describe.skip('watchRebalanceSwap', () => {
+  test('default', async () => {
+    const { tokenAddress } = await setupPoolWithLiquidity(clientWithAccount)
+
+    // TODO(TEMPO-1183): Remove this janky fix to get some user token in the pool
+    await Actions.token.transferSync(clientWithAccount, {
+      to: '0x30D861999070Ae03B9548501DBd573E11A9f59Ee',
+      amount: 600n,
+      token: tokenAddress,
+      feeToken: tokenAddress,
+    })
+
+    let eventArgs: any = null
+    const unwatch = Actions.amm.watchRebalanceSwap(clientWithAccount, {
+      onRebalanceSwap: (args) => {
+        eventArgs = args
+      },
+    })
+
+    // Perform rebalance swap
+    await Actions.amm.rebalanceSwapSync(clientWithAccount, {
+      userToken: tokenAddress,
+      validatorToken: 1n,
+      amountOut: 100n,
+      to: account2.address,
+      account: account,
+    })
+
+    await setTimeout(1000)
+
+    expect(eventArgs).toBeDefined()
+    expect(eventArgs.userToken.toLowerCase()).toBe(tokenAddress.toLowerCase())
+    expect(eventArgs.validatorToken.toLowerCase()).toBe(
+      '0x20c0000000000000000000000000000000000001',
+    )
+    expect(eventArgs.amountOut).toBe(100n)
+
+    unwatch()
+  })
+})
+
 describe('watchMint', () => {
   test('default', async () => {
     // Create a new token for testing
@@ -160,3 +332,50 @@ describe('watchMint', () => {
     unwatch()
   })
 })
+
+describe.skip('watchBurn', () => {
+  test('default', async () => {
+    const { tokenAddress } = await setupPoolWithLiquidity(clientWithAccount)
+
+    // Get LP balance
+    const lpBalance = await Actions.amm.getLiquidityBalance(clientWithAccount, {
+      userToken: tokenAddress,
+      validatorToken: 1n,
+      address: account.address,
+    })
+
+    // TODO(TEMPO-1183): Remove this janky fix to get some user token in the pool
+    await Actions.token.transferSync(clientWithAccount, {
+      to: '0x30D861999070Ae03B9548501DBd573E11A9f59Ee',
+      amount: 600n,
+      token: tokenAddress,
+      feeToken: tokenAddress,
+    })
+
+    let eventArgs: any = null
+    const unwatch = Actions.amm.watchBurn(clientWithAccount, {
+      onBurn: (args) => {
+        eventArgs = args
+      },
+    })
+
+    // Burn LP tokens
+    await Actions.amm.burnSync(clientWithAccount, {
+      userToken: tokenAddress,
+      validatorToken: 1n,
+      liquidity: lpBalance / 2n,
+      to: account.address,
+    })
+
+    await setTimeout(1000)
+
+    expect(eventArgs).toBeDefined()
+    expect(eventArgs.userToken.toLowerCase()).toBe(tokenAddress.toLowerCase())
+    expect(eventArgs.validatorToken.toLowerCase()).toBe(
+      '0x20c0000000000000000000000000000000000001',
+    )
+    expect(eventArgs.liquidity).toBe(lpBalance / 2n)
+
+    unwatch()
+  })
+})

package/src/viem/Actions/amm.ts

@@ -456,14 +456,9 @@ export namespace rebalanceSwapSync {
  * })
  *
  * const hash = await Actions.amm.mint(client, {
- *   userToken: {
- *     address: '0x20c0...beef',
- *     amount: 100n,
- *   },
- *   validatorToken: {
- *     address: '0x20c0...babe',
- *     amount: 100n,
- *   },
+ *   userTokenAddress: '0x20c0...beef',
+ *   validatorTokenAddress: '0x20c0...babe',
+ *   validatorTokenAmount: 100n,
  *   to: '0xfeed...fede',
  * })
  * ```
@@ -552,25 +547,15 @@ export namespace mint {
    * const { result } = await client.sendCalls({
    *   calls: [
    *     actions.amm.mint.call({
-   *       userToken: {
-   *         address: '0x20c0...beef',
-   *         amount: 100n,
-   *       },
-   *       validatorToken: {
-   *         address: '0x20c0...babe',
-   *         amount: 100n,
-   *       },
+   *       userTokenAddress: '0x20c0...beef',
+   *       validatorTokenAddress: '0x20c0...babe',
+   *       validatorTokenAmount: 100n,
    *       to: '0xfeed...fede',
    *     }),
    *     actions.amm.mint.call({
-   *       userToken: {
-   *         address: '0x20c0...babe',
-   *         amount: 100n,
-   *       },
-   *       validatorToken: {
-   *         address: '0x20c0...babe',
-   *         amount: 100n,
-   *       },
+   *       userTokenAddress: '0x20c0...babe',
+   *       validatorTokenAddress: '0x20c0...babe',
+   *       validatorTokenAmount: 100n,
    *       to: '0xfeed...fede',
    *     }),
    *   ]
@@ -635,14 +620,9 @@ export namespace mint {
  * })
  *
  * const hash = await Actions.amm.mint(client, {
- *   userToken: {
- *     address: '0x20c0...beef',
- *     amount: 100n,
- *   },
- *   validatorToken: {
- *     address: '0x20c0...babe',
- *     amount: 100n,
- *   },
+ *   userTokenAddress: '0x20c0...beef',
+ *   validatorTokenAddress: '0x20c0...babe',
+ *   validatorTokenAmount: 100n,
  *   to: '0xfeed...fede',
  * })
  * ```

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

@@ -349,7 +349,7 @@ describe('getMetadata', () => {
         "name": "Test USD",
         "paused": false,
         "quoteToken": "0x20C0000000000000000000000000000000000000",
-        "supplyCap": 115792089237316195423570985008687907853269984665640564039457584007913129639935n,
+        "supplyCap": 340282366920938463463374607431768211455n,
         "symbol": "TUSD",
         "totalSupply": 0n,
         "transferPolicyId": 1n,
@@ -360,15 +360,15 @@ describe('getMetadata', () => {
   test('behavior: quote token', async () => {
     {
       const metadata = await actions.token.getMetadata(clientWithAccount, {
-        token: TokenIds.linkingUsd,
+        token: TokenIds.pathUsd,
       })
 
       expect(metadata).toMatchInlineSnapshot(`
         {
           "currency": "USD",
           "decimals": 6,
-          "name": "linkingUSD",
-          "symbol": "linkingUSD",
+          "name": "pathUSD",
+          "symbol": "pathUSD",
           "totalSupply": 18446744073709551615n,
         }
       `)
@@ -376,15 +376,15 @@ describe('getMetadata', () => {
 
     {
       const metadata = await actions.token.getMetadata(clientWithAccount, {
-        token: Addresses.linkingUsd,
+        token: Addresses.pathUsd,
       })
 
       expect(metadata).toMatchInlineSnapshot(`
         {
           "currency": "USD",
           "decimals": 6,
-          "name": "linkingUSD",
-          "symbol": "linkingUSD",
+          "name": "pathUSD",
+          "symbol": "pathUSD",
           "totalSupply": 18446744073709551615n,
         }
       `)
@@ -409,7 +409,7 @@ describe('getMetadata', () => {
         "name": "Test USD",
         "paused": false,
         "quoteToken": "0x20C0000000000000000000000000000000000000",
-        "supplyCap": 115792089237316195423570985008687907853269984665640564039457584007913129639935n,
+        "supplyCap": 340282366920938463463374607431768211455n,
         "symbol": "TUSD",
         "totalSupply": 0n,
         "transferPolicyId": 1n,

package/src/viem/Actions/token.ts

@@ -998,7 +998,7 @@ export namespace create {
       name,
       symbol,
       currency,
-      quoteToken = Addresses.linkingUsd,
+      quoteToken = Addresses.pathUsd,
       admin,
     } = args
     return defineCall({
@@ -1285,7 +1285,7 @@ export async function getMetadata<chain extends Chain | undefined>(
   const address = TokenId.toAddress(token)
   const abi = Abis.tip20
 
-  if (TokenId.from(token) === TokenId.fromAddress(Addresses.linkingUsd))
+  if (TokenId.from(token) === TokenId.fromAddress(Addresses.pathUsd))
     return multicall(client, {
       ...rest,
       contracts: [

package/src/viem/Addresses.ts

@@ -2,7 +2,7 @@ export const accountImplementation =
   '0x7702c00000000000000000000000000000000000'
 export const accountRegistrar = '0x7702ac0000000000000000000000000000000000'
 export const feeManager = '0xfeec000000000000000000000000000000000000'
-export const linkingUsd = '0x20c0000000000000000000000000000000000000'
+export const pathUsd = '0x20c0000000000000000000000000000000000000'
 export const stablecoinExchange = '0xdec0000000000000000000000000000000000000'
 export const tip20Factory = '0x20fc000000000000000000000000000000000000'
 export const tip403Registry = '0x403c000000000000000000000000000000000000'

package/src/viem/Chain.test.ts

@@ -0,0 +1,168 @@
+import {
+  getTransaction,
+  prepareTransactionRequest,
+  sendTransactionSync,
+} from 'viem/actions'
+import { describe, expect, test, vi } from 'vitest'
+import { chain, client, clientWithAccount } from '../../test/viem/config.js'
+
+describe('chain.prepareTransactionRequest', () => {
+  test('behavior: sequential nonce keys for feePayer transactions', async () => {
+    const requests = await Promise.all([
+      chain.prepareTransactionRequest({ feePayer: true } as never),
+      chain.prepareTransactionRequest({ feePayer: true } as never),
+      chain.prepareTransactionRequest({ feePayer: true } as never),
+    ])
+
+    expect((requests[0] as any)?.nonceKey).toBe(0n)
+    expect((requests[1] as any)?.nonceKey).toBeGreaterThan(0n)
+    expect((requests[2] as any)?.nonceKey).toBeGreaterThan(0n)
+  })
+
+  test('behavior: nonce key counter resets after event loop tick', async () => {
+    const requests1 = await Promise.all([
+      chain.prepareTransactionRequest({ feePayer: true } as never),
+      chain.prepareTransactionRequest({ feePayer: true } as never),
+    ])
+
+    expect((requests1[0] as any)?.nonceKey).toBe(0n)
+    expect((requests1[1] as any)?.nonceKey).toBeGreaterThan(0n)
+
+    // Wait for microtask queue to flush
+    await new Promise((resolve) => queueMicrotask(() => resolve(undefined)))
+
+    const requests2 = await Promise.all([
+      chain.prepareTransactionRequest({ feePayer: true } as never),
+      chain.prepareTransactionRequest({ feePayer: true } as never),
+    ])
+
+    // Counter should have reset
+    expect((requests2[0] as any)?.nonceKey).toBe(0n)
+    expect((requests2[1] as any)?.nonceKey).toBeGreaterThan(0n)
+  })
+
+  test('behavior: explicit nonceKey overrides counter', async () => {
+    const requests = await Promise.all([
+      chain.prepareTransactionRequest({
+        feePayer: true,
+        nonceKey: 42n,
+      } as never),
+      chain.prepareTransactionRequest({ feePayer: true } as never),
+      chain.prepareTransactionRequest({
+        feePayer: true,
+        nonceKey: 100n,
+      } as never),
+    ])
+
+    expect((requests[0] as any)?.nonceKey).toBe(42n)
+    expect((requests[1] as any)?.nonceKey).toBe(0n)
+    expect((requests[2] as any)?.nonceKey).toBe(100n)
+  })
+
+  test('behavior: default nonceKey when feePayer is not true', async () => {
+    const request = await chain.prepareTransactionRequest({} as never)
+    expect((request as any)?.nonceKey).toBe(0n)
+  })
+
+  test('behavior: nonce with sequential nonceKey', async () => {
+    const requests = await Promise.all([
+      chain.prepareTransactionRequest({ feePayer: true } as never), // nonceKey: 0n
+      chain.prepareTransactionRequest({ feePayer: true } as never), // nonceKey: 1n
+      chain.prepareTransactionRequest({ feePayer: true } as never), // nonceKey: 2n
+    ])
+
+    // Note: 0n is falsy, so first request has nonce undefined
+    expect((requests[0] as any)?.nonce).toBe(undefined)
+    expect((requests[0] as any)?.nonceKey).toBe(0n)
+
+    // nonceKey >= 1n is truthy, so nonce is 0
+    expect((requests[1] as any)?.nonce).toBe(0)
+    expect((requests[1] as any)?.nonceKey).toBeGreaterThan(0n)
+
+    expect((requests[2] as any)?.nonce).toBe(0)
+    expect((requests[2] as any)?.nonceKey).toBeGreaterThan(0n)
+  })
+
+  test('behavior: explicit nonce is preserved', async () => {
+    const request = await chain.prepareTransactionRequest({
+      feePayer: true,
+      nonce: 123,
+    } as never)
+    expect((request as any)?.nonce).toBe(123)
+    expect((request as any)?.nonceKey).toBe(0n)
+  })
+
+  test('behavior: default nonceKey is 0n (falsy)', async () => {
+    const request = await chain.prepareTransactionRequest({} as never)
+    expect((request as any)?.nonceKey).toBe(0n)
+    expect((request as any)?.nonce).toBe(undefined)
+  })
+
+  test('behavior: resetScheduled optimization - only one microtask scheduled', async () => {
+    const queueMicrotaskSpy = vi.spyOn(globalThis, 'queueMicrotask')
+    const callCountBefore = queueMicrotaskSpy.mock.calls.length
+
+    // Prepare multiple transactions in parallel
+    await Promise.all([
+      chain.prepareTransactionRequest({ feePayer: true } as never),
+      chain.prepareTransactionRequest({ feePayer: true } as never),
+      chain.prepareTransactionRequest({ feePayer: true } as never),
+      chain.prepareTransactionRequest({ feePayer: true } as never),
+      chain.prepareTransactionRequest({ feePayer: true } as never),
+    ])
+
+    const callCountAfter = queueMicrotaskSpy.mock.calls.length
+
+    // Only one microtask should have been scheduled for the reset
+    expect(callCountAfter - callCountBefore).toBe(1)
+
+    queueMicrotaskSpy.mockRestore()
+  })
+
+  describe('e2e', async () => {
+    test('behavior: prepareTransactionRequest', async () => {
+      const [request, request2, request3] = await Promise.all([
+        prepareTransactionRequest(client, {
+          to: '0x0000000000000000000000000000000000000000',
+        }),
+        prepareTransactionRequest(client, {
+          to: '0x0000000000000000000000000000000000000000',
+        }),
+        prepareTransactionRequest(client, {
+          to: '0x0000000000000000000000000000000000000000',
+        }),
+      ])
+      expect(request.nonceKey).toBe(0n)
+      expect(request2.nonceKey).toBeGreaterThan(0n)
+      expect(request3.nonceKey).toBeGreaterThan(0n)
+    })
+
+    test('behavior: sendTransaction', async () => {
+      const receipts = await Promise.all([
+        sendTransactionSync(clientWithAccount, {
+          to: '0x0000000000000000000000000000000000000000',
+        }),
+        sendTransactionSync(clientWithAccount, {
+          to: '0x0000000000000000000000000000000000000001',
+        }),
+        sendTransactionSync(clientWithAccount, {
+          to: '0x0000000000000000000000000000000000000002',
+        }),
+      ])
+      const transactions = await Promise.all([
+        getTransaction(clientWithAccount, {
+          hash: receipts[0].transactionHash,
+        }),
+        getTransaction(clientWithAccount, {
+          hash: receipts[1].transactionHash,
+        }),
+        getTransaction(clientWithAccount, {
+          hash: receipts[2].transactionHash,
+        }),
+      ])
+      expect(transactions[0].nonceKey).toBe(0n)
+      expect(transactions[1].nonceKey).toBeGreaterThan(0n)
+      expect(transactions[2].nonceKey).toBeGreaterThan(0n)
+    })
+  })
+})

package/src/viem/Chain.ts

@@ -1,3 +1,4 @@
+import * as Hex from 'ox/Hex'
 import {
   defineTransaction,
   defineTransactionReceipt,
@@ -25,6 +26,25 @@ export type Chain<
       })
 
 function config<const chain extends Chain>(chain: chain) {
+  const nonceKeyManager = {
+    counter: 0,
+    resetScheduled: false,
+    reset() {
+      this.counter = 0
+      this.resetScheduled = false
+    },
+    get() {
+      if (!this.resetScheduled) {
+        this.resetScheduled = true
+        queueMicrotask(() => this.reset())
+      }
+      const count = this.counter
+      this.counter++
+      if (count === 0) return 0n
+      return Hex.toBigInt(Hex.random(6))
+    },
+  }
+
   return {
     blockTime: 1_000,
     contracts: {
@@ -66,6 +86,22 @@ function config<const chain extends Chain>(chain: chain) {
           ),
       }),
     },
+    async prepareTransactionRequest(r) {
+      const request = r as Transaction.TransactionRequest
+      const nonceKey = (() => {
+        if (typeof request.nonceKey !== 'undefined') return request.nonceKey
+        return nonceKeyManager.get()
+      })()
+
+      const nonce = (() => {
+        if (typeof request.nonce === 'number') return request.nonce
+        // TODO: remove this line once `eth_fillTransaction` supports nonce keys.
+        if (nonceKey) return 0
+        return undefined
+      })()
+
+      return { ...request, nonce, nonceKey } as unknown as typeof r
+    },
     serializers: {
       // TODO: casting to satisfy viem – viem v3 to have more flexible serializer type.
       transaction: ((transaction, signature) =>
@@ -88,7 +124,7 @@ function config<const chain extends Chain>(chain: chain) {
         )) as SerializeTransactionFn,
     },
     ...chain,
-  } as const
+  } as const satisfies viem_Chain
 }
 
 export function define<const chain extends viem_Chain>(