tapimo 0.15.1 → 0.18.0

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

@@ -57,9 +57,8 @@ export namespace schema {
           .check(
             z.describe(
               'When `true`, include only tokens eligible to pay transaction fees on Tempo: ' +
-                'verified tokens that have a Fee AMM pool, plus the default fee token ' +
-                '(`pathUSD`). Use this to avoid a second `/fee-amm/pools` query when you ' +
-                'only want fee-payable holdings.',
+                'verified tokens preferred by an active validator or backed by a liquid pool ' +
+                'against one, plus the default fee token (`pathUSD`).',
             ),
             z.meta({ examples: [true] }),
           ),
@@ -122,10 +121,9 @@ export namespace schema {
             .check(
               z.describe(
                 'Whether this token can be used to pay transaction fees on Tempo: `true` when ' +
-                  'the token is verified and has a Fee AMM pool, or is the default fee token ' +
-                  '(`pathUSD`). Lets you identify fee-payable holdings without a separate ' +
-                  '`/fee-amm/pools` query. Omitted (best-effort) when the fee-token lookup ' +
-                  'is unavailable.',
+                  'the token is verified and preferred by an active validator or backed by a ' +
+                  'liquid pool against one, or is the default fee token (`pathUSD`). Omitted ' +
+                  'when the lookup is unavailable.',
               ),
               z.meta({ examples: [true] }),
             ),

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

@@ -11,6 +11,13 @@ const fixtures = {
   },
 } as const
 
+const holders = {
+  4217: {
+    address: '0xc0d8af19c4ef4725789e06b296da7f679fdc0db5',
+    vault: '0xd730394f3bb85a4828e35fc5e361dcc9f894fa4f',
+  },
+} as const
+
 const vaultQueries = [
   'apy.window=1d',
   'include=access',
@@ -52,6 +59,17 @@ QueryBench.bench({
   },
 })
 
+// A funded holder of the mainnet reward-campaign vault, so wallet APY walks
+// the boost, qualification, and eligibility branches the test vault skips.
+QueryBench.bench({
+  name: 'getEarnVaultPosition:holder',
+  path: {
+    4217: `/v1/earn/vaults/${holders[4217].vault}/positions/${holders[4217].address}`,
+    42431: `/v1/earn/vaults/${fixtures[42431].vault}/positions/${fixtures[42431].address}`,
+  },
+  queries: ['include=apy', 'include=apy,rewards'],
+})
+
 QueryBench.bench({
   name: 'getEarnVaultEarnings',
   path: {

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

@@ -0,0 +1,507 @@
+/** @module-tag localnet */
+
+import { sql } from 'kysely'
+import { createPublicClient, erc20Abi, http, parseAbi } from 'viem'
+import { getBlock, getBlockNumber, getCode, readContract } from 'viem/actions'
+import { Account, Actions } from 'viem/tempo'
+
+import * as TestApp from '../../../../test/App.js'
+import * as EarnLocal from '../../../../test/EarnLocal.js'
+import * as Runtime from '../../../../test/runtime.js'
+import * as Tempo from '../../../../test/Tempo.js'
+import * as TestViem from '../../../../test/Viem.js'
+import * as EarnVaults from '../../../db/tables/earnVaults.js'
+import * as core_EarnVaults from '../../../internal/EarnVaults.js'
+import type * as Log from '../../../internal/Log.js'
+import * as Earn from './earn.js'
+
+const runtime = Runtime.get()
+const deployer = Tempo.getClient({ account: Tempo.accounts[6] })
+const administrator = Tempo.getClient({
+  account: Account.fromSecp256k1(
+    '0xac0974bec39a17e36ba4a6b4d238ff944bacb478cbed5efcae784d7bf4f2ff80',
+  ),
+})
+let stack: Awaited<ReturnType<typeof EarnLocal.deploy>>
+let zone: Awaited<ReturnType<typeof EarnLocal.getZone>>
+type HistoricalRoute = {
+  /** Zone observation timestamp before the second router deployment. */
+  asOf: string
+  /** Parent block that deployed the second router. */
+  deploymentBlock: number
+  /** Router deployed after the historical observation. */
+  router: typeof stack.router
+}
+let historical: HistoricalRoute
+const key = {
+  ...TestApp.key,
+  scopes: ['data:read', `zone:${runtime.zone.chainId}:read`],
+} satisfies TestApp.kvStore.Key
+const unrelatedKey = {
+  ...TestApp.key,
+  id: 'key_earn_local_unrelated',
+  scopes: ['data:read'],
+  token: 'secret_earn_local_unrelated',
+} satisfies TestApp.kvStore.Key
+
+async function createPositionApp(options: createPositionApp.Options = {}) {
+  const db = TestApp.database()
+  await EarnVaults.upsert(db, {
+    chainId: runtime.chainId,
+    description: 'Disposable local Earn vault.',
+    label: 'Local Earn',
+    privateInputTokens: [],
+    privateOutputTokens: [],
+    vaultAddress: stack.vault,
+    zones: options.zones ?? [],
+  })
+  const chain = TestApp.zone({
+    chainId: runtime.zone.chainId,
+    messenger: zone.messenger,
+    portal: zone.portal,
+    rpcUrl: runtime.zone.internalRpcUrl,
+    sourceChainId: runtime.chainId,
+    tidxUrl: runtime.tidxUrl,
+  })
+  const entries: Log.Entry[] = []
+  return {
+    app: TestApp.create({
+      auth: { keys: options.keys ?? [key, unrelatedKey] },
+      db,
+      logger: (entry) => void entries.push(entry),
+      zones: [chain],
+    }),
+    db,
+    entries,
+  }
+}
+
+declare namespace createPositionApp {
+  type Options = {
+    keys?: TestApp.kvStore.Key[] | undefined
+    zones?: EarnVaults.upsert.Options['zones'] | undefined
+  }
+}
+
+function positionPath() {
+  return `/v1/earn/vaults/${stack.vault}/positions/${deployer.account.address}?chainId=${runtime.zone.chainId}`
+}
+
+beforeAll(async () => {
+  if (runtime.mode !== 'localnet') return
+  await Actions.faucet.fundSync(deployer, { account: deployer.account })
+  stack = await EarnLocal.deploy({ client: deployer, zoneId: runtime.zone.chainId - 421_700_000 })
+  zone = await EarnLocal.getZone({ client: deployer, zoneId: runtime.zone.chainId - 421_700_000 })
+  await EarnLocal.enableZoneTokens({ client: administrator, portal: zone.portal, stack })
+  const seeded = await EarnLocal.seedZone({ client: deployer, portal: zone.portal, stack })
+  const sourceBlock = await getBlockNumber(deployer)
+  const zoneClient = createPublicClient({
+    batch: { multicall: false },
+    chain: { ...Tempo.chain, id: runtime.zone.chainId },
+    transport: http(runtime.zone.internalRpcUrl),
+  })
+  const deadline = Date.now() + 60_000
+  while (Date.now() < deadline) {
+    // The Zone may not have imported the share contract yet.
+    const observation = await Promise.all([
+      readContract(zoneClient, {
+        abi: erc20Abi,
+        account: deployer.account.address,
+        address: stack.earnShare,
+        args: [deployer.account.address],
+        functionName: 'balanceOf',
+      }),
+      readContract(deployer, {
+        abi: parseAbi(['function lastSyncedTempoBlockNumber() view returns (uint64)']),
+        address: zone.portal,
+        functionName: 'lastSyncedTempoBlockNumber',
+      }),
+    ]).catch(() => undefined)
+    if (observation?.[0] === seeded.shareBalance && observation[1] >= sourceBlock) {
+      const block = await getBlock(zoneClient)
+      // Keep later Zone blocks outside the timestamp selected by `asOf`.
+      await new Promise((resolve) => setTimeout(resolve, 1_200))
+      const route = await EarnLocal.deployRouter({
+        client: deployer,
+        privateAsset: stack.privateAsset,
+        tokenAuthority: stack.tokenAuthority,
+        vault: stack.vault,
+        zoneId: runtime.zone.chainId - 421_700_000,
+      })
+      historical = {
+        asOf: new Date(Number(block.timestamp) * 1_000).toISOString(),
+        deploymentBlock: route.deploymentBlock,
+        router: route.router,
+      }
+      return
+    }
+    await new Promise((resolve) => setTimeout(resolve, 500))
+  }
+  throw new Error('Zone did not import the seeded EarnShare and parent checkpoint.')
+}, 120_000)
+
+test.runIf(runtime.mode === 'localnet')(
+  'deploys an ERC-4626 Earn stack and imports Zone shares',
+  async () => {
+    for (const address of [stack.vault, stack.router]) {
+      const code = await getCode(deployer, { address })
+      expect(code).toBeDefined()
+      expect(code).not.toBe('0x')
+    }
+  },
+  120_000,
+)
+
+test.runIf(runtime.mode === 'localnet')(
+  'rejects a Zone quote before the parent vault exists at the verified block',
+  async () => {
+    const client = TestViem.getClient()
+    expect(await getCode(client, { address: stack.vault, blockNumber: 0n })).toBeUndefined()
+    await expect(
+      Earn.quoteZonePosition(client, {
+        blockNumber: 0n,
+        shareAmount: 1n,
+        vault: stack.vault,
+      }),
+    ).rejects.toBeInstanceOf(core_EarnVaults.NotFoundError)
+  },
+)
+
+test.runIf(runtime.mode === 'localnet')(
+  'reads a Zone position without an Admin route mapping',
+  async () => {
+    const { app, entries } = await createPositionApp()
+    const response = await app.request(positionPath(), {
+      headers: { 'tempo-api-key': key.token },
+    })
+    if (response.status !== 200)
+      throw new Error(JSON.stringify({ body: await response.json(), entries }))
+    const position = await TestApp.json(response, Earn.schema.getEarnVaultPosition.Response)
+    expect(position.assetToken).toBe(stack.baseAsset.toLowerCase())
+    expect(position.assetBalance).toBe('0')
+    expect(position.shareBalance).not.toBe('0')
+    expect(position).not.toHaveProperty('privateAssetToken')
+  },
+)
+
+test.runIf(runtime.mode === 'localnet')('enriches a configured Zone position', async () => {
+  const { app, entries } = await createPositionApp({
+    zones: [
+      {
+        chainId: runtime.zone.chainId,
+        deploymentBlock: stack.routerDeploymentBlock,
+        earnRouter: stack.router,
+      },
+    ],
+  })
+  const response = await app.request(positionPath(), {
+    headers: { 'tempo-api-key': key.token },
+  })
+  if (response.status !== 200)
+    throw new Error(JSON.stringify({ body: await response.json(), entries }))
+  const position = await TestApp.json(response, Earn.schema.getEarnVaultPosition.Response)
+  expect(position.assetToken).toBe(stack.baseAsset.toLowerCase())
+  expect(position.assetBalance).toBe('0')
+  expect(position.privateAssetToken).toBe(stack.privateAsset.toLowerCase())
+  expect(position.privateAssetBalance).toBe('1000000')
+})
+
+test.runIf(runtime.mode === 'localnet')(
+  'omits private enrichment before the router deployment checkpoint',
+  async () => {
+    const { app, entries } = await createPositionApp({
+      zones: [
+        {
+          chainId: runtime.zone.chainId,
+          deploymentBlock: historical.deploymentBlock,
+          earnRouter: historical.router,
+        },
+      ],
+    })
+    const response = await app.request(
+      `${positionPath()}&asOf=${encodeURIComponent(historical.asOf)}`,
+      {
+        headers: { 'tempo-api-key': key.token },
+      },
+    )
+    if (response.status !== 200)
+      throw new Error(JSON.stringify({ body: await response.json(), entries }))
+    const position = await TestApp.json(response, Earn.schema.getEarnVaultPosition.Response)
+    expect(position.assetBalance).toBe('0')
+    expect(position.shareBalance).not.toBe('0')
+    expect(position).not.toHaveProperty('privateAssetBalance')
+    expect(position).not.toHaveProperty('privateAssetToken')
+  },
+  60_000,
+)
+
+test.runIf(runtime.mode === 'localnet')(
+  'logs a database enrichment failure without losing the core position',
+  async () => {
+    const { app, db, entries } = await createPositionApp({
+      zones: [
+        {
+          chainId: runtime.zone.chainId,
+          deploymentBlock: stack.routerDeploymentBlock,
+          earnRouter: stack.router,
+        },
+      ],
+    })
+    // This database has its own schema; dependent fixture objects are disposable.
+    await sql`DROP TABLE earn_vaults CASCADE`.execute(db.kysely)
+    const response = await app.request(positionPath(), {
+      headers: { 'tempo-api-key': key.token },
+    })
+    if (response.status !== 200)
+      throw new Error(JSON.stringify({ body: await response.json(), entries }))
+    const position = await TestApp.json(response, Earn.schema.getEarnVaultPosition.Response)
+    expect(position.assetBalance).toBe('0')
+    expect(position.shareBalance).not.toBe('0')
+    expect(position).not.toHaveProperty('privateAssetBalance')
+    expect(position).not.toHaveProperty('privateAssetToken')
+    expect(entries.find((entry) => entry.providerFailures)?.providerFailures).toEqual([
+      {
+        chainId: runtime.chainId,
+        failure: 'unknown',
+        id: 'earn-zone-position',
+        operation: 'resolvePrivateAsset',
+      },
+    ])
+  },
+)
+
+test.runIf(runtime.mode === 'localnet')('logs a Zone router validation failure', async () => {
+  const { app, entries } = await createPositionApp({
+    zones: [
+      {
+        chainId: runtime.zone.chainId,
+        deploymentBlock: stack.routerDeploymentBlock + 1,
+        earnRouter: stack.router,
+      },
+    ],
+  })
+  const response = await app.request(positionPath(), {
+    headers: { 'tempo-api-key': key.token },
+  })
+  if (response.status !== 200)
+    throw new Error(JSON.stringify({ body: await response.json(), entries }))
+  const position = await TestApp.json(response, Earn.schema.getEarnVaultPosition.Response)
+  expect(position).not.toHaveProperty('privateAssetToken')
+  expect(entries.find((entry) => entry.providerFailures)?.providerFailures).toEqual([
+    {
+      chainId: runtime.chainId,
+      failure: 'unknown',
+      id: 'earn-zone-position',
+      operation: 'resolvePrivateAsset',
+    },
+  ])
+})
+
+test.runIf(runtime.mode === 'localnet')(
+  'lists Zone shares with parent asset metadata',
+  async () => {
+    const { app, entries } = await createPositionApp({
+      zones: [
+        {
+          chainId: runtime.zone.chainId,
+          deploymentBlock: stack.routerDeploymentBlock,
+          earnRouter: stack.router,
+        },
+      ],
+    })
+    const response = await app.request(
+      `/v1/earn/addresses/${deployer.account.address}/positions?chainId=${runtime.zone.chainId}`,
+      { headers: { 'tempo-api-key': key.token } },
+    )
+    if (response.status !== 200)
+      throw new Error(JSON.stringify({ body: await response.json(), entries }))
+    const body = await TestApp.json(response, Earn.schema.getEarnAddressPositions.Response)
+    const position = body.data[0]
+    const zoneClient = createPublicClient({
+      chain: { ...Tempo.chain, id: runtime.zone.chainId },
+      transport: http(runtime.zone.internalRpcUrl),
+    })
+    expect(await getCode(zoneClient, { address: stack.baseAsset })).toBeUndefined()
+    expect(position?.vaultAddress).toBe(stack.vault.toLowerCase())
+    expect(position?.assetToken.address).toBe(stack.baseAsset.toLowerCase())
+    expect(position?.assetToken.symbol).toBeTruthy()
+    expect(position?.valueToken.address).toBe(stack.baseAsset.toLowerCase())
+    expect(position?.valueToken.symbol).toBe(position?.assetToken.symbol)
+    expect(position?.shareToken.address).toBe(stack.earnShare.toLowerCase())
+  },
+)
+
+test.runIf(runtime.mode === 'localnet')(
+  'does not validate unused private routes while listing Zone shares',
+  async () => {
+    const { app, entries } = await createPositionApp({
+      zones: [
+        {
+          chainId: runtime.zone.chainId,
+          deploymentBlock: stack.routerDeploymentBlock + 1,
+          earnRouter: stack.router,
+        },
+      ],
+    })
+    const response = await app.request(
+      `/v1/earn/addresses/${deployer.account.address}/positions?chainId=${runtime.zone.chainId}`,
+      { headers: { 'tempo-api-key': key.token } },
+    )
+    if (response.status !== 200)
+      throw new Error(JSON.stringify({ body: await response.json(), entries }))
+    const body = await TestApp.json(response, Earn.schema.getEarnAddressPositions.Response)
+    expect(body.data.map((position) => position.vaultAddress)).toEqual([stack.vault.toLowerCase()])
+    expect(entries.some((entry) => entry.providerFailures !== undefined)).toBe(false)
+  },
+)
+
+test.runIf(runtime.mode === 'localnet')(
+  'lists Zone shares without a route while skipping unimported vaults',
+  async () => {
+    const { app, db, entries } = await createPositionApp()
+    const unimported = await EarnLocal.deploy({
+      client: deployer,
+      zoneId: runtime.zone.chainId - 421_700_000,
+    })
+    await EarnVaults.upsert(db, {
+      chainId: runtime.chainId,
+      description: 'Vault without imported Zone shares.',
+      label: 'Unimported Earn',
+      privateInputTokens: [],
+      privateOutputTokens: [],
+      vaultAddress: unimported.vault,
+      zones: [],
+    })
+    const zoneClient = createPublicClient({
+      chain: { ...Tempo.chain, id: runtime.zone.chainId },
+      transport: http(runtime.zone.internalRpcUrl),
+    })
+    expect(await getCode(zoneClient, { address: unimported.earnShare })).toBeUndefined()
+    const response = await app.request(
+      `/v1/earn/addresses/${deployer.account.address}/positions?chainId=${runtime.zone.chainId}`,
+      { headers: { 'tempo-api-key': key.token } },
+    )
+    if (response.status !== 200)
+      throw new Error(JSON.stringify({ body: await response.json(), entries }))
+    const body = await TestApp.json(response, Earn.schema.getEarnAddressPositions.Response)
+    expect(body.data.map((position) => position.vaultAddress)).toEqual([stack.vault.toLowerCase()])
+  },
+  120_000,
+)
+
+test.runIf(runtime.mode === 'localnet')('scopes verified Zone route capabilities', async () => {
+  const otherZoneId = runtime.zone.chainId + 1
+  const scopedKey = {
+    ...key,
+    scopes: ['data:read', `zone:${otherZoneId}:read`, `zone:${runtime.zone.chainId}:read`],
+  } satisfies TestApp.kvStore.Key
+  const unrelatedKey = {
+    ...TestApp.key,
+    id: 'key_earn_local_other_zone',
+    scopes: ['data:read', `zone:${otherZoneId}:read`],
+    token: 'secret_earn_local_other_zone',
+  } satisfies TestApp.kvStore.Key
+  const writeOnlyKey = {
+    ...TestApp.key,
+    id: 'key_earn_local_write_zone',
+    scopes: ['data:read', `zone:${runtime.zone.chainId}:write`],
+    token: 'secret_earn_local_write_zone',
+  } satisfies TestApp.kvStore.Key
+  const wildcardKey = {
+    ...TestApp.key,
+    id: 'key_earn_local_all_zones',
+    scopes: ['*'],
+    token: 'secret_earn_local_all_zones',
+  } satisfies TestApp.kvStore.Key
+  const { app, entries } = await createPositionApp({
+    keys: [scopedKey, unrelatedKey, wildcardKey, writeOnlyKey],
+    zones: [
+      {
+        chainId: runtime.zone.chainId,
+        deploymentBlock: stack.routerDeploymentBlock,
+        earnRouter: stack.router,
+      },
+    ],
+  })
+  const base = `/v1/earn/vaults/verified?chainId=${runtime.chainId}`
+  const included = `${base}&include=capabilities,zone,zones`
+  const filtered = `${included}&capability=privateRouting`
+  // Fill the query-credential cache entry before checking callers without its Zone scope.
+  const scopedResponse = await app.request(`${filtered}&key=${scopedKey.token}`)
+  const [defaultResponse, unrelatedResponse, publicResponse, wildcardResponse, writeOnlyResponse] =
+    await Promise.all([
+      app.request(base, { headers: { 'tempo-api-key': scopedKey.token } }),
+      app.request(included, { headers: { 'tempo-api-key': unrelatedKey.token } }),
+      app.request(filtered),
+      app.request(filtered, { headers: { 'tempo-api-key': wildcardKey.token } }),
+      app.request(filtered, { headers: { 'tempo-api-key': writeOnlyKey.token } }),
+    ])
+  const responses = [
+    defaultResponse,
+    scopedResponse,
+    unrelatedResponse,
+    publicResponse,
+    wildcardResponse,
+    writeOnlyResponse,
+  ]
+  if (responses.some((response) => response.status !== 200))
+    throw new Error(
+      JSON.stringify({ statuses: responses.map((response) => response.status), entries }),
+    )
+  const [defaultBody, scopedBody, unrelatedBody, publicBody, wildcardBody, writeOnlyBody] =
+    await Promise.all([
+      TestApp.json(defaultResponse, Earn.schema.getVerifiedEarnVaults.Response),
+      TestApp.json(scopedResponse, Earn.schema.getVerifiedEarnVaults.Response),
+      TestApp.json(unrelatedResponse, Earn.schema.getVerifiedEarnVaults.Response),
+      TestApp.json(publicResponse, Earn.schema.getVerifiedEarnVaults.Response),
+      TestApp.json(wildcardResponse, Earn.schema.getVerifiedEarnVaults.Response),
+      TestApp.json(writeOnlyResponse, Earn.schema.getVerifiedEarnVaults.Response),
+    ])
+  expect(defaultBody.data[0]).not.toHaveProperty('zone')
+  expect(defaultBody.data[0]).not.toHaveProperty('zones')
+  for (const body of [unrelatedBody, publicBody])
+    expect(body.data[0]).toMatchObject({
+      capabilities: { privateRouting: true, routerSwaps: true },
+      zone: null,
+      zones: [],
+    })
+  expect(writeOnlyBody.data[0]).toMatchObject({ zone: null, zones: [] })
+  const vault = scopedBody.data[0]
+  expect(vault?.capabilities).toMatchObject({ privateRouting: true, routerSwaps: true })
+  expect(vault?.zones).toHaveLength(1)
+  expect(vault?.zones?.[0]).toMatchObject({
+    chainId: runtime.zone.chainId,
+    deploymentBlock: stack.routerDeploymentBlock,
+    earnRouter: stack.router,
+  })
+  expect(vault?.zone).toStrictEqual(
+    vault?.zones?.[0]
+      ? {
+          chainId: vault.zones[0].chainId,
+          inputTokens: vault.zones[0].inputTokens,
+          name: vault.zones[0].name,
+          outputTokens: vault.zones[0].outputTokens,
+        }
+      : null,
+  )
+  expect(wildcardBody.data[0]).toStrictEqual(vault)
+})
+
+test.runIf(runtime.mode === 'localnet')('imports a verified parent checkpoint', async () => {
+  const client = TestViem.getClient()
+  const { portal } = zone
+  if (!(await client.getCode({ address: portal })))
+    throw new Error(`Local Zone Portal ${portal} has no code.`)
+  const deadline = Date.now() + 30_000
+  while (Date.now() < deadline) {
+    const checkpoint = await client.readContract({
+      abi: parseAbi(['function lastSyncedTempoBlockNumber() view returns (uint64)']),
+      address: portal,
+      functionName: 'lastSyncedTempoBlockNumber',
+    })
+    if (checkpoint > 0n) return
+    await new Promise((resolve) => setTimeout(resolve, 500))
+  }
+
+  throw new Error('Local Zone did not import a verified parent checkpoint within 30 seconds.')
+})