tempo.ts 0.6.2 → 0.7.1

package/src/viem/e2e.test.ts

@@ -41,6 +41,8 @@ describe('sendTransaction', () => {
         gas,
         gasPrice,
         hash: hash_,
+        // @ts-expect-error
+        keyAuthorization: __,
         maxFeePerGas,
         maxPriorityFeePerGas,
         nonce,
@@ -115,6 +117,8 @@ describe('sendTransaction', () => {
         gas,
         gasPrice,
         hash: hash_,
+        // @ts-expect-error
+        keyAuthorization: __,
         maxFeePerGas,
         maxPriorityFeePerGas,
         nonce,
@@ -178,6 +182,8 @@ describe('sendTransaction', () => {
         gas,
         gasPrice,
         hash: hash_,
+        // @ts-expect-error
+        keyAuthorization: __,
         maxFeePerGas,
         maxPriorityFeePerGas,
         nonce,
@@ -251,6 +257,8 @@ describe('sendTransaction', () => {
         gas,
         gasPrice,
         hash,
+        // @ts-expect-error
+        keyAuthorization: __,
         maxFeePerGas,
         maxPriorityFeePerGas,
         nonce,
@@ -333,6 +341,8 @@ describe('sendTransaction', () => {
         gas,
         gasPrice,
         hash,
+        // @ts-expect-error
+        keyAuthorization: __,
         maxFeePerGas,
         maxPriorityFeePerGas,
         nonce,
@@ -401,6 +411,8 @@ describe('sendTransaction', () => {
         gas,
         gasPrice,
         hash: hash_,
+        // @ts-expect-error
+        keyAuthorization: __,
         maxFeePerGas,
         maxPriorityFeePerGas,
         nonce,
@@ -472,6 +484,8 @@ describe('sendTransaction', () => {
         from,
         gasPrice,
         hash,
+        // @ts-expect-error
+        keyAuthorization: __,
         maxFeePerGas,
         maxPriorityFeePerGas,
         nonce,
@@ -553,6 +567,8 @@ describe('sendTransaction', () => {
         gas,
         gasPrice,
         hash,
+        // @ts-expect-error
+        keyAuthorization: __,
         maxFeePerGas,
         maxPriorityFeePerGas,
         nonce,
@@ -596,6 +612,8 @@ describe('sendTransaction', () => {
         from,
         gasPrice,
         hash: hash_,
+        // @ts-expect-error
+        keyAuthorization: __,
         maxFeePerGas,
         maxPriorityFeePerGas,
         nonce,
@@ -644,6 +662,8 @@ describe('sendTransaction', () => {
         gas,
         gasPrice,
         hash,
+        // @ts-expect-error
+        keyAuthorization: __,
         maxFeePerGas,
         maxPriorityFeePerGas,
         nonce,
@@ -730,6 +750,8 @@ describe('sendTransaction', () => {
         gas,
         gasPrice,
         hash,
+        // @ts-expect-error
+        keyAuthorization: __,
         maxFeePerGas,
         maxPriorityFeePerGas,
         nonce,
@@ -802,6 +824,8 @@ describe('sendTransaction', () => {
         gas,
         gasPrice,
         hash: hash_,
+        // @ts-expect-error
+        keyAuthorization: __,
         maxFeePerGas,
         maxPriorityFeePerGas,
         nonce,
@@ -888,6 +912,8 @@ describe('signTransaction', () => {
       from,
       gasPrice,
       hash: hash_,
+      // @ts-expect-error
+      keyAuthorization: __,
       maxFeePerGas,
       maxPriorityFeePerGas,
       nonce,
@@ -943,6 +969,7 @@ describe('relay', () => {
     transport: withFeePayer(
       http(undefined, { fetchOptions }),
       http('http://localhost:3050'),
+      { policy: 'sign-and-broadcast' },
     ),
   })
     .extend(tempoActions())
@@ -963,7 +990,9 @@ describe('relay', () => {
 
         const request = RpcRequest.from(await r.json())
 
+        // Validate method
         if (
+          (request as any).method !== 'eth_signRawTransaction' &&
           request.method !== 'eth_sendRawTransaction' &&
           request.method !== 'eth_sendRawTransactionSync'
         )
@@ -972,7 +1001,7 @@ describe('relay', () => {
               {
                 error: new RpcResponse.InvalidParamsError({
                   message:
-                    'service only supports `eth_sendRawTransaction` and `eth_sendRawTransactionSync`',
+                    'service only supports `eth_signTransaction`, `eth_sendRawTransaction`, and `eth_sendRawTransactionSync`',
                 }),
               },
               { request },
@@ -985,7 +1014,7 @@ describe('relay', () => {
             RpcResponse.from(
               {
                 error: new RpcResponse.InvalidParamsError({
-                  message: 'service only supports `0x77` transactions',
+                  message: 'service only supports `0x76` transactions',
                 }),
               },
               { request },
@@ -997,10 +1026,20 @@ describe('relay', () => {
           ...transaction,
           feePayer: client.account,
         })
+
+        // Handle based on RPC method
+        if ((request as any).method === 'eth_signRawTransaction') {
+          // Policy: 'sign-only' - Return signed transaction without broadcasting
+          return Response.json(
+            RpcResponse.from({ result: serializedTransaction }, { request }),
+          )
+        }
+
+        // Policy: 'sign-and-broadcast' - Sign, broadcast, and return hash
         const result = await client.request({
           method: request.method,
           params: [serializedTransaction],
-        })
+        } as never)
 
         return Response.json(RpcResponse.from({ result }, { request }))
       }),
@@ -1050,6 +1089,8 @@ describe('relay', () => {
         gas,
         gasPrice,
         hash,
+        // @ts-expect-error
+        keyAuthorization: __,
         maxFeePerGas,
         maxPriorityFeePerGas,
         nonce,
@@ -1129,6 +1170,8 @@ describe('relay', () => {
         gas,
         gasPrice,
         hash,
+        // @ts-expect-error
+        keyAuthorization: __,
         maxFeePerGas,
         maxPriorityFeePerGas,
         nonce,
@@ -1239,6 +1282,8 @@ describe('relay', () => {
         gas,
         gasPrice,
         hash,
+        // @ts-expect-error
+        keyAuthorization: __,
         maxFeePerGas,
         maxPriorityFeePerGas,
         nonce,
@@ -1288,4 +1333,62 @@ describe('relay', () => {
       `)
     })
   })
+
+  describe('policy: sign-only', () => {
+    test('relay co-signs and transport auto-submits', async () => {
+      const signClient = getClient({
+        transport: withFeePayer(
+          http(undefined, { fetchOptions }),
+          http('http://localhost:3050'),
+          { policy: 'sign-only' },
+        ),
+      })
+        .extend(tempoActions())
+        .extend(walletActions)
+        .extend(publicActions)
+
+      // unfunded account that needs sponsorship
+      const account = privateKeyToAccount(
+        '0xecc3fe55647412647e5c6b657c496803b08ef956f927b7a821da298cfbdd9666',
+      )
+
+      // With 'sign-only' policy, the relay co-signs and the transport auto-submits
+      const { user, token, receipt } = await signClient.fee.setUserTokenSync({
+        account,
+        feePayer: true,
+        token: 1n,
+      })
+
+      // Verify the action returned the expected values
+      expect(user).toBe(account.address)
+      expect(token).toBe('0x20C0000000000000000000000000000000000001')
+      expect(receipt).toBeDefined()
+
+      // Verify the transaction was successfully executed
+      const userToken = await signClient.fee.getUserToken({
+        account: account.address,
+      })
+      expect(userToken?.id).toBe(1n)
+
+      const {
+        feePayerSignature,
+        from,
+        gas,
+        gasPrice,
+        maxFeePerGas,
+        maxPriorityFeePerGas,
+        signature,
+      } = (await signClient.getTransaction({
+        hash: receipt.transactionHash,
+      })) as any
+
+      expect(feePayerSignature).toBeDefined()
+      expect(from).toBe(account.address.toLowerCase())
+      expect(gas).toBeDefined()
+      expect(gasPrice).toBeDefined()
+      expect(maxFeePerGas).toBeDefined()
+      expect(maxPriorityFeePerGas).toBeDefined()
+      expect(signature).toBeDefined()
+    })
+  })
 })

package/src/viem/internal/utils.ts

@@ -35,3 +35,24 @@ export function defineCall<
     to: call.address,
   } as const
 }
+
+/**
+ * Normalizes a value into a structured-clone compatible format.
+ *
+ * @see https://developer.mozilla.org/en-US/docs/Web/API/Window/structuredClone
+ */
+export function normalizeValue<type>(value: type): type {
+  if (Array.isArray(value)) return value.map(normalizeValue) as never
+  if (typeof value === 'function') return undefined as never
+  if (typeof value !== 'object' || value === null) return value
+  if (Object.getPrototypeOf(value) !== Object.prototype)
+    try {
+      return structuredClone(value)
+    } catch {
+      return undefined as never
+    }
+
+  const normalized: Record<string, unknown> = {}
+  for (const [k, v] of Object.entries(value)) normalized[k] = normalizeValue(v)
+  return normalized as never
+}

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

@@ -1,8 +1,8 @@
-import { connect, getConnectorClient } from '@wagmi/core'
+import { connect } from '@wagmi/core'
 import { parseUnits } from 'viem'
 import { describe, expect, test } from 'vitest'
 import { addresses } from '../../../test/config.js'
-import { accounts, setupPoolWithLiquidity } from '../../../test/viem/config.js'
+import { accounts } from '../../../test/viem/config.js'
 import { config, queryClient } from '../../../test/wagmi/config.js'
 import * as ammActions from './amm.js'
 import * as tokenActions from './token.js'
@@ -96,23 +96,18 @@ describe('mintSync', () => {
     const { receipt: mintReceipt, ...mintResult } = await ammActions.mintSync(
       config,
       {
-        userToken: {
-          address: token,
-          amount: parseUnits('100', 6),
-        },
-        validatorToken: {
-          address: addresses.alphaUsd,
-          amount: parseUnits('100', 6),
-        },
+        userTokenAddress: token,
+        validatorTokenAddress: addresses.alphaUsd,
+        validatorTokenAmount: parseUnits('100', 6),
         to: account.address,
       },
     )
     expect(mintReceipt).toBeDefined()
     expect(mintResult).toMatchInlineSnapshot(`
       {
-        "amountUserToken": 100000000n,
+        "amountUserToken": 0n,
         "amountValidatorToken": 100000000n,
-        "liquidity": 4999999999999000n,
+        "liquidity": 49999000n,
         "sender": "0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266",
         "userToken": "0x20C0000000000000000000000000000000000004",
         "validatorToken": "0x20C0000000000000000000000000000000000001",
@@ -120,76 +115,3 @@ describe('mintSync', () => {
     `)
   })
 })
-
-describe('burnSync', () => {
-  test('default', async () => {
-    await connect(config, {
-      connector: config.connectors[0]!,
-    })
-
-    const client = await getConnectorClient(config)
-    const { tokenAddress } = await setupPoolWithLiquidity(client)
-
-    // Get LP balance before burn
-    const lpBalanceBefore = await ammActions.getLiquidityBalance(config, {
-      userToken: tokenAddress,
-      validatorToken: addresses.alphaUsd,
-      address: account.address,
-    })
-
-    // Burn half of LP tokens
-    const { receipt: burnReceipt, ...burnResult } = await ammActions.burnSync(
-      config,
-      {
-        userToken: tokenAddress,
-        validatorToken: addresses.alphaUsd,
-        liquidity: lpBalanceBefore / 2n,
-        to: account.address,
-      },
-    )
-    expect(burnReceipt).toBeDefined()
-    expect(burnResult).toMatchInlineSnapshot(`
-      {
-        "amountUserToken": 49999999n,
-        "amountValidatorToken": 49999999n,
-        "liquidity": 2499999999999500n,
-        "sender": "0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266",
-        "to": "0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266",
-        "userToken": "0x20c0000000000000000000000000000000000005",
-        "validatorToken": "0x20C0000000000000000000000000000000000001",
-      }
-    `)
-  })
-})
-
-describe('rebalanceSwapSync', () => {
-  test('default', async () => {
-    await connect(config, {
-      connector: config.connectors[0]!,
-    })
-
-    const client = await getConnectorClient(config)
-    const { tokenAddress } = await setupPoolWithLiquidity(client)
-
-    const account2 = accounts[1]
-
-    // Perform rebalance swap
-    const { receipt: swapReceipt, ...swapResult } =
-      await ammActions.rebalanceSwapSync(config, {
-        userToken: tokenAddress,
-        validatorToken: addresses.alphaUsd,
-        amountOut: parseUnits('10', 6),
-        to: account2.address,
-      })
-    expect(swapReceipt).toBeDefined()
-    expect(swapResult).toMatchInlineSnapshot(`
-      {
-        "amountIn": 9985001n,
-        "amountOut": 10000000n,
-        "swapper": "0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266",
-        "userToken": "0x20C0000000000000000000000000000000000006",
-        "validatorToken": "0x20C0000000000000000000000000000000000001",
-      }
-    `)
-  })
-})

package/src/wagmi/Actions/reward.test.ts

@@ -5,31 +5,6 @@ import { config, queryClient, setupToken } from '../../../test/wagmi/config.js'
 import * as actions from './reward.js'
 import * as tokenActions from './token.js'
 
-describe('cancelSync', () => {
-  test('default', async () => {
-    const { token } = await setupToken()
-
-    // Start a reward stream
-    const rewardAmount = parseUnits('100', 6)
-    const { id: streamId } = await actions.startSync(config, {
-      amount: rewardAmount,
-      seconds: 3600,
-      token,
-    })
-
-    // Cancel the reward
-    const { receipt, refund, ...result } = await actions.cancelSync(config, {
-      id: streamId,
-      token,
-    })
-
-    expect(refund).toBeGreaterThan(0n)
-    expect(receipt).toBeDefined()
-    expect(result.funder).toBeDefined()
-    expect(result.id).toBe(streamId)
-  })
-})
-
 // TODO: unskip
 describe.skip('claimSync', () => {
   test('default', async () => {
@@ -59,7 +34,6 @@ describe.skip('claimSync', () => {
     // Start immediate reward
     await actions.startSync(config, {
       amount: rewardAmount,
-      seconds: 0,
       token,
     })
 
@@ -89,55 +63,6 @@ describe.skip('claimSync', () => {
   })
 })
 
-describe('getStream', () => {
-  test('default', async () => {
-    const { token } = await setupToken()
-
-    // Start a reward stream
-    const rewardAmount = parseUnits('100', 6)
-    const { id: streamId } = await actions.startSync(config, {
-      amount: rewardAmount,
-      seconds: 10,
-      token,
-    })
-
-    // Get the stream
-    const stream = await actions.getStream(config, {
-      id: streamId,
-      token,
-    })
-
-    expect(stream.funder).toBeDefined()
-    expect(stream.amountTotal).toBe(rewardAmount)
-    expect(stream.endTime).toBeGreaterThan(stream.startTime)
-    expect(stream.ratePerSecondScaled).toBeGreaterThan(0n)
-  })
-
-  describe('queryOptions', () => {
-    test('default', async () => {
-      const { token } = await setupToken()
-
-      // Start a reward stream
-      const rewardAmount = parseUnits('100', 6)
-      const { id: streamId } = await actions.startSync(config, {
-        amount: rewardAmount,
-        seconds: 10,
-        token,
-      })
-
-      const options = actions.getStream.queryOptions(config, {
-        id: streamId,
-        token,
-      })
-
-      const stream = await queryClient.fetchQuery(options)
-
-      expect(stream.funder).toBeDefined()
-      expect(stream.amountTotal).toBe(rewardAmount)
-    })
-  })
-})
-
 describe('getTotalPerSecond', () => {
   test('default', async () => {
     const { token } = await setupToken()
@@ -184,27 +109,3 @@ describe('setRecipientSync', () => {
     expect(recipient).toBe(account.address)
   })
 })
-
-describe('startSync', () => {
-  test('default', async () => {
-    const { token } = await setupToken()
-
-    const account = getAccount(config)
-
-    // Start a reward stream
-    const rewardAmount = parseUnits('100', 6)
-    const duration = 10
-    const { amount, durationSeconds, funder, id, receipt } =
-      await actions.startSync(config, {
-        amount: rewardAmount,
-        seconds: duration,
-        token,
-      })
-
-    expect(receipt).toBeDefined()
-    expect(funder).toBe(account.address)
-    expect(id).toBeGreaterThan(0n)
-    expect(amount).toBe(rewardAmount)
-    expect(durationSeconds).toBe(duration)
-  })
-})