tapimo 0.8.0 → 0.10.0

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

@@ -28,6 +28,7 @@ type OpenApiDocument = {
     string,
     {
       get?: {
+        description?: string
         parameters?: readonly {
           description?: string
           name?: string
@@ -87,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 = {
@@ -109,12 +137,6 @@ describe('schema.getEarnVaultEarnings.Response', () => {
         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',
@@ -125,12 +147,23 @@ describe('schema.getEarnVaultEarnings.Response', () => {
         period: 'active',
         status: 'incomplete_cost_basis',
       }).success,
+      incompleteWindow: Earn.schema.getEarnVaultEarnings.Response.safeParse({
+        ...response,
+        period: '30d',
+        status: 'incomplete_cost_basis',
+      }).success,
       incompleteWithEarnings: Earn.schema.getEarnVaultEarnings.Response.safeParse({
         ...response,
         lifetimeEarnings: '0',
         period: 'lifetime',
         status: 'incomplete_cost_basis',
       }).success,
+      lifetime: Earn.schema.getEarnVaultEarnings.Response.safeParse({
+        ...response,
+        lifetimeEarnings: '0',
+        period: 'lifetime',
+        status: 'complete',
+      }).success,
       pending: Earn.schema.getEarnVaultEarnings.Response.safeParse({
         ...response,
         period: 'lifetime',
@@ -141,34 +174,77 @@ describe('schema.getEarnVaultEarnings.Response', () => {
         period: 'active',
         status: 'pending_redemption',
       }).success,
+      pendingWindow: Earn.schema.getEarnVaultEarnings.Response.safeParse({
+        ...response,
+        period: '30d',
+        status: 'pending_redemption',
+      }).success,
       pendingWithEarnings: Earn.schema.getEarnVaultEarnings.Response.safeParse({
         ...response,
         lifetimeEarnings: '0',
         period: 'lifetime',
         status: 'pending_redemption',
       }).success,
+      window: Earn.schema.getEarnVaultEarnings.Response.safeParse({
+        ...response,
+        period: '30d',
+        status: 'complete',
+        windowEarnings: '0',
+      }).success,
+      windowWithActiveEarnings: Earn.schema.getEarnVaultEarnings.Response.safeParse({
+        ...response,
+        activeEarnings: '0',
+        period: '30d',
+        status: 'complete',
+      }).success,
+      windowWithoutEarnings: Earn.schema.getEarnVaultEarnings.Response.safeParse({
+        ...response,
+        period: '30d',
+        status: 'complete',
+      }).success,
     }).toMatchInlineSnapshot(`
       {
         "active": true,
         "activeWithLifetimeEarnings": false,
         "completeWithoutEarnings": false,
         "incomplete": true,
+        "incompleteWindow": true,
         "incompleteWithEarnings": false,
         "lifetime": true,
         "pending": true,
         "pendingActive": false,
+        "pendingWindow": true,
         "pendingWithEarnings": false,
+        "window": true,
+        "windowWithActiveEarnings": false,
+        "windowWithoutEarnings": false,
       }
     `)
   })
 })
 
 describe('schema.getEarnVaultEarnings.Query', () => {
-  test('defaults to lifetime and accepts active earnings', () => {
+  test('defaults to lifetime and accepts active and trailing earnings', () => {
     expect([
       Earn.schema.getEarnVaultEarnings.Query.parse({}).period,
+      Earn.schema.getEarnVaultEarnings.Query.parse({ period: '30d' }).period,
       Earn.schema.getEarnVaultEarnings.Query.parse({ period: 'active' }).period,
-    ]).toStrictEqual(['lifetime', 'active'])
+    ]).toStrictEqual(['lifetime', '30d', 'active'])
+  })
+})
+
+describe('calculateWindowEarnings', () => {
+  test('adjusts snapshot growth for deposits and realized assets', () => {
+    expect(
+      Earn.calculateWindowEarnings({
+        deposited: 50n,
+        endingValue: 130n,
+        finalized: 10n,
+        openingValue: 100n,
+        redeemed: 15n,
+        withdrewExact: 5n,
+      }),
+    ).toBe(10n)
   })
 })
 
@@ -491,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 })
@@ -1098,6 +1312,30 @@ describe('GET /v1/earn/vaults/:vaultId/earnings/:address', () => {
     60_000,
   )
 
+  test.runIf(Runtime.get().mode === 'testnet')(
+    'returns cash-flow-adjusted trailing earnings',
+    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=30d`,
+      )
+
+      expect(response.status).toBe(200)
+      const earnings = await TestApp.json(response, Earn.schema.getEarnVaultEarnings.Response)
+      if (earnings.status !== 'complete' || earnings.period !== '30d')
+        throw new Error('Expected complete trailing earnings history.')
+      expect(earnings).toMatchObject({
+        account: TestEarn.activeEarningsAddress,
+        period: '30d',
+        status: 'complete',
+        windowEarnings: expect.stringMatching(/^-?\d+$/),
+      })
+      expect(earnings).not.toHaveProperty('activeEarnings')
+      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 () => {
@@ -1302,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}',
@@ -1373,18 +1612,56 @@ 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
     const operation = spec.paths['/v1/earn/vaults/{vaultId}/earnings/{address}']?.get
+    const period = operation?.parameters?.find((parameter) => parameter.name === 'period')
     const response = JSON.stringify(operation?.responses)
 
+    expect(operation?.description).toContain('the trailing 30 days')
+    expect(period?.description).toContain('trailing 30 days')
+    expect(period?.schema?.enum).toStrictEqual(['30d', 'active', 'lifetime'])
+    expect(period?.schema?.examples).toStrictEqual(['lifetime'])
     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('Ending share value plus realized assets')
+    expect(response).toContain('cannot reconstruct the asset cost basis for the requested period')
     expect(response).toContain('"active"')
+    expect(response).toContain('"30d"')
     expect(response).toContain('"incomplete_cost_basis"')
     expect(response).toContain('"pending_redemption"')
   })