tapimo 0.7.2 → 0.8.0

package/src/analytics/Analytics.ts

@@ -359,9 +359,13 @@ export class ConfigError extends Error {
 
 /** Failed ClickHouse insert (non-2xx HTTP response). */
 export class InsertError extends Error {
+  /** HTTP response status returned by ClickHouse. */
+  status: number
+
   constructor(status: number, body: string) {
     super(`ClickHouse insert failed with status ${status}: ${body.slice(0, 500)}`)
     this.name = 'Analytics.InsertError'
+    this.status = status
   }
 }
 

package/src/apps/composition.test.ts

@@ -1,5 +1,5 @@
 import { App, Store } from 'tapimo'
-import { data, management, mpp, relay } from 'tapimo/apps'
+import { data, funding, management, mpp, relay } from 'tapimo/apps'
 import { Hono } from 'hono'
 import { describeRoute } from 'hono-openapi'
 import * as TestApp from '../../test/App.js'
@@ -14,7 +14,10 @@ async function document(app: { request: (path: string) => Promise<Response> | Re
   const res = await app.request('/openapi.json')
   return (await res.json()) as {
     components: { securitySchemes: Record<string, unknown> }
-    paths: Record<string, unknown>
+    paths: Record<
+      string,
+      Partial<Record<'get' | 'post', { operationId: string; tags?: readonly string[] | undefined }>>
+    >
     tags: readonly { description: string; name: string }[]
     webhooks?: Record<string, unknown> | undefined
     'x-tagGroups'?: readonly { name: string; tags: readonly string[] }[] | undefined
@@ -146,10 +149,12 @@ describe('data()', () => {
     expect(keys.some((path) => path.startsWith('/v1/blocks'))).toBe(true)
     expect(keys.some((path) => path.startsWith('/v1/orgs'))).toBe(false)
     expect(keys.some((path) => path.startsWith('/v1/me'))).toBe(false)
+    expect(keys.some((path) => path.startsWith('/v1/funding'))).toBe(false)
 
     // The omitted management route resolves to a 404 (never mounted), not a 401.
     const orgs = await app.request('/v1/orgs')
     expect(orgs.status).toBe(404)
+    expect((await app.request('/v1/funding/chains')).status).toBe(404)
   })
 
   test('inherits shared chain context', async () => {
@@ -272,6 +277,99 @@ describe('data()', () => {
   })
 })
 
+describe('funding()', () => {
+  test('mounts the Funding & Bridge API independently', async () => {
+    const group = funding()
+    expectTypeOf(App.funding).toEqualTypeOf<typeof funding>()
+    expectTypeOf(group).toEqualTypeOf<App.FundingApp>()
+    const app = App.create({ auth: false, db: TestApp.database() }).route('/', group)
+    const spec = await document(app)
+
+    expect(
+      Object.keys(spec.paths)
+        .filter((path) => path.startsWith('/v1/funding'))
+        .sort(),
+    ).toEqual(
+      [
+        '/v1/funding/chains',
+        '/v1/funding/deposit-addresses',
+        '/v1/funding/deposit-addresses/{id}',
+        '/v1/funding/deposit-addresses/{id}/deposits',
+        '/v1/funding/deposit-addresses/{id}/reconcile',
+        '/v1/funding/deposits',
+        '/v1/funding/deposits/{id}',
+        '/v1/funding/providers',
+        '/v1/funding/quotes',
+        '/v1/funding/transfers',
+        '/v1/funding/transfers/vault',
+        '/v1/funding/transfers/zone',
+        '/v1/funding/transfers/{id}',
+      ].sort(),
+    )
+    expect(Object.keys(spec.paths).some((path) => path.startsWith('/v1/tokens'))).toBe(false)
+    expect(spec.paths['/webhooks/funding/{providerId}']).toBeUndefined()
+    expect(spec['x-tagGroups']).toEqual([
+      {
+        name: 'Funding & Bridge API',
+        tags: ['Chains', 'Deposit Addresses', 'Providers', 'Quotes', 'Transfers'],
+      },
+    ])
+    expect(
+      Object.values(spec.paths).flatMap((path) =>
+        [path.get, path.post].flatMap((operation) =>
+          operation?.tags?.includes('Deposit Addresses') ? [operation.operationId] : [],
+        ),
+      ),
+    ).toEqual([
+      'createFundingDepositAddress',
+      'reconcileFundingDepositAddress',
+      'getFundingDepositAddress',
+      'getFundingDeposit',
+      'listFundingDepositAddressDeposits',
+      'listFundingDeposits',
+    ])
+    expect((await app.request('/v1/tokens')).status).toBe(404)
+  })
+
+  test('maps operations to five tags and reuses Transfers across groups', async () => {
+    const app = App.create({ auth: false, db: TestApp.database() })
+      .route('/', data())
+      .route('/', funding())
+    const spec = await document(app)
+    const operationTag = (path: string, method: 'get' | 'post') =>
+      (spec.paths[path] as Record<string, { tags?: readonly string[] | undefined } | undefined>)[
+        method
+      ]?.tags
+
+    expect({
+      chains: operationTag('/v1/funding/chains', 'get'),
+      depositAddress: operationTag('/v1/funding/deposit-addresses', 'post'),
+      deposits: operationTag('/v1/funding/deposit-addresses/{id}/deposits', 'get'),
+      providers: operationTag('/v1/funding/providers', 'get'),
+      quotes: operationTag('/v1/funding/quotes', 'get'),
+      transfers: operationTag('/v1/funding/transfers', 'get'),
+      vault: operationTag('/v1/funding/transfers/vault', 'post'),
+      zone: operationTag('/v1/funding/transfers/zone', 'post'),
+    }).toEqual({
+      chains: ['Chains'],
+      depositAddress: ['Deposit Addresses'],
+      deposits: ['Deposit Addresses'],
+      providers: ['Providers'],
+      quotes: ['Quotes'],
+      transfers: ['Transfers'],
+      vault: ['Transfers'],
+      zone: ['Transfers'],
+    })
+
+    const groups = Object.fromEntries(
+      (spec['x-tagGroups'] ?? []).map((group) => [group.name, group.tags]),
+    )
+    expect(groups['Data API']).toContain('Transfers')
+    expect(groups['Funding & Bridge API']).toContain('Transfers')
+    expect(spec.tags.filter((tag) => tag.name === 'Transfers')).toHaveLength(1)
+  })
+})
+
 describe('relay()', () => {
   test('mounts the relay after data() without documenting RPC routes', async () => {
     const composed = App.create({ db: TestApp.database() }).route('/', data()).route('/', relay())

package/src/apps/data/App.test.ts

@@ -386,18 +386,6 @@ describe('zone chain gate', () => {
     expect((await privateApp.request(path)).status).toBe(403)
   })
 
-  test('public chains remain edge-cacheable on a Zone deployment', async () => {
-    const store = Store.memory()
-    const app = TestApp.create({ auth: false, cache: { store }, zones: [zoneOptions(zone)] })
-    const path = '/v1/funding/chains'
-
-    const first = await app.request(path)
-    const second = await app.request(path)
-    expect(first.status).toBe(200)
-    expect(second.status).toBe(200)
-    expect(second.headers.get('cache-control')).toContain('public')
-  })
-
   test('serves anonymous token lists from the edge cache on public chains', async () => {
     const store = Store.memory()
     const app = TestApp.create({ auth: false, cache: { store }, zones: [zoneOptions(zone)] })

package/src/apps/data/App.ts

@@ -25,7 +25,6 @@ import { coingecko } from './routes/coingecko.js'
 import { earn } from './routes/earn.js'
 import { exchanges } from './routes/exchanges.js'
 import { feeAmm } from './routes/fee-amm.js'
-import { funding } from './routes/funding.js'
 import { indexer } from './routes/indexer.js'
 import { receipts } from './routes/receipts.js'
 import { rpc } from './routes/rpc.js'
@@ -217,7 +216,6 @@ export function data(options: data.Options = {}) {
     .route('/', earn_routes)
     .route('/', exchanges({ fx: options.fx }))
     .route('/', feeAmm())
-    .route('/', funding())
     .route('/', indexer_routes)
     .route('/', receipts({ fx: options.fx }))
     .route('/', tokenlist())
@@ -375,13 +373,12 @@ const openapi = {
     { name: 'Earn', description: 'Vaults that earn yield from assets deposited on Tempo.' },
     { name: 'Exchange', description: "Tempo's built-in stablecoin exchange: pairs, swaps, orders, prices." }, // prettier-ignore
     { name: 'Fee AMM', description: 'Pools that convert stablecoins to pay fees.' },
-    {
-      name: 'Funding',
-      description: 'Quote, transfer, and deposit management for funding Tempo from other chains.',
-    },
     { name: 'Tokens', description: 'TIP-20 token details, supply, and holders.' },
     { name: 'Transactions', description: 'Transactions submitted to Tempo, and their receipts.' },
-    { name: 'Transfers', description: 'Token movements from executing transactions.' },
+    {
+      name: 'Transfers',
+      description: 'Token movements from executing transactions.',
+    },
     { name: 'Verified Tokens', description: 'A curated, trusted list of TIP-20 tokens.' },
     { name: 'Webhooks', description: 'Get signed callbacks when onchain events happen.' },
     { name: 'Zones', description: 'Private chain operations anchored to Tempo.' },
@@ -399,7 +396,6 @@ const openapi = {
         'Earn',
         'Exchange',
         'Fee AMM',
-        'Funding',
         'Tokens',
         'Transactions',
         'Transfers',

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

@@ -87,6 +87,166 @@ describe('schema.getEarnVaults.Query', () => {
   })
 })
 
+describe('schema.getEarnVaultEarnings.Response', () => {
+  test('enforces status-specific earnings fields', () => {
+    const response = {
+      account: TestEarn.earningsAddress,
+      assetToken: TestEarn.assetTokenAddress,
+      currentValue: '1000000',
+      id: TestEarn.earningsAddress,
+    }
+
+    expect({
+      active: Earn.schema.getEarnVaultEarnings.Response.safeParse({
+        ...response,
+        activeEarnings: '0',
+        period: 'active',
+        status: 'complete',
+      }).success,
+      activeWithLifetimeEarnings: Earn.schema.getEarnVaultEarnings.Response.safeParse({
+        ...response,
+        lifetimeEarnings: '0',
+        period: 'active',
+        status: 'complete',
+      }).success,
+      lifetime: Earn.schema.getEarnVaultEarnings.Response.safeParse({
+        ...response,
+        lifetimeEarnings: '0',
+        period: 'lifetime',
+        status: 'complete',
+      }).success,
+      completeWithoutEarnings: Earn.schema.getEarnVaultEarnings.Response.safeParse({
+        ...response,
+        period: 'lifetime',
+        status: 'complete',
+      }).success,
+      incomplete: Earn.schema.getEarnVaultEarnings.Response.safeParse({
+        ...response,
+        period: 'active',
+        status: 'incomplete_cost_basis',
+      }).success,
+      incompleteWithEarnings: Earn.schema.getEarnVaultEarnings.Response.safeParse({
+        ...response,
+        lifetimeEarnings: '0',
+        period: 'lifetime',
+        status: 'incomplete_cost_basis',
+      }).success,
+      pending: Earn.schema.getEarnVaultEarnings.Response.safeParse({
+        ...response,
+        period: 'lifetime',
+        status: 'pending_redemption',
+      }).success,
+      pendingActive: Earn.schema.getEarnVaultEarnings.Response.safeParse({
+        ...response,
+        period: 'active',
+        status: 'pending_redemption',
+      }).success,
+      pendingWithEarnings: Earn.schema.getEarnVaultEarnings.Response.safeParse({
+        ...response,
+        lifetimeEarnings: '0',
+        period: 'lifetime',
+        status: 'pending_redemption',
+      }).success,
+    }).toMatchInlineSnapshot(`
+      {
+        "active": true,
+        "activeWithLifetimeEarnings": false,
+        "completeWithoutEarnings": false,
+        "incomplete": true,
+        "incompleteWithEarnings": false,
+        "lifetime": true,
+        "pending": true,
+        "pendingActive": false,
+        "pendingWithEarnings": false,
+      }
+    `)
+  })
+})
+
+describe('schema.getEarnVaultEarnings.Query', () => {
+  test('defaults to lifetime and accepts active earnings', () => {
+    expect([
+      Earn.schema.getEarnVaultEarnings.Query.parse({}).period,
+      Earn.schema.getEarnVaultEarnings.Query.parse({ period: 'active' }).period,
+    ]).toStrictEqual(['lifetime', 'active'])
+  })
+})
+
+describe('calculateActiveCostBasis', () => {
+  test('allocates weighted-average basis across partial exits', () => {
+    expect(
+      Earn.calculateActiveCostBasis({
+        actions: [
+          { assets: 100n, kind: 'deposit', shares: 100n },
+          { assets: 300n, kind: 'deposit', shares: 100n },
+          { kind: 'redeem', shares: 100n },
+        ],
+        shareBalance: 100n,
+      }),
+    ).toBe(200n)
+  })
+
+  test('calculates remaining basis while an async redemption is pending', () => {
+    expect(
+      Earn.calculateActiveCostBasis({
+        actions: [
+          { assets: 100n, kind: 'deposit', shares: 100n },
+          { kind: 'request', requestId: 'request-1', shares: 40n },
+        ],
+        shareBalance: 60n,
+      }),
+    ).toBe(60n)
+  })
+
+  test('restores removed basis when an async redemption is cancelled', () => {
+    expect(
+      Earn.calculateActiveCostBasis({
+        actions: [
+          { assets: 100n, kind: 'deposit', shares: 100n },
+          { kind: 'request', requestId: 'request-1', shares: 40n },
+          { kind: 'cancel', requestId: 'request-1', shares: 40n },
+        ],
+        shareBalance: 100n,
+      }),
+    ).toBe(100n)
+  })
+
+  test('recovers after unknown-basis shares fully exit', () => {
+    expect(
+      Earn.calculateActiveCostBasis({
+        actions: [
+          { kind: 'unknown', shares: 100n },
+          { kind: 'redeem', shares: 100n },
+          { assets: 200n, kind: 'deposit', shares: 100n },
+        ],
+        shareBalance: 100n,
+      }),
+    ).toBe(200n)
+  })
+
+  test('rejects remaining shares with unknown cost basis', () => {
+    expect(
+      Earn.calculateActiveCostBasis({
+        actions: [
+          { assets: 100n, kind: 'deposit', shares: 100n },
+          { kind: 'unknown', shares: 100n },
+          { kind: 'redeem', shares: 100n },
+        ],
+        shareBalance: 100n,
+      }),
+    ).toBeUndefined()
+  })
+
+  test('rejects history that does not reconcile to the indexed share balance', () => {
+    expect(
+      Earn.calculateActiveCostBasis({
+        actions: [{ assets: 100n, kind: 'deposit', shares: 100n }],
+        shareBalance: 99n,
+      }),
+    ).toBeUndefined()
+  })
+})
+
 describe('discoveryBatchLimit', () => {
   test('fetches one extra candidate without live filters', () => {
     expect(
@@ -864,6 +1024,112 @@ describe('GET /v1/earn/vaults/:vaultId/positions/:address', () => {
   )
 })
 
+describe('GET /v1/earn/vaults/:vaultId/earnings/:address', () => {
+  test('returns chain selection errors', async () => {
+    const app = TestApp.create({ auth: false, cache })
+    const invalid = await app.request(
+      `/v1/earn/vaults/${TestEarn.vaultAddress}/earnings/${TestEarn.earningsAddress}?chainId=abc`,
+    )
+    const unsupported = await app.request(
+      `/v1/earn/vaults/${TestEarn.vaultAddress}/earnings/${TestEarn.earningsAddress}?chainId=999999`,
+    )
+
+    expect([
+      (await TestApp.json(invalid, Schema.ErrorResponse)).error.code,
+      (await TestApp.json(unsupported, Schema.ErrorResponse)).error.code,
+    ]).toStrictEqual(['chain_id_invalid', 'chain_id_unsupported'])
+  })
+
+  test('rejects malformed vault earnings parameters', async () => {
+    const response = await TestApp.create({ auth: false, cache }).request(
+      '/v1/earn/vaults/not-an-address/earnings/not-an-address',
+    )
+
+    expect(response.status).toBe(400)
+    expect(await TestApp.json(response, Schema.ErrorResponse)).toMatchObject({
+      error: { code: 'earnings_invalid' },
+    })
+  })
+
+  test.runIf(Runtime.get().mode === 'testnet')(
+    'returns lifetime return through indexed vault events',
+    async () => {
+      const app = TestApp.create({ auth: false, cache })
+      const response = await app.request(
+        `/v1/earn/vaults/${TestEarn.vaultAddress}/earnings/${TestEarn.earningsAddress}?chainId=${TestEarn.chain.id}`,
+      )
+
+      expect(response.status).toBe(200)
+      const earnings = await TestApp.json(response, Earn.schema.getEarnVaultEarnings.Response)
+      if (earnings.status !== 'complete') throw new Error('Expected complete earnings history.')
+      expect(earnings).toMatchObject({
+        account: TestEarn.earningsAddress,
+        assetToken: TestEarn.assetTokenAddress,
+        currentValue: expect.stringMatching(/^\d+$/),
+        id: TestEarn.earningsAddress,
+        lifetimeEarnings: expect.stringMatching(/^-?\d+$/),
+        period: 'lifetime',
+        status: 'complete',
+      })
+    },
+    60_000,
+  )
+
+  test.runIf(Runtime.get().mode === 'testnet')(
+    'returns earnings on shares still held',
+    async () => {
+      const app = TestApp.create({ auth: false, cache })
+      const response = await app.request(
+        `/v1/earn/vaults/${TestEarn.activeEarningsVaultAddress}/earnings/${TestEarn.activeEarningsAddress}?chainId=${TestEarn.chain.id}&period=active`,
+      )
+
+      expect(response.status).toBe(200)
+      const earnings = await TestApp.json(response, Earn.schema.getEarnVaultEarnings.Response)
+      if (earnings.status !== 'complete' || earnings.period !== 'active')
+        throw new Error('Expected complete active earnings history.')
+      expect(earnings).toMatchObject({
+        account: TestEarn.activeEarningsAddress,
+        activeEarnings: expect.stringMatching(/^-?\d+$/),
+        period: 'active',
+        status: 'complete',
+      })
+      expect(earnings).not.toHaveProperty('lifetimeEarnings')
+    },
+    60_000,
+  )
+
+  test.runIf(Runtime.get().mode === 'testnet')(
+    'omits lifetime earnings when venue shares make the cost basis incomplete',
+    async () => {
+      const app = TestApp.create({ auth: false, cache })
+      const response = await app.request(
+        `/v1/earn/vaults/${TestEarn.vaultAddress}/earnings/${TestEarn.incompleteEarningsAddress}?chainId=${TestEarn.chain.id}`,
+      )
+
+      expect(response.status).toBe(200)
+      const earnings = await TestApp.json(response, Earn.schema.getEarnVaultEarnings.Response)
+      expect(earnings.status).toBe('incomplete_cost_basis')
+      expect(earnings).not.toHaveProperty('lifetimeEarnings')
+    },
+    60_000,
+  )
+
+  test.runIf(Runtime.get().mode === 'testnet')(
+    'returns not found for an address without an Earn vault',
+    async () => {
+      const response = await TestApp.create({ auth: false, cache }).request(
+        `/v1/earn/vaults/0x1111111111111111111111111111111111111111/earnings/${TestEarn.earningsAddress}?chainId=${TestEarn.chain.id}`,
+      )
+
+      expect(response.status).toBe(404)
+      expect(await TestApp.json(response, Schema.ErrorResponse)).toMatchObject({
+        error: { code: 'earn_vault_not_found' },
+      })
+    },
+    60_000,
+  )
+})
+
 describe('GET /v1/earn/vaults', () => {
   test.runIf(Runtime.get().mode === 'testnet')(
     'extracts an indexed deployment and applies onchain filters',
@@ -1039,6 +1305,7 @@ describe('OpenAPI', () => {
         '/v1/earn/vaults',
         '/v1/earn/vaults/verified',
         '/v1/earn/vaults/{vaultId}',
+        '/v1/earn/vaults/{vaultId}/earnings/{address}',
         '/v1/earn/vaults/{vaultId}/positions/{address}',
       ]),
     )
@@ -1105,4 +1372,20 @@ describe('OpenAPI', () => {
     expect(address?.schema?.examples).toStrictEqual([TestEarn.positionAddress])
     expect(vaultId?.schema?.examples).toStrictEqual([TestEarn.mainnetVaultAddress])
   })
+
+  test('documents vault-earnings variants', async () => {
+    const app = TestApp.create({ auth: false, cache })
+    const spec = (await (await app.request('/openapi.json')).json()) as OpenApiDocument
+    const operation = spec.paths['/v1/earn/vaults/{vaultId}/earnings/{address}']?.get
+    const response = JSON.stringify(operation?.responses)
+
+    expect(response).toContain('"earn_vault_not_found"')
+    expect(response).toContain('Stable resource ID for these vault earnings')
+    expect(response).toContain('Current share value plus completed redemptions')
+    expect(response).toContain('weighted-average asset cost basis')
+    expect(response).toContain('cannot reconstruct the remaining asset cost basis')
+    expect(response).toContain('"active"')
+    expect(response).toContain('"incomplete_cost_basis"')
+    expect(response).toContain('"pending_redemption"')
+  })
 })