tapimo 0.9.0 → 0.10.1

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

@@ -0,0 +1,53 @@
+import * as QueryBench from '../../../../test/QueryBench.js'
+
+const pairId = {
+  4217: '0xc91fa403390f4eaf7f555b1ee33f54408befc79c5665728a2ac7e7ffa39c42ef',
+  42431: '0xb2b3f6d58ad8554d56200ebcd347ee2461a07276b764e0c0daf56b192bc7d341',
+} as const
+
+const block = { 4217: 34_335_551, 42431: 30_469_074 } as const
+
+QueryBench.bench({
+  chainId: false,
+  name: 'coingeckoLatestBlock',
+  path: { 4217: '/gecko/4217/latest-block', 42431: '/gecko/42431/latest-block' },
+})
+
+QueryBench.bench({
+  chainId: false,
+  name: 'coingeckoAsset',
+  path: {
+    4217: `/gecko/4217/assets/${QueryBench.pathUsd}`,
+    42431: `/gecko/42431/assets/${QueryBench.pathUsd}`,
+  },
+})
+
+QueryBench.bench({
+  chainId: false,
+  name: 'coingeckoPairs',
+  path: { 4217: '/gecko/4217/pairs', 42431: '/gecko/42431/pairs' },
+})
+
+QueryBench.bench({
+  chainId: false,
+  name: 'coingeckoPair',
+  path: {
+    4217: `/gecko/4217/pairs/${pairId[4217]}`,
+    42431: `/gecko/42431/pairs/${pairId[42431]}`,
+  },
+})
+
+QueryBench.bench({
+  chainId: false,
+  name: 'coingeckoEvents',
+  path: { 4217: '/gecko/4217/events', 42431: '/gecko/42431/events' },
+})
+
+QueryBench.bench({
+  chainId: false,
+  name: 'coingeckoEvents?fromBlock&toBlock',
+  path: {
+    4217: `/gecko/4217/events?fromBlock=${block[4217] - 100}&toBlock=${block[4217]}`,
+    42431: `/gecko/42431/events?fromBlock=${block[42431] - 100}&toBlock=${block[42431]}`,
+  },
+})

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

@@ -0,0 +1,71 @@
+import * as QueryBench from '../../../../test/QueryBench.js'
+
+const fixtures = {
+  4217: {
+    address: '0xbe058e1c4df8a4366a387bf595b284246a93039e',
+    vault: '0xf06e5740e5c72f61a10cf8149fa145fee48e560e',
+  },
+  42431: {
+    address: '0x68f94cfca22e5969c0553bbeab00a2acde88939b',
+    vault: '0xf4ae63687d6753a78e7f551d2eda1d0d31a5ea3a',
+  },
+} as const
+
+const vaultQueries = [
+  'apy.window=1d',
+  'include=access',
+  'include=apy',
+  'include=capabilities',
+  'include=token.logoUri',
+  'include=tvl',
+  'include=zone',
+] as const
+
+const collectionQueries = ['capability=deposit', ...vaultQueries] as const
+
+QueryBench.bench({
+  name: 'getEarnVaults',
+  path: '/v1/earn/vaults',
+  queries: collectionQueries,
+})
+
+QueryBench.bench({
+  name: 'getVerifiedEarnVaults',
+  path: '/v1/earn/vaults/verified',
+  queries: collectionQueries,
+})
+
+QueryBench.bench({
+  name: 'getEarnAddressPositions',
+  path: {
+    4217: `/v1/earn/addresses/${fixtures[4217].address}/positions`,
+    42431: `/v1/earn/addresses/${fixtures[42431].address}/positions`,
+  },
+  queries: ['valuation.currency=USD', 'verified=true'],
+})
+
+QueryBench.bench({
+  name: 'getEarnVaultPosition',
+  path: {
+    4217: `/v1/earn/vaults/${fixtures[4217].vault}/positions/${fixtures[4217].address}`,
+    42431: `/v1/earn/vaults/${fixtures[42431].vault}/positions/${fixtures[42431].address}`,
+  },
+})
+
+QueryBench.bench({
+  name: 'getEarnVaultEarnings',
+  path: {
+    4217: `/v1/earn/vaults/${fixtures[4217].vault}/earnings/${fixtures[4217].address}`,
+    42431: `/v1/earn/vaults/${fixtures[42431].vault}/earnings/${fixtures[42431].address}`,
+  },
+  queries: ['period=30d', 'period=active'],
+})
+
+QueryBench.bench({
+  name: 'getEarnVault',
+  path: {
+    4217: `/v1/earn/vaults/${fixtures[4217].vault}`,
+    42431: `/v1/earn/vaults/${fixtures[42431].vault}`,
+  },
+  queries: vaultQueries,
+})

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

@@ -88,6 +88,33 @@ describe('schema.getEarnVaults.Query', () => {
   })
 })
 
