tapimo 0.14.0 → 0.15.1

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

@@ -11,6 +11,7 @@ import * as Runtime from '../../../../test/runtime.js'
 import * as Tempo from '../../../../test/Tempo.js'
 import * as Cursor from '../../../internal/Cursor.js'
 import * as Store from '../../../internal/Store.js'
+import * as Tidx from '../../../internal/Tidx.js'
 import * as Activities from './activities.js'
 import * as Transactions from './transactions.js'
 
@@ -148,6 +149,82 @@ describe('GET /addresses/:address/activities', () => {
     ).toStrictEqual(['zones'])
   })
 
+  test('parses activity type filters with OR semantics', () => {
+    expect(
+      Activities.schema.getAddressActivities.Query.parse({ type: 'transfer, swap' }).type,
+    ).toStrictEqual(['transfer', 'swap'])
+    expect(
+      Activities.schema.getAddressActivities.Query.safeParse({ type: 'not-an-activity' }).success,
+    ).toBe(false)
+  })
+
+  test('validates raw token amount filters', () => {
+    expect(
+      Activities.schema.getAddressActivities.Query.parse({
+        'amount.from': '1000000',
+        'amount.to': '2000000',
+      }),
+    ).toMatchObject({ 'amount.from': '1000000', 'amount.to': '2000000' })
+    expect(
+      Activities.schema.getAddressActivities.Query.safeParse({ 'amount.from': '1.5' }).success,
+    ).toBe(false)
+    expect(
+      Activities.schema.getAddressActivities.Query.safeParse({
+        'amount.from': '2',
+        'amount.to': '1',
+      }).success,
+    ).toBe(false)
+  })
+
+  test('normalizes participant and token filters', () => {
+    expect(
+      Activities.schema.getAddressActivities.Query.parse({
+        recipient: '0x1111111111111111111111111111111111111111',
+        sender: '0x2222222222222222222222222222222222222222',
+        token: Addresses.pathUsd.toUpperCase().replace('0X', '0x'),
+      }),
+    ).toMatchObject({
+      recipient: '0x1111111111111111111111111111111111111111',
+      sender: '0x2222222222222222222222222222222222222222',
+      token: Addresses.pathUsd.toLowerCase(),
+    })
+    expect(
+      Activities.schema.getAddressActivities.Query.safeParse({ sender: 'not-an-address' }).success,
+    ).toBe(false)
+  })
+
+  test('validates valuation amount filters', () => {
+    expect(
+      Activities.schema.getAddressActivities.Query.parse({
+        'valuation.amount.from': '1.25',
+        'valuation.amount.to': '10',
+        'valuation.currency': 'usd',
+      }),
+    ).toMatchObject({
+      'valuation.amount.from': '1.25',
+      'valuation.amount.to': '10',
+      'valuation.currency': 'USD',
+    })
+    expect(
+      Activities.schema.getAddressActivities.Query.safeParse({
+        'valuation.amount.from': '1',
+      }).success,
+    ).toBe(false)
+    expect(
+      Activities.schema.getAddressActivities.Query.safeParse({
+        'valuation.amount.from': '10',
+        'valuation.amount.to': '1',
+        'valuation.currency': 'USD',
+      }).success,
+    ).toBe(false)
+    expect(
+      Activities.schema.getAddressActivities.Query.safeParse({
+        'valuation.amount.from': '1.0000001',
+        'valuation.currency': 'USD',
+      }).success,
+    ).toBe(false)
+  })
+
   test('returns a newest-first, schema-valid feed with timing', async () => {
     const response = await request(accounts.keychain, { limit: '10' })
     expect(response.status).toBe(200)
@@ -168,6 +245,143 @@ describe('GET /addresses/:address/activities', () => {
     expect(find(body.data, type)).toBeDefined()
   })
 
+  test('filters activities by type', async () => {
+    const body = await activities(accounts.creator, { type: 'transfer' })
+    expect(body.data.length).toBeGreaterThan(0)
+    expect(body.data.every((entry) => entry.type === 'transfer')).toBe(true)
+  })
+
+  test('filters activities by raw token amount', async () => {
+    const unfiltered = await activities(accounts.creator, { type: 'transfer' })
+    const transfer = unfiltered.data.find((entry) => entry.type === 'transfer')
+    expect(transfer?.type).toBe('transfer')
+    if (transfer?.type !== 'transfer') return
+
+    const amount = transfer.data.sourceAmount.baseUnits
+    const filtered = await activities(accounts.creator, {
+      'amount.from': amount,
+      'amount.to': amount,
+      type: 'transfer',
+    })
+    expect(
+      filtered.data.some(
+        (entry) => entry.type !== 'group' && entry.transactionHash === transfer.transactionHash,
+      ),
+    ).toBe(true)
+  })
+
+  test.skipIf(runtime.mode !== 'localnet')(
+    'filters and paginates indexed transfers by inclusive raw amount',
+    async () => {
+      const address = localAccounts!.amountRecipient
+      const query = {
+        'amount.from': '9007199254740992',
+        'amount.to': '9007199254740997',
+        limit: '5',
+        type: 'transfer',
+      }
+      const first = await activities(address, query)
+      const second = await activities(address, { ...query, cursor: first.nextCursor! })
+      const entries = [...first.data, ...second.data]
+
+      expect(first.data).toHaveLength(5)
+      expect(first.nextCursor).not.toBeNull()
+      expect(second.data).toHaveLength(1)
+      expect(second.nextCursor).toBeNull()
+      expect(
+        entries.map((entry) => {
+          if (entry.type !== 'transfer') throw new Error('Expected a transfer activity.')
+          return entry.data.sourceAmount.baseUnits
+        }),
+      ).toStrictEqual([
+        '9007199254740997',
+        '9007199254740996',
+        '9007199254740995',
+        '9007199254740994',
+        '9007199254740993',
+        '9007199254740992',
+      ])
+      expect(new Set(entries.map((entry) => entry.id)).size).toBe(6)
+    },
+  )
+
+  test.skipIf(runtime.mode !== 'localnet')(
+    'paginates complete transfer transactions beyond the scan limit',
+    async () => {
+      const address = localAccounts!.batchedAmountRecipient
+      if (process.env.TIDX_CLICKHOUSE_ENABLED === 'false') {
+        const tidx = Tidx.getClient({
+          chainId: runtime.chainId,
+          tidx: { baseUrl: runtime.tidxUrl },
+        })
+        await expect(tidx.fetch({ engine: 'clickhouse', query: 'SELECT 1' })).rejects.toMatchObject(
+          { status: 400 },
+        )
+      }
+
+      const query = { limit: '5', type: 'transfer' }
+      const first = await activities(address, query)
+      expect(first.data).toHaveLength(28)
+      expect(first.nextCursor).not.toBeNull()
+      const second = await activities(address, { ...query, cursor: first.nextCursor! })
+      expect(second.data).toHaveLength(2)
+      expect(second.nextCursor).toBeNull()
+
+      const entries = [...first.data, ...second.data]
+      expect(new Set(entries.map((entry) => entry.id)).size).toBe(30)
+      expect(
+        entries.map((entry) => {
+          if (entry.type !== 'transfer') throw new Error('Expected a transfer activity.')
+          return entry.data.sourceAmount.baseUnits
+        }),
+      ).toStrictEqual([
+        ...Array.from({ length: 24 }, (_, index) => String(100 + index)),
+        ...Array.from({ length: 6 }, (_, index) => String(85 - index)),
+      ])
+
+      // A candidate filter must not shrink the hydrated transaction before
+      // classification, and exact refinement must still remove nonmatching items.
+      const filtered = await activities(address, { ...query, 'amount.to': '110' })
+      expect(filtered.data).toHaveLength(15)
+      expect(filtered.nextCursor).not.toBeNull()
+      expect(
+        filtered.data.map((entry) => {
+          if (entry.type !== 'transfer') throw new Error('Expected a transfer activity.')
+          return entry.data.sourceAmount.baseUnits
+        }),
+      ).toStrictEqual([
+        ...Array.from({ length: 11 }, (_, index) => String(100 + index)),
+        '85',
+        '84',
+        '83',
+        '82',
+      ])
+    },
+  )
+
+  test.skipIf(runtime.mode !== 'localnet')(
+    'filters address activities by valuation amount',
+    async () => {
+      const db = TestApp.database()
+      await TestApp.verifiedSeed(db, runtime.chainId)
+      const client = TestApp.client({ db, fx: { oracle: fixed } })
+      const response = await client.v1.addresses[':address'].activities.$get(
+        {
+          param: { address: accounts.creator },
+          query: {
+            limit: '50',
+            'valuation.amount.from': '999999999999',
+            'valuation.currency': 'AUD',
+          },
+        },
+        TestApp.auth,
+      )
+      const body = await TestApp.json(response, Activities.schema.getAddressActivities.Response)
+      expect(response.status).toBe(200)
+      expect(body.data).toStrictEqual([])
+    },
+  )
+
   // 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')(
@@ -335,6 +549,44 @@ describe('GET /addresses/:address/activities', () => {
     },
   )
 
+  test.skipIf(runtime.mode !== 'localnet')(
+    'filters indexed activities by sender, recipient, and token',
+    async () => {
+      const crossToken = runtime.fixtures?.crossTokenTransfer
+      expect(crossToken).toBeDefined()
+      if (!crossToken) return
+
+      const query = {
+        recipient: crossToken.recipient,
+        sender: crossToken.sender,
+        token: crossToken.destinationToken,
+        type: 'transfer',
+      }
+      const incoming = await activities(crossToken.recipient, query)
+      const outgoing = await activities(crossToken.sender, query)
+      const excluded = await activities(crossToken.recipient, {
+        ...query,
+        token: crossToken.sourceToken,
+      })
+
+      expect(
+        incoming.data.some(
+          (entry) => entry.type !== 'group' && entry.transactionHash === crossToken.hash,
+        ),
+      ).toBe(true)
+      expect(
+        outgoing.data.some(
+          (entry) => entry.type !== 'group' && entry.transactionHash === crossToken.hash,
+        ),
+      ).toBe(true)
+      expect(
+        excluded.data.some(
+          (entry) => entry.type !== 'group' && entry.transactionHash === crossToken.hash,
+        ),
+      ).toBe(false)
+    },
+  )
+
   test.skipIf(runtime.mode === 'localnet')(
     'folds consecutive access-key items into a group when group=true',
     async () => {
@@ -859,6 +1111,132 @@ describe('GET /transactions/:transactionHash/activities', () => {
 describe('Activities.list classification', () => {
   const viewer = '0x1111111111111111111111111111111111111111' as Address.Address
 
+  test('uses one timed TIDX request per logical source', async () => {
+    const other = '0x2222222222222222222222222222222222222222' as Address.Address
+    const timings: string[] = []
+    const txHash = `0x${'1'.repeat(64)}` as Hex.Hex
+    const tidx = {
+      fetch: async ({ query }: { query: string }) => {
+        if (query.includes('WITH outbound_candidates'))
+          return {
+            rows: [
+              {
+                address: viewer,
+                block_num: 100,
+                block_timestamp: 1_700_000_000,
+                data: '0x',
+                fee_payer: viewer,
+                from: viewer,
+                log_idx: 0,
+                selector: null,
+                topic1: null,
+                topic2: null,
+                topic3: null,
+                tx_hash: txHash,
+                tx_idx: 1,
+              },
+            ],
+          }
+        if (query.includes('WITH transfer_candidates'))
+          return {
+            rows: Array.from({ length: 8 }, (_, index) => ({
+              address: viewer,
+              amount: String(index + 1),
+              block_num: 99 - index,
+              block_timestamp: 1_700_000_001 + index,
+              from: index < 4 ? other : viewer,
+              log_idx: index,
+              to: index < 4 ? viewer : other,
+              tx_hash: `0x${(index + 2).toString(16).repeat(64)}`,
+              tx_idx: 8 - index,
+            })),
+          }
+        return { rows: [] }
+      },
+    } as unknown as Parameters<typeof Activities.tidx>[0]['tidx']
+    const provider = Activities.tidx({
+      chainId: 4217,
+      tidx,
+      time: async (name, fn) => {
+        timings.push(name)
+        return fn()
+      },
+    })
+
+    const { rows } = await provider.fetchRows({ address: viewer, limit: 1 })
+
+    expect(new Set(timings)).toEqual(
+      new Set(['address_activity_outbound', 'address_activity_transfers']),
+    )
+    const transfers = rows.filter((row) => row.source === 'q2')
+    expect({
+      inbound: transfers.filter((row) => row.transferTo === viewer).length,
+      outbound: transfers.filter((row) => row.transferFrom === viewer).length,
+      rows: transfers.length,
+      sample: transfers
+        .slice(0, 1)
+        .map((row) => [row.transferAmount, row.transferFrom, row.transferTo, row.transferToken]),
+    }).toMatchInlineSnapshot(`
+      {
+        "inbound": 4,
+        "outbound": 4,
+        "rows": 8,
+        "sample": [
+          [
+            1n,
+            "0x2222222222222222222222222222222222222222",
+            "0x1111111111111111111111111111111111111111",
+            "0x1111111111111111111111111111111111111111",
+          ],
+        ],
+      }
+    `)
+  })
+
+  test('refines participants, tokens, and amounts with same-leg semantics', () => {
+    const tokenA = '0x2222222222222222222222222222222222222222' as Address.Address
+    const tokenB = '0x3333333333333333333333333333333333333333' as Address.Address
+    const sender = '0x4444444444444444444444444444444444444444' as Address.Address
+    const recipient = '0x5555555555555555555555555555555555555555' as Address.Address
+    const token = (address: Address.Address, amount: bigint) => ({
+      address,
+      amount: amount.toString(),
+    })
+    const item = (data: Record<string, unknown>) =>
+      ({ data }) as unknown as Activities.UnenrichedItem
+    const source = item({ sourceToken: token(tokenA, 50n) })
+    const destination = item({
+      destinationToken: token(tokenB, 100n),
+      recipient,
+      sender,
+      sourceToken: token(tokenA, 1n),
+    })
+    const refund = item({ refund: token(tokenA, 500n), sourceToken: token(tokenA, 1_000n) })
+    const splitBounds = item({
+      refund: token(tokenA, 10n),
+      sourceToken: token(tokenA, 1_000n),
+    })
+
+    expect(
+      Activities.filterActivities({
+        filter: { amount: { from: 50n, to: 500n } },
+        items: [source, destination, refund, splitBounds],
+      }),
+    ).toStrictEqual([source, destination, refund])
+    expect(
+      Activities.filterActivities({
+        filter: { amount: { from: 100n, to: 100n }, recipient, sender, token: tokenA },
+        items: [destination],
+      }),
+    ).toStrictEqual([])
+    expect(
+      Activities.filterActivities({
+        filter: { amount: { from: 100n, to: 100n }, recipient, sender, token: tokenB },
+        items: [destination],
+      }),
+    ).toStrictEqual([destination])
+  })
+
   /** A memory store pre-seeded so the MPP directory fetch never hits the network. */
   function store() {
     const store = Store.memory()
@@ -947,6 +1325,37 @@ describe('Activities.list classification', () => {
     expect(new Set(items.map((item) => item.id)).size).toBe(2)
   })
 
+  test('scans bounded pages to fill a filtered activity page', async () => {
+    const rows = Array.from({ length: 30 }, (_, index) =>
+      unknownRow({
+        blockNum: 100 - index,
+        blockTimestamp: 1_700_000_000 - index,
+        hash: ((index % 9) + 1).toString(),
+      }),
+    )
+    let calls = 0
+    const source = pagedProvider(rows)
+    const result = await Activities.list(
+      {
+        cursorForGroup: (group) => source.cursorForGroup(group),
+        fetchRows: async (options) => {
+          calls++
+          return source.fetchRows(options)
+        },
+      },
+      {
+        address: viewer,
+        filter: { refine: (items) => items.filter((item) => item.type === 'transfer') },
+        limit: 5,
+        store: store(),
+      },
+    )
+
+    expect(result.items).toStrictEqual([])
+    expect(result.nextCursor).not.toBeNull()
+    expect(calls).toBe(3)
+  })
+
   test('merges chain pages and retains each provider cursor', async () => {
     const providers = [
       {
@@ -1252,12 +1661,15 @@ describe('Activities.list precompile classification', () => {
         type: 'event',
       },
     ] as const
-    const abi = [...Abis.abis, ...Abis.earnRouter, ...Abis.earnVault, ...erc4626Events]
-    const event = abi.find((a) => a.type === 'event' && a.name === options.eventName) as {
-      inputs: readonly Param[]
-    }
+    const abi = [...Abis.core, ...Abis.earnRouter, ...Abis.earnVault, ...erc4626Events]
+    const event = abi.find(
+      (a) =>
+        a.type === 'event' &&
+        a.name === options.eventName &&
+        a.inputs.every((input) => !input.name || input.name in options.args),
+    ) as { inputs: readonly Param[]; name: string; type: 'event' }
     const topics = encodeEventTopics({
-      abi,
+      abi: [event],
       eventName: options.eventName as never,
       args: options.args as never,
     }) as (string | null)[]
@@ -2190,7 +2602,7 @@ describe('Activities.list precompile classification', () => {
     expect(items[1]?.type === 'session-closed' && items[1].data.refund).toBeUndefined()
   })
 
-  test('folds the router funding leg into a private Earn deposit', async () => {
+  test('folds the router routes leg into a private Earn deposit', async () => {
     const actionId = `0x${'c'.repeat(64)}` as Hex.Hex
     const router = '0x9999999999999999999999999999999999999999' as Address.Address
     const asset = '0x4444444444444444444444444444444444444444' as Address.Address
@@ -2844,7 +3256,7 @@ describe('Activities.list precompile classification', () => {
     expect(items.map((item) => item.type)).toEqual(['transfer', 'fees-distributed'])
   })
 
-  test('keeps a same-amount payment beside a reward funding', async () => {
+  test('keeps a same-amount payment beside a reward routes', async () => {
     const other = '0x7777777777777777777777777777777777777777' as Address.Address
     const items = await classify([
       transferRow({ from: viewer, logIdx: 0, to: other, token: tokenA, value: 77n }),