tapimo 0.10.1 → 0.11.0

package/src/apps/data/routes/activities.test.ts

@@ -35,8 +35,6 @@ const liveAccounts = {
   channel: '0x5217c502adf3c96a9551770af4caa5f5144a6984',
   // TokenCreated + Mint + Transfer.
   creator: '0x253fb3bf1e3d75ad6ee1554f68f4ea0568f7d24e',
-  // Token burns.
-  burner: '0x69519497b59bd64e109d993157d45f14455cc7e6',
   // KeyAuthorized + KeyRevoked + Approval (+ transfer/mint/exchange).
   keychain: '0xfe776fd28e06ecc71a157398b2c9991318f1ea2e',
   // Swaps through the stablecoin DEX (output kept, so it stays a plain `swap`).
@@ -50,27 +48,29 @@ const accounts =
     ? {
         channel: localAccounts.keychain,
         creator: localAccounts.creator,
-        burner: localAccounts.burner,
         keychain: localAccounts.keychain,
         swapper: localAccounts.swapper,
       }
     : liveAccounts
 
-/** The account expected to surface each activity type. */
+/**
+ * The account expected to surface each activity type. Burns are seeded per run
+ * instead: a live burner keeps accruing activity until its last burn falls off
+ * the first page.
+ */
 const coverage =
-  runtime.mode === 'localnet'
+  runtime.mode === 'localnet' && localAccounts
     ? {
-        approval: accounts.keychain,
-        burn: accounts.burner,
-        mint: accounts.creator,
-        'token-created': accounts.creator,
-        transfer: accounts.creator,
+        approval: localAccounts.keychain,
+        burn: localAccounts.burner,
+        mint: localAccounts.creator,
+        'token-created': localAccounts.creator,
+        transfer: localAccounts.creator,
       }
     : {
         'access-key-created': accounts.keychain,
         'access-key-revoked': accounts.keychain,
         approval: accounts.keychain,
-        burn: accounts.burner,
         mint: accounts.creator,
         'session-closed': accounts.channel,
         swap: accounts.swapper,
@@ -165,6 +165,54 @@ describe('GET /addresses/:address/activities', () => {
     expect(find(body.data, type)).toBeDefined()
   })
 
+  // Localnet seeds its burner through the shared fixtures, so this covers the
+  // hosted testnet, where no address stays burn-topped for long.
+  test.skipIf(runtime.mode === 'localnet')(
+    'classifies a seeded burn',
+    async () => {
+      const account = Tempo.accounts[11]
+      const wallet = Tempo.getClient({ account })
+      await Actions.faucet.fundSync(Tempo.client, { account, timeout: 60_000 })
+
+      // Burning needs the `issuer` role, so the account burns a token it owns.
+      const { token } = await Actions.token.createSync(wallet, {
+        currency: 'USD',
+        name: 'Seeded Burn USD',
+        symbol: 'SBUSD',
+      })
+      await sendTransactionSync(wallet, {
+        account,
+        calls: [
+          Actions.token.grantRoles.call(wallet, { role: 'issuer', to: account.address, token }),
+          Actions.token.mint.call(wallet, { amount: 1_000_000n, to: account.address, token }),
+        ],
+      })
+      const { receipt } = await Actions.token.burnSync(wallet, { amount: 100_000n, token })
+
+      const deadline = Date.now() + 90_000
+      let burn: Activities.Entry | undefined
+      while (Date.now() < deadline) {
+        const response = await client.v1.addresses[':address'].activities.$get(
+          { param: { address: account.address }, query: { limit: '50' } },
+          { headers: { 'cache-control': 'no-store', ...TestApp.auth.headers } },
+        )
+        if (response.status === 200) {
+          const body = await TestApp.json(response, Activities.schema.getAddressActivities.Response)
+          burn = find(body.data, 'burn')
+          if (burn?.type === 'burn' && burn.transactionHash === receipt.transactionHash) break
+        }
+        await new Promise((resolve) => setTimeout(resolve, 500))
+      }
+      expect(burn?.type).toBe('burn')
+      if (burn?.type !== 'burn') return
+      expect(burn.transactionHash).toBe(receipt.transactionHash)
+      expect(burn.data.sender.toLowerCase()).toBe(account.address.toLowerCase())
+      expect(burn.data.sourceToken.address.toLowerCase()).toBe(token.toLowerCase())
+      expect(burn.data.sourceAmount.baseUnits).toBe('100000')
+    },
+    180_000,
+  )
+
   test('transfer data mirrors the `Transfer` resource', async () => {
     const transfer = find((await activities(accounts.creator)).data, 'transfer')
     expect(transfer?.type).toBe('transfer')
@@ -666,6 +714,54 @@ describe('Activities.list classification', () => {
     expect(log.data).toBe('0x1234')
     expect(log.topics).toEqual([unknownSelector, pad(viewer)])
   })
+
+  test('degrades a topic-encoded approval with a fee transfer to `unknown`', async () => {
+    const approvalToken = '0x4120c7ec7e9ead9dcf44b35b5134ebdbfc6e3de9' as Address.Address
+    const feeToken = '0x20c0000000000000000000000000000000000000' as Address.Address
+    const feeManager = '0xfeec000000000000000000000000000000000000'
+    const approvalSelector = '0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925'
+    const transferSelector = '0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef'
+    const pad = (value: string) => `0x${value.slice(2).padStart(64, '0')}`
+    const txHash = '0xd2439ad8016d4ffd6aebe835734ee4d118a688714a4f9aebcc11f87a2b22e896' as Hex.Hex
+    const common = {
+      blockNum: 15_781_805,
+      blockTimestamp: 1_776_703_284,
+      feePayer: viewer,
+      source: 'q1' as const,
+      txHash,
+      txIdx: 0,
+      txSender: viewer,
+    }
+    const { items } = await Activities.list(
+      provider([
+        {
+          ...common,
+          data: '0x',
+          logAddress: approvalToken,
+          logIdx: 0,
+          selector: approvalSelector,
+          topic1: pad(viewer),
+          topic2: pad('0x6063259f720ee125e5bff693779ab8118b0118a7'),
+          topic3: '0x2a9063ed52b7d417e441f378325359c9ce274f5d6c3ecf11b7d42f24b9c90b7f',
+        },
+        {
+          ...common,
+          data: `0x${(5_815).toString(16).padStart(64, '0')}`,
+          logAddress: feeToken,
+          logIdx: 1,
+          selector: transferSelector,
+          topic1: pad(viewer),
+          topic2: pad(feeManager),
+          topic3: null,
+        },
+      ]),
+      { address: viewer, store: store() },
+    )
+
+    expect(items).toHaveLength(1)
+    expect(items[0]?.type).toBe('unknown')
+    expect(items[0]?.events).toHaveLength(2)
+  })
 })
 
 describe('Activities.list precompile classification', () => {

package/src/apps/data/routes/activities.ts

@@ -2727,15 +2727,46 @@ function classifyFromLogs(
     viewer: Address.Address
   },
 ): RawItem[] {
-  const items = classifyFromLogsCore(rows, ctx)
+  const decoded = decodeRows(rows)
+  const items = (() => {
+    try {
+      return classifyFromLogsCore(rows, ctx, decoded)
+    } catch {
+      // Indexed logs can match a known signature without satisfying that event's expected shape.
+      return [
+        unknown(ctx.itemBase(Math.min(...rows.map((row) => row.logIdx))), {
+          events: buildTxEvents(rows, decoded),
+          signer: signerForRows(rows, { fallback: ctx.signer, viewer: ctx.viewer }),
+        }),
+      ]
+    }
+  })()
   // When the caller requested raw logs, attach the full per-transaction log set
   // (decoded when possible) to every classified item so no co-located log is
   // hidden behind the headline. `unknown` items already carry it.
   if (!ctx.includeLogs) return items
-  const events = buildTxEvents(rows, decodeRows(rows))
+  const events = buildTxEvents(rows, decoded)
   return items.map((item) => (item.type === 'unknown' ? item : { ...item, events }))
 }
 
+/** Resolves an access-key signer from raw rows, falling back to the transaction signer. */
+function signerForRows(
+  rows: readonly Row[],
+  options: { fallback: 'self' | Address.Address; viewer: Address.Address },
+) {
+  const accessKeySpendRow = rows.find(
+    (row) =>
+      row.selector === accessKeySpendSelector &&
+      Address.isEqual(row.logAddress, Addresses.accountKeychain),
+  )
+  const accessKeySigner = accessKeySpendRow?.topic2
+    ? (`0x${accessKeySpendRow.topic2.slice(-40)}`.toLowerCase() as Address.Address)
+    : null
+  return accessKeySigner && !Address.isEqual(accessKeySigner, options.viewer)
+    ? accessKeySigner
+    : options.fallback
+}
+
 /** Classifies a Q1 (log-bearing) group via `parseEventLogs`, picking one headline item. */
 function classifyFromLogsCore(
   rows: Row[],
@@ -2746,24 +2777,11 @@ function classifyFromLogsCore(
     signer: 'self' | Address.Address
     viewer: Address.Address
   },
+  events = decodeRows(rows),
 ): RawItem[] {
   const { blockNum, fingerprintMap, itemBase, viewer } = ctx
 
-  // An access-key-signed tx emits AccessKeySpend at the accountKeychain; topic2
-  // is the access-key publicKey. Use it as the signer so successive access-key
-  // actions group together.
-  const accessKeySpendRow = rows.find(
-    (r) =>
-      r.selector === accessKeySpendSelector &&
-      Address.isEqual(r.logAddress, Addresses.accountKeychain),
-  )
-  const accessKeySigner = accessKeySpendRow?.topic2
-    ? (`0x${accessKeySpendRow.topic2.slice(-40)}`.toLowerCase() as Address.Address)
-    : null
-  const signer: 'self' | Address.Address =
-    accessKeySigner && !Address.isEqual(accessKeySigner, viewer) ? accessKeySigner : ctx.signer
-
-  const events = decodeRows(rows)
+  const signer = signerForRows(rows, { fallback: ctx.signer, viewer })
 
   const minLogIndex = Math.min(...rows.map((r) => r.logIdx))
 
@@ -3251,6 +3269,14 @@ function classifyFromLogsCore(
   const approvalEvent = finalEvents.find(
     (e) =>
       e.eventName === 'Approval' &&
+      // ERC-721 uses the same selector but indexes its token ID as topic3. In
+      // non-strict mode viem otherwise decodes the missing ERC-20 amount as zero.
+      rows.some(
+        (row) =>
+          row.logIdx === e.logIndex &&
+          row.topic3 === null &&
+          /^0x[0-9a-fA-F]{64}$/.test(row.data ?? ''),
+      ) &&
       !Address.isEqual((e.args as { spender: Address.Address }).spender, Addresses.zoneOutbox),
   )
   if (approvalEvent) {
@@ -4338,21 +4364,27 @@ function unknown(
 
 /** Decodes a group's raw rows into `viem/tempo` events via `parseEventLogs` (non-strict). */
 function decodeRows(rows: readonly Row[]) {
-  const viemLogs: Log[] = rows.map((r) => ({
-    address: r.logAddress as `0x${string}`,
-    blockHash: '0x0' as Hex.Hex,
-    blockNumber: BigInt(r.blockNum),
-    data: (r.data ?? '0x') as Hex.Hex,
-    logIndex: r.logIdx,
-    removed: false,
-    topics: [r.selector, r.topic1, r.topic2, r.topic3].filter(Boolean) as [Hex.Hex, ...Hex.Hex[]],
-    transactionHash: r.txHash as `0x${string}`,
-    transactionIndex: r.txIdx,
-  }))
-  return parseEventLogs({
-    abi: [...Abis.abis, ...Abis.earnRouter, ...Abis.earnVault],
-    logs: viemLogs,
-    strict: false,
+  return rows.flatMap((r) => {
+    const log: Log = {
+      address: r.logAddress as `0x${string}`,
+      blockHash: '0x0' as Hex.Hex,
+      blockNumber: BigInt(r.blockNum),
+      data: (r.data ?? '0x') as Hex.Hex,
+      logIndex: r.logIdx,
+      removed: false,
+      topics: [r.selector, r.topic1, r.topic2, r.topic3].filter(Boolean) as [Hex.Hex, ...Hex.Hex[]],
+      transactionHash: r.txHash as `0x${string}`,
+      transactionIndex: r.txIdx,
+    }
+    try {
+      return parseEventLogs({
+        abi: [...Abis.abis, ...Abis.earnRouter, ...Abis.earnVault],
+        logs: [log],
+        strict: false,
+      })
+    } catch {
+      return []
+    }
   })
 }
 

package/src/apps/data/routes/balances.ts

@@ -375,9 +375,7 @@ export function addresses(options: addresses.Options = {}) {
             ),
           )
           const client = c.get('getClient')(chainId)
-          const caller = c.get('zones').has(chainId)
-            ? (await client.zone.getZoneInfo()).sequencers[0]
-            : undefined
+          const caller = c.get('zones').has(chainId) ? address : undefined
           const [balance, feeTokens, snapshot, resolvedToken] = await Promise.all([
             Timing.time(c, 'balance_rpc', async () => {
               const call = Actions.token.getBalance.call(client, {
@@ -516,9 +514,7 @@ async function getAddressBalances(
   const correctedPromise = holdingsPromise.then(async (holdings) => {
     if (holdings.length === 0) return []
     const client = c.get('getClient')(chainId)
-    const caller = c.get('zones').has(chainId)
-      ? (await client.zone.getZoneInfo()).sequencers[0]
-      : undefined
+    const caller = c.get('zones').has(chainId) ? address : undefined
     return Timing.time(c, 'balances_rpc', async () => {
       // Concurrent reads enter viem's shared batch window and become one
       // deployless multicall. A failed read fails the request rather than serving

package/src/apps/data/routes/earn.ts

@@ -2034,6 +2034,8 @@ export async function listVaults(c: Context<App.Environment>, options: listVault
     core_EarnVaults.list(db, { chainId: options.chainId }),
     VerifiedTokens.snapshot(c, options.chainId),
   ])
+  const include = vaultInclude(options)
+  const apyByVault = new Map<string, EarnRates.Apy | null>()
   const registry = new Map(records.map((record) => [record.vaultAddress.toLowerCase(), record]))
   const decoded = options.cursor ? Cursor.decode(options.cursor, ['int', 'int']) : undefined
   let position = decoded
@@ -2062,22 +2064,44 @@ export async function listVaults(c: Context<App.Environment>, options: listVault
     }
     scanned += page.items.length
 
-    const discovered = await Promise.all(
-      page.items.map(async (item) => {
-        const record = registry.get(item.vaultAddress.toLowerCase())
-        try {
-          const discovery = await resolveVaultDiscovery(c, {
+    const apyVaults =
+      apyByVault.size === 0 &&
+      include.includes('apy') &&
+      options.capability.length === 0 &&
+      options['engine.type'] === undefined
+        ? page.items
+            .slice(0, options.limit - matches.length)
+            .map(({ vaultAddress }) => vaultAddress)
+        : []
+    // Rate boundaries and historical quotes depend only on candidate addresses,
+    // so the unfiltered page can resolve them alongside live vault discovery.
+    const [discovered, prefetchedApy] = await Promise.all([
+      Promise.all(
+        page.items.map(async (item) => {
+          const record = registry.get(item.vaultAddress.toLowerCase())
+          try {
+            const discovery = await resolveVaultDiscovery(c, {
+              chainId: options.chainId,
+              include: discoveryInclude(options),
+              vaultAddress: item.vaultAddress,
+            })
+            return { discovery, position: item.position, record }
+          } catch (cause) {
+            if (!record && isIncompatible(cause)) return undefined
+            throw cause
+          }
+        }),
+      ),
+      apyVaults.length > 0
+        ? resolvePageApy(c, {
             chainId: options.chainId,
-            include: discoveryInclude(options),
-            vaultAddress: item.vaultAddress,
+            include,
+            vaults: apyVaults,
+            window: options['apy.window'],
           })
-          return { discovery, position: item.position, record }
-        } catch (cause) {
-          if (!record && isIncompatible(cause)) return undefined
-          throw cause
-        }
-      }),
-    )
+        : undefined,
+    ])
+    for (const [vault, apy] of prefetchedApy ?? []) apyByVault.set(vault, apy)
     for (const match of discovered) {
       if (!match || !matchesVaultFilters(match.discovery, options)) continue
       matches.push(match)
@@ -2089,17 +2113,25 @@ export async function listVaults(c: Context<App.Environment>, options: listVault
 
   const page = matches.slice(0, options.limit)
   const discoveries = page.map(({ discovery }) => discovery)
-  const include = vaultInclude(options)
-  const [apy, rates, tokens] = await Promise.all([
-    resolvePageApy(c, {
-      chainId: options.chainId,
-      discoveries,
-      include,
-      window: options['apy.window'],
-    }),
+  const missingApyVaults = include.includes('apy')
+    ? discoveries.flatMap(({ vaultAddress }) =>
+        apyByVault.has(vaultAddress.toLowerCase()) ? [] : [vaultAddress],
+      )
+    : []
+  const [missingApy, rates, tokens] = await Promise.all([
+    missingApyVaults.length > 0
+      ? resolvePageApy(c, {
+          chainId: options.chainId,
+          include,
+          vaults: missingApyVaults,
+          window: options['apy.window'],
+        })
+      : undefined,
     resolvePageRates(c, { discoveries, include, oracle: options.oracle, snapshot }),
     resolvePageTokens(c, { chainId: options.chainId, discoveries, include, snapshot }),
   ])
+  for (const [vault, apy] of missingApy ?? []) apyByVault.set(vault, apy)
+  const apy = include.includes('apy') ? apyByVault : undefined
   const data = page.map((match) =>
     resolveVault(c, { ...match, apy, include, rates, snapshot, tokens }),
   )
@@ -2181,8 +2213,8 @@ export async function listVerifiedVaults(
   const [apy, rates, tokens] = await Promise.all([
     resolvePageApy(c, {
       chainId: options.chainId,
-      discoveries,
       include,
+      vaults: discoveries.map(({ vaultAddress }) => vaultAddress),
       window: options['apy.window'],
     }),
     resolvePageRates(c, { discoveries, include, oracle: options.oracle, snapshot }),
@@ -2503,8 +2535,8 @@ export async function getVault(c: Context<App.Environment>, options: getVault.Op
     const [apy, rates, tokens] = await Promise.all([
       resolvePageApy(c, {
         chainId: options.chainId,
-        discoveries,
         include,
+        vaults: discoveries.map(({ vaultAddress }) => vaultAddress),
         window: options['apy.window'],
       }),
       resolvePageRates(c, { discoveries, include, oracle: options.oracle, snapshot }),
@@ -2616,7 +2648,7 @@ function resolvePageApy(c: Context<App.Environment>, options: resolvePageApy.Opt
       getClient: c.get('getClient'),
       getTidx: c.get('getTidx'),
       store: c.get('store'),
-      vaults: options.discoveries.map(({ vaultAddress }) => vaultAddress),
+      vaults: options.vaults,
       window: options.window,
     }),
   )
@@ -2625,8 +2657,8 @@ function resolvePageApy(c: Context<App.Environment>, options: resolvePageApy.Opt
 declare namespace resolvePageApy {
   type Options = {
     chainId: z.output<typeof Schema.ChainId>
-    discoveries: readonly EarnVaults.Discovery[]
     include: z.output<typeof schema.getEarnVault.Query>['include']
+    vaults: readonly z.output<typeof Schema.Address>[]
     window: z.output<typeof schema.getEarnVault.Query>['apy.window']
   }
 }
@@ -2837,7 +2869,7 @@ async function queryDeployments(
   c: Context<App.Environment>,
   options: queryDeployments.Options,
 ): Promise<queryDeployments.Result> {
-  const filters = ['deployment_rank = 1']
+  const filters: string[] = []
   if (options.asset) filters.push(`lower(asset) = '${options.asset.toLowerCase()}'`)
   if (options.cursor)
     filters.push(
@@ -2855,7 +2887,7 @@ async function queryDeployments(
       ]),
     )
 
-  // ClickHouse supports ordering and windowing over decoded event CTEs.
+  // Deduplicate before outer filters so every vault is filtered by its latest deployment.
   const result = await c
     .get('getTidx')(options.chainId)
     .fetch({
@@ -2868,14 +2900,12 @@ async function queryDeployments(
           "earnVault",
           asset,
           block_num,
-          log_idx,
-          row_number() OVER (
-            PARTITION BY lower("earnVault")
-            ORDER BY block_num DESC, log_idx DESC
-          ) AS deployment_rank
+          log_idx
         FROM EarnStackDeployed
+        ORDER BY block_num DESC, log_idx DESC
+        LIMIT 1 BY lower("earnVault")
       )
-      WHERE ${filters.join(' AND ')}
+      ${filters.length > 0 ? `WHERE ${filters.join(' AND ')}` : ''}
       ORDER BY block_num DESC, log_idx DESC
       LIMIT ${options.limit + 1}
     ` as string,

package/src/apps/data/routes/exchanges.test.ts

@@ -531,7 +531,7 @@ describe('GET /exchange/orders?base=… (pair-scoped orders)', () => {
 })
 
 describe('GET /exchange/pairs/:base/depth', () => {
-  test('returns orderbook depth for a real pair', async () => {
+  test('returns orderbook depth when token metadata is requested', async () => {
     const client = TestApp.client()
     const pairsResponse = await client.v1.exchange.pairs.$get(
       { query: { limit: '5' } },
@@ -547,21 +547,25 @@ describe('GET /exchange/pairs/:base/depth', () => {
     // throttles the multicall response.
     let body: z.output<typeof Exchanges.schema.getPairDepth.Response> | null = null
     let pair: (typeof pairs.data)[number] | null = null
+    let timing: string | null = null
     for (const candidate of pairs.data) {
       const response = await client.v1.exchange.pairs[':base'].depth.$get(
-        { param: { base: candidate.base.address }, query: {} },
+        { param: { base: candidate.base.address }, query: { include: 'tokens' } },
         TestApp.auth,
       )
       if (response.status === 502) return
       expect(response.status).toBe(200)
       body = await TestApp.json(response, Exchanges.schema.getPairDepth.Response)
       pair = candidate
+      timing = response.headers.get('server-timing')
       if (body.bids.length > 0 || body.asks.length > 0) break
     }
     if (!body || !pair) return
 
     expect(body.base.address).toBe(pair.base.address)
     expect(body.quote.address).toBe(pair.quote.address)
+    expect(timing).toContain('pair_lookup;dur=')
+    expect(timing).not.toContain('pair_index;dur=')
 
     // Asks are emitted lowest-tick first (best ask outward); bids are
     // emitted highest-tick first (best bid outward). Per-row `cumulativeSize`
@@ -689,9 +693,9 @@ describe('GET /exchange/swaps', () => {
     const response = await client.v1.exchange.swaps.$get({ query: { limit: '10' } }, TestApp.auth)
     expect(response.status).toBe(200)
     const body = await TestApp.json(response, Exchanges.schema.getSwaps.Response)
+    expect(body.data.length).toBeGreaterThan(0)
     expect(body.data.length).toBeLessThanOrEqual(10)
     expect(response.headers.get('server-timing')).not.toContain('valuation_rates;dur=')
-    if (body.data.length === 0) return
 
     for (const swap of body.data) {
       expect(swap.taker).toMatch(/^0x[0-9a-f]{40}$/)
@@ -827,6 +831,7 @@ describe('GET /exchange/swaps', () => {
       TestApp.auth,
     )
     expect(response.status).toBe(200)
+    expect(response.headers.get('server-timing')).not.toContain('token_logo_uri;dur=')
     const body = await TestApp.json(response, Exchanges.schema.getSwaps.Response)
     if (body.data.length === 0) return