+describe('schema.getEarnAddressPositions.Query', () => {
+  test('parses collection filters', () => {
+    const query = Earn.schema.getEarnAddressPositions.Query.parse({
+      limit: '5',
+      'valuation.currency': 'usd',
+      verified: 'true',
+    })
+
+    expect(query.limit).toBe(5)
+    expect(query['valuation.currency']).toBe('USD')
+    expect(query.verified).toBe(true)
+  })
+
+  test('defaults the page size', () => {
+    expect(Earn.schema.getEarnAddressPositions.Query.parse({}).limit).toBe(10)
+  })
+
+  test('rejects vault-collection filters', () => {
+    expect(() =>
+      Earn.schema.getEarnAddressPositions.Query.parse({ capability: 'deposit' }),
+    ).toThrow()
+    expect(() =>
+      Earn.schema.getEarnAddressPositions.Query.parse({ asset: `0x${'aa'.repeat(20)}` }),
+    ).toThrow()
+  })
+})
+
 describe('schema.getEarnVaultEarnings.Response', () => {
   test('enforces status-specific earnings fields', () => {
     const response = {
@@ -540,6 +567,144 @@ describe('GET /v1/earn/vaults/verified', () => {
   )
 })
 
+describe('GET /v1/earn/addresses/:address/positions', () => {
+  test('returns chain selection errors', async () => {
+    const app = TestApp.create({ auth: false, cache })
+    const invalid = await app.request(
+      `/v1/earn/addresses/${TestEarn.positionAddress}/positions?chainId=abc`,
+    )
+    const unsupported = await app.request(
+      `/v1/earn/addresses/${TestEarn.positionAddress}/positions?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 a malformed account address', async () => {
+    const response = await TestApp.create({ auth: false, cache }).request(
+      '/v1/earn/addresses/not-an-address/positions',
+    )
+
+    expect(response.status).toBe(400)
+    expect(await TestApp.json(response, Schema.ErrorResponse)).toMatchObject({
+      error: { code: 'positions_invalid' },
+    })
+  })
+
+  test('returns an empty verified page without curated vaults', async () => {
+    const app = TestApp.create({ auth: false, cache })
+    const response = await app.request(
+      `/v1/earn/addresses/${TestEarn.positionAddress}/positions?verified=true`,
+    )
+
+    expect(response.status).toBe(200)
+    expect(
+      await TestApp.json(response, Earn.schema.getEarnAddressPositions.Response),
+    ).toStrictEqual({ data: [], nextCursor: null })
+  })
+
+  test.runIf(Runtime.get().mode === 'testnet')(
+    'lists non-zero verified positions for an account',
+    async () => {
+      const db = TestApp.database()
+      // Valuation resolves through the curated verified list, so seed it.
+      await TestApp.verifiedSeed(db, TestEarn.chain.id)
+      await core_EarnVaults.upsert(db, TestEarn.verifiedVault)
+      await core_EarnVaults.upsert(db, {
+        ...TestEarn.verifiedVault,
+        description: 'Active-earnings Earn deployment.',
+        label: 'Active btPATHUSD Earn',
+        vaultAddress: TestEarn.activeEarningsVaultAddress,
+      })
+      const app = TestApp.create({ auth: false, cache, db, zones: [TestEarn.zone] })
+      const response = await app.request(
+        `/v1/earn/addresses/${TestEarn.activeEarningsAddress}/positions?chainId=${TestEarn.chain.id}&verified=true&valuation.currency=USD`,
+      )
+
+      expect(response.status).toBe(200)
+      const body = await TestApp.json(response, Earn.schema.getEarnAddressPositions.Response)
+      expect(body.data.every((position) => BigInt(position.shareAmount.amount) > 0n)).toBe(true)
+      const row = body.data.find(
+        (position) => position.vaultAddress === TestEarn.activeEarningsVaultAddress,
+      )
+      expect(row).toBeDefined()
+      if (!row) return
+      // Amounts render in their own token's display currency and precision.
+      expect(row.shareAmount.currency).toBe(row.shareToken.currency)
+      expect(row.shareAmount.decimals).toBe(row.shareToken.decimals)
+      expect(row.assetAmount.currency).toBe(row.assetToken.currency)
+      expect(row.assetAmount.decimals).toBe(row.assetToken.decimals)
+      // A USD-denominated asset values identically without consulting rates.
+      expect(row.valuation).toStrictEqual({ amount: row.assetAmount.formatted, currency: 'USD' })
+      expect(body.meta).toBeUndefined()
+      expect({
+        assetToken: row.assetToken.address,
+        formattedShape: /^\d+(\.\d+)?$/.test(row.assetAmount.formatted),
+        id: row.id,
+        sharesHeld: BigInt(row.shareAmount.amount) > 0n,
+        valued: BigInt(row.assetAmount.amount) > 0n,
+        vaultAddress: row.vaultAddress,
+        verified: row.verified,
+      }).toMatchInlineSnapshot(`
+        {
+          "assetToken": "0x20c0000000000000000000000000000000000001",
+          "formattedShape": true,
+          "id": "0x3e4405801a1bee1b58394228ea0b44b667e222fc",
+          "sharesHeld": true,
+          "valued": true,
+          "vaultAddress": "0x3e4405801a1bee1b58394228ea0b44b667e222fc",
+          "verified": true,
+        }
+      `)
+    },
+    60_000,
+  )
+
+  test.runIf(Runtime.get().mode === 'testnet')(
+    'discovers held vaults from indexed share balances',
+    async () => {
+      const app = TestApp.create({ auth: false, cache, zones: [TestEarn.zone] })
+      const response = await app.request(
+        `/v1/earn/addresses/${TestEarn.activeEarningsAddress}/positions?chainId=${TestEarn.chain.id}`,
+      )
+
+      expect(response.status).toBe(200)
+      const body = await TestApp.json(response, Earn.schema.getEarnAddressPositions.Response)
+      expect(body.data.map((position) => position.vaultAddress)).toContain(
+        TestEarn.activeEarningsVaultAddress,
+      )
+      expect(
+        body.data.every(
+          (position) =>
+            position.id === position.vaultAddress &&
+            !position.verified &&
+            /^\d+$/.test(position.assetAmount.amount) &&
+            BigInt(position.shareAmount.amount) > 0n &&
+            position.assetToken.address.startsWith('0x20c0') &&
+            position.shareToken.address.startsWith('0x20c0'),
+        ),
+      ).toBe(true)
+
+      // An address-keyset cursor excludes every vault at or before it.
+      const cursor = Cursor.encode([TestEarn.activeEarningsVaultAddress])
+      const paged = await app.request(
+        `/v1/earn/addresses/${TestEarn.activeEarningsAddress}/positions?chainId=${TestEarn.chain.id}&cursor=${encodeURIComponent(cursor)}`,
+      )
+      expect(paged.status).toBe(200)
+      const pagedBody = await TestApp.json(paged, Earn.schema.getEarnAddressPositions.Response)
+      expect(
+        pagedBody.data.every(
+          (position) => position.vaultAddress > TestEarn.activeEarningsVaultAddress,
+        ),
+      ).toBe(true)
+    },
+    90_000,
+  )
+})
+
 describe('GET /v1/earn/vaults/:vaultId', () => {
   test('rejects a malformed vault address', async () => {
     const app = TestApp.create({ auth: false, cache })
@@ -1375,6 +1540,7 @@ describe('OpenAPI', () => {
 
     expect(Object.keys(spec.paths)).toEqual(
       expect.arrayContaining([
+        '/v1/earn/addresses/{address}/positions',
         '/v1/earn/vaults',
         '/v1/earn/vaults/verified',
         '/v1/earn/vaults/{vaultId}',
@@ -1446,6 +1612,37 @@ describe('OpenAPI', () => {
     expect(vaultId?.schema?.examples).toStrictEqual([TestEarn.mainnetVaultAddress])
   })
 
+  test('documents address-position inputs and responses', 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/addresses/{address}/positions']?.get
+    const address = operation?.parameters?.find((parameter) => parameter.name === 'address')
+    const denomination = operation?.parameters?.find(
+      (parameter) => parameter.name === 'valuation.currency',
+    )
+    const verified = operation?.parameters?.find((parameter) => parameter.name === 'verified')
+    const response = JSON.stringify(operation?.responses)
+
+    expect(operation?.description).toContain('currently holds shares')
+    expect(address?.schema?.examples).toStrictEqual([TestEarn.positionAddress])
+    expect(denomination?.description).toContain('nominal value')
+    expect(verified?.description).toContain('registry-curated')
+    expect(verified?.schema?.examples).toStrictEqual([true])
+    expect(response).toContain('"chain_id_invalid"')
+    expect(response).toContain('"chain_id_unsupported"')
+    expect(response).toContain('"positions_invalid"')
+    expect(response).toContain('"query_invalid"')
+    expect(response).toContain('Stable resource ID for this position')
+    expect(response).toContain('Current asset value of the held shares')
+    expect(response).toContain('"assetAmount"')
+    expect(response).toContain('"shareAmount"')
+    expect(response).toContain('"valuation"')
+    expect(response).toContain('"vaultAddress"')
+    expect(response).toContain('"nextCursor"')
+    // Token references embed the trimmed token object, not a bare address.
+    expect(response).toContain('"symbol"')
+  })
+
   test('documents vault-earnings variants', async () => {
     const app = TestApp.create({ auth: false, cache })
     const spec = (await (await app.request('/openapi.json')).json()) as OpenApiDocument