tapimo 0.10.1 → 0.10.2

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

@@ -976,9 +976,10 @@ function countFilters(options: countReceipts.Options): string[] {
 
 /**
  * Capped total count of receipts matching the same filters as the page. The
- * address scope reuses the page's `UNION` workaround (`receipts` indexes `from`
- * but not `to`, so the `to` side resolves hashes via the `txs` index), counting
- * the deduped keyset so self-receipts (`from = to`) aren't double-counted.
+ * address scope reuses the page's `UNION` workaround. Fee-payer filters make a
+ * direct `receipts.to` predicate selective; otherwise the `to` side resolves
+ * hashes via the `txs` index. The deduped keyset avoids double-counting
+ * self-receipts (`from = to`).
  * `totalCountCapped: true` is a lower bound — at least {@link Schema.countCap} matches.
  */
 export function countReceipts(
@@ -995,10 +996,11 @@ export function countReceipts(
         let query: string
         if (address !== undefined) {
           const fromWhere = [`"from" = '${address}'`, ...filters].join(' AND ')
-          const toWhere = [
-            `tx_hash IN (SELECT hash FROM txs WHERE "to" = '${address}')`,
-            ...filters,
-          ].join(' AND ')
+          const toPredicate =
+            options.feePayer !== undefined
+              ? `"to" = '${address}'`
+              : `tx_hash IN (SELECT hash FROM txs WHERE "to" = '${address}')`
+          const toWhere = [toPredicate, ...filters].join(' AND ')
           query = `
             SELECT count(*) AS total
             FROM (
@@ -1069,13 +1071,13 @@ export async function embedReceipts(
   const { chainId, include, rows } = options
   const found = new Map<string, humanizeReceipt.Output>()
 
-  // Only mined rows can have a receipt; their block numbers also feed the
-  // block bound the `logs` lookup requires.
-  const blocks: number[] = []
+  // Only mined rows can have a receipt; their block numbers also constrain the
+  // `logs` lookup to the page's exact blocks.
+  const blocks = new Set<number>()
   const hashes = new Set<string>()
   for (const row of rows) {
     if (row.blockNumber === null) continue
-    blocks.push(row.blockNumber)
+    blocks.add(row.blockNumber)
     hashes.add(row.hash.toLowerCase())
   }
   if (hashes.size === 0) return new Map()
@@ -1086,8 +1088,8 @@ export async function embedReceipts(
   // Raw-table queries (no signature-decoded CTE), so the inline SQL is cast to
   // `string`. The receipts lookup needs no block bound (`receipts.tx_hash` is
   // indexed — see the `sideQuery` comment in `getReceipts`); the logs lookup
-  // REQUIRES one: `logs` is sorted by block position, so a bare `tx_hash IN`
-  // scans to genesis (see `blockBound` in `transfers.ts`).
+  // uses the page's exact blocks so sparse transaction pages do not scan every
+  // block between their oldest and newest rows.
   const [receipts_result, logs_result] = await Timing.time(c, 'receipts_embed', () =>
     Promise.all([
       options.receipts
@@ -1100,7 +1102,7 @@ export async function embedReceipts(
       tidx.fetch({
         chainId,
         query:
-          `SELECT tx_hash, block_num, tx_idx, log_idx, address, selector, topic1, topic2, topic3, data, block_timestamp FROM logs WHERE block_num BETWEEN ${Math.min(...blocks)} AND ${Math.max(...blocks)} AND tx_hash IN (${inList}) ORDER BY block_num ASC, log_idx ASC` as string,
+          `SELECT tx_hash, block_num, tx_idx, log_idx, address, selector, topic1, topic2, topic3, data, block_timestamp FROM logs WHERE block_num IN (${[...blocks].join(', ')}) AND tx_hash IN (${inList}) ORDER BY block_num ASC, log_idx ASC` as string,
       }),
     ]),
   )

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

@@ -1228,12 +1228,13 @@ export async function resolveTokens(
   const logos = new Map(logoByAddress)
   const metadataMap = new Map(metadataByAddress)
   const onchainLogos = new Map(
-    includeLogoUri
+    includeLogoUri && options.metadata !== undefined
       ? await Timing.time(c, 'token_logo_uri', () =>
           Promise.all(
             addresses
               .filter(
                 (address) =>
+                  options.metadata?.has(address) === true &&
                   !logos.get(address) &&
                   !snapshot?.byAddress.get(address)?.logoUri &&
                   !metadataMap.get(address)?.logoUri,
@@ -1321,7 +1322,7 @@ function getTokenLogoUri(c: Context<App.Environment>, options: getTokenMetadata.
 
 /**
  * Resolves a token's on-chain metadata (`name`/`symbol`/`decimals`/`currency`/
- * `totalSupply`) via a single `token.getMetadata` RPC, memoized under the shared
+ * `logoUri`/`totalSupply`) via a single `token.getMetadata` RPC, memoized under the shared
  * `token:v1:{chainId}:{address}:metadata` key. Exported so feed enrichers (e.g.
  * `activities`) reuse the same cache entry as the token resource rather than
  * fetching metadata through a parallel path.

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

@@ -30,6 +30,14 @@ QueryBench.bench({
   },
 })
 
+QueryBench.bench({
+  name: 'getTransactions?address&include=receipt',
+  path: {
+    4217: `/v1/transactions?address=${address[4217]}&include=receipt`,
+    42431: `/v1/transactions?address=${address[42431]}&include=receipt`,
+  },
+})
+
 QueryBench.bench({
   name: 'getTransaction',
   path: {

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

@@ -437,10 +437,10 @@ export function transfers(options: transfers.Options = {}) {
           transactionHash: row.transactionHash,
         }))
 
-        // Memo/attribution are opt-in: one `TransferWithMemo` lookup bounded
-        // to the page's transactions resolves both — the decoded text `memo`,
-        // and `attribution` when the memo is a known MPP service fingerprint.
-        if (options.include.includes('memo') && data.length > 0) {
+        const includeCrossToken = options.include.includes('crossToken')
+        const includeMemo = options.include.includes('memo')
+        // Attach memos before cross-token folding changes the matching fields.
+        if (includeMemo && includeCrossToken && data.length > 0) {
           const memoByRow = await memoMap(c, { chainId, rows: data })
           data = data.map((transfer) => {
             const entry = memoByRow.get(
@@ -469,7 +469,7 @@ export function transfers(options: transfers.Options = {}) {
         // own event token is the delivered token), so a `token=` filter matches
         // cross-token rows by their destination token, and each transfer still
         // appears exactly once across pages.
-        if (options.include.includes('crossToken') && data.length > 0) {
+        if (includeCrossToken && data.length > 0) {
           const { fold, suppress } = await crossTokenMap(c, { chainId, rows: data })
           data = data.flatMap((transfer) => {
             const key = eventKey(transfer.transactionHash, transfer.logIndex)
@@ -502,11 +502,17 @@ export function transfers(options: transfers.Options = {}) {
             ]),
           ),
         )
-        const tokensByAddress = new Map<
-          string,
-          Awaited<ReturnType<typeof Tokens.getTokenMetadata>>
-        >()
-        await Timing.time(c, 'tokens', async () => {
+        // Memo and token metadata depend only on the page rows, so resolve
+        // them concurrently when cross-token folding is not requested.
+        const memoPromise =
+          includeMemo && !includeCrossToken && data.length > 0
+            ? memoMap(c, { chainId, rows: data })
+            : undefined
+        const tokensPromise = Timing.time(c, 'tokens', async () => {
+          const tokensByAddress = new Map<
+            string,
+            Awaited<ReturnType<typeof Tokens.getTokenMetadata>>
+          >()
           for (let index = 0; index < uniqueTokens.length; index += tokenReadChunkSize) {
             const group = uniqueTokens.slice(index, index + tokenReadChunkSize)
             const entries = await Promise.all(
@@ -536,7 +542,27 @@ export function transfers(options: transfers.Options = {}) {
             )
             for (const entry of entries) tokensByAddress.set(...entry)
           }
+          return tokensByAddress
         })
+        const [memoByRow, tokensByAddress] = await Promise.all([memoPromise, tokensPromise])
+        if (memoByRow)
+          data = data.map((transfer) => {
+            const entry = memoByRow.get(
+              transferKey(
+                transfer.transactionHash,
+                transfer.sender,
+                transfer.recipient,
+                transfer.sourceToken.amount,
+                transfer.sourceToken.address,
+              ),
+            )
+            if (!entry) return transfer
+            return {
+              ...transfer,
+              ...(entry.attribution ? { attribution: entry.attribution } : {}),
+              ...(entry.memo ? { memo: entry.memo } : {}),
+            }
+          })
 
         // Value each leg via its curated display currency, in the requested
         // denomination.

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

@@ -2276,16 +2276,11 @@ export async function poll(options: poll.Options): Promise<poll.Result> {
               // Token metadata is best-effort for webhooks: transfers use it for display,
               // while transactions expose fee-token references without blocking delivery.
               const enrichStartedAt = Date.now()
-              const data =
-                eventType === 'token:transfer'
-                  ? await withTokenMetadata(item.data, { cache: cache_metadata, chainId, client })
-                  : eventType === 'transaction:included'
-                    ? await withFeeTokenMetadata(item.data, {
-                        cache: cache_metadata,
-                        chainId,
-                        client,
-                      })
-                    : item.data
+              const data = await enrichEventData(eventType, item.data, {
+                cache: cache_metadata,
+                chainId,
+                client,
+              })
               durations.enrich += Date.now() - enrichStartedAt
               observed.add('enrich')
               options.signal?.throwIfAborted()
@@ -3074,6 +3069,32 @@ function decodeScanLog(log: ScanLog, event: AbiEvent): ScanLog {
   }
 }
 
+/**
+ * Attaches best-effort token metadata to one matched row before delivery.
+ * Transfers gain display metadata; transactions resolve their fee token.
+ */
+export async function enrichEventData(
+  eventType: EventType,
+  data: unknown,
+  options: enrichEventData.Options,
+): Promise<unknown> {
+  if (eventType === 'token:transfer') return withTokenMetadata(data, options)
+  if (eventType === 'transaction:included') return withFeeTokenMetadata(data, options)
+  return data
+}
+
+export declare namespace enrichEventData {
+  /** Metadata lookup dependencies. */
+  type Options = {
+    /** Memoization store for token metadata (5 minute TTL). */
+    cache: Store.Store
+    /** Chain the row was produced on. */
+    chainId: number
+    /** Client for `token.getMetadata` reads. */
+    client: Viem.getClient.ReturnType
+  }
+}
+
 /** Scans contract logs for one subscription, then re-checks every filter in memory. */
 async function scanLogs(options: {
   batchSize: number

package/src/apps/funding/routes/deposit-addresses.test.ts

@@ -966,6 +966,67 @@ describe.skipIf(!relayApiKey)('POST /funding/deposit-addresses (relay)', () => {
   })
 })
 
+describe('GET /funding/deposit-addresses', () => {
+  test('pages organization addresses and narrows project-attributed keys', async () => {
+    const app = transfersApp()
+    const first = await seedDepositAddress({ orgId: fundingAddressListReader.orgId })
+    const second = await seedDepositAddress({ orgId: fundingAddressListReader.orgId })
+    const third = await seedDepositAddress({ orgId: fundingAddressListReader.orgId })
+    const project = await seedDepositAddress({
+      orgId: fundingAddressListReader.orgId,
+      projectId: fundingAddressListProjectReader.projectId,
+    })
+    const sibling = await seedDepositAddress({
+      orgId: fundingAddressListReader.orgId,
+      projectId: 'prj_funding_address_list_sibling',
+    })
+    const sixth = await seedDepositAddress({ orgId: fundingAddressListReader.orgId })
+    await seedDepositAddress({ orgId: fundingForeign.orgId })
+    await seedDepositAddress({
+      environment: 'sandbox',
+      orgId: fundingAddressListReader.orgId,
+    })
+
+    const path = '/v1/funding/deposit-addresses'
+    expect((await app.request(path)).status).toBe(401)
+    expect((await app.request(path, as(TestApp.key))).status).toBe(403)
+
+    const response = await app.request(`${path}?limit=5`, as(fundingAddressListReader))
+    expect(response.status).toBe(200)
+    expect({
+      cacheControl: response.headers.get('cache-control'),
+      etag: response.headers.get('etag'),
+      vary: response.headers.get('vary'),
+    }).toEqual({
+      cacheControl: 'no-store',
+      etag: null,
+      vary: 'Accept-Encoding, Authorization, Tempo-API-Key, X-API-Key',
+    })
+    const body = await TestApp.json(response, Funding.schema.listFundingDepositAddresses.Response)
+    expect(body.data.map((address) => address.id)).toEqual([
+      sixth.id,
+      sibling.id,
+      project.id,
+      third.id,
+      second.id,
+    ])
+    expect(body.nextCursor).toBe(Cursor.encode([second.createdAt, second.id]))
+
+    const next = await TestApp.json(
+      await app.request(`${path}?limit=5&cursor=${body.nextCursor}`, as(fundingAddressListReader)),
+      Funding.schema.listFundingDepositAddresses.Response,
+    )
+    expect(next.data.map((address) => address.id)).toEqual([first.id])
+    expect(next.nextCursor).toBeNull()
+
+    const projectBody = await TestApp.json(
+      await app.request(path, as(fundingAddressListProjectReader)),
+      Funding.schema.listFundingDepositAddresses.Response,
+    )
+    expect(projectBody.data.map((address) => address.id)).toEqual([project.id])
+  })
+})
+
 describe('GET /funding/deposit-addresses/:id', () => {
   test('requires funding:read and returns the owned address', async () => {
     const app = transfersApp()
@@ -1329,6 +1390,63 @@ describe('GET /funding/deposits?depositAddress', () => {
   })
 })
 
+describe('GET /funding/deposits', () => {
+  test('pages organization deposits and narrows project-attributed keys', async () => {
+    const app = transfersApp()
+    const firstAddress = await seedDepositAddress({ orgId: fundingDepositListReader.orgId })
+    const secondAddress = await seedDepositAddress({ orgId: fundingDepositListReader.orgId })
+    const thirdAddress = await seedDepositAddress({ orgId: fundingDepositListReader.orgId })
+    const projectAddress = await seedDepositAddress({
+      orgId: fundingDepositListReader.orgId,
+      projectId: fundingDepositListProjectReader.projectId,
+    })
+    const siblingAddress = await seedDepositAddress({
+      orgId: fundingDepositListReader.orgId,
+      projectId: 'prj_funding_deposit_list_sibling',
+    })
+    const sixthAddress = await seedDepositAddress({ orgId: fundingDepositListReader.orgId })
+    const first = await seedDeposit(firstAddress)
+    const second = await seedDeposit(secondAddress)
+    const third = await seedDeposit(thirdAddress)
+    const project = await seedDeposit(projectAddress)
+    const sibling = await seedDeposit(siblingAddress)
+    const sixth = await seedDeposit(sixthAddress)
+    const foreignAddress = await seedDepositAddress({ orgId: fundingForeign.orgId })
+    await seedDeposit(foreignAddress)
+    const sandboxAddress = await seedDepositAddress({
+      environment: 'sandbox',
+      orgId: fundingDepositListReader.orgId,
+    })
+    await seedDeposit(sandboxAddress)
+
+    const path = '/v1/funding/deposits'
+    const response = await app.request(`${path}?limit=5`, as(fundingDepositListReader))
+    expect(response.status).toBe(200)
+    const body = await TestApp.json(response, Funding.schema.listFundingDeposits.Response)
+    expect(body.data.map((deposit) => deposit.id)).toEqual([
+      sixth.id,
+      sibling.id,
+      project.id,
+      third.id,
+      second.id,
+    ])
+    expect(body.nextCursor).toBe(Cursor.encode([second.createdAt, second.id]))
+
+    const next = await TestApp.json(
+      await app.request(`${path}?limit=5&cursor=${body.nextCursor}`, as(fundingDepositListReader)),
+      Funding.schema.listFundingDeposits.Response,
+    )
+    expect(next.data.map((deposit) => deposit.id)).toEqual([first.id])
+    expect(next.nextCursor).toBeNull()
+
+    const projectBody = await TestApp.json(
+      await app.request(path, as(fundingDepositListProjectReader)),
+      Funding.schema.listFundingDeposits.Response,
+    )
+    expect(projectBody.data.map((deposit) => deposit.id)).toEqual([project.id])
+  })
+})
+
 describe('GET /funding/deposits?recipient', () => {
   test('requires funding:read and pages recipient deposits across addresses', async () => {
     const app = transfersApp()
@@ -1336,7 +1454,6 @@ describe('GET /funding/deposits?recipient', () => {
     const path = `/v1/funding/deposits?recipient=${recipient.toLowerCase()}`
     expect((await app.request(path)).status).toBe(401)
     expect((await app.request(path, as(TestApp.key))).status).toBe(403)
-    expect((await app.request('/v1/funding/deposits', as(fundingReader))).status).toBe(400)
     expect(
       (await app.request('/v1/funding/deposits?depositAddress=', as(fundingReader))).status,
     ).toBe(400)
@@ -1347,7 +1464,7 @@ describe('GET /funding/deposits?recipient', () => {
           as(fundingReader),
         )
       ).status,
-    ).toBe(400)
+    ).toBe(200)
 
     const firstAddress = await seedDepositAddress({
       snapshot: TestFunding.depositAddressSnapshot({
@@ -1438,6 +1555,61 @@ describe('GET /funding/deposits?recipient', () => {
   })
 })
 
+describe('GET /funding/deposits?filters', () => {
+  test('AND-combines canonical aliases and includes the matching count', async () => {
+    const app = transfersApp()
+    const snapshot = TestFunding.depositAddressSnapshot({
+      address: 'TQn9Y2khEsLJW1ChVWFMSMeRDow5KcbLSE',
+    })
+    const address = await seedDepositAddress({
+      orgId: fundingDepositFilterReader.orgId,
+      snapshot,
+    })
+    const deposit = await seedDeposit(address)
+    const unrelatedAddress = await seedDepositAddress({
+      orgId: fundingDepositFilterReader.orgId,
+      snapshot: TestFunding.depositAddressSnapshot({
+        provider: { id: 'relay_unrelated', name: 'Relay' },
+        recipient: `0x${'22'.repeat(20)}`,
+      }),
+    })
+    await seedDeposit(unrelatedAddress)
+    const query = new URLSearchParams({
+      depositAddress: snapshot.address,
+      destinationToken: 'usdt0',
+      include: 'totalCount',
+      provider: 'relay',
+      recipient: snapshot.recipient.toLowerCase(),
+      sourceChain: 'tron',
+      sourceToken: 'usdt',
+      status: 'detected',
+    })
+
+    const body = await TestApp.json(
+      await app.request(`/v1/funding/deposits?${query}`, as(fundingDepositFilterReader)),
+      Funding.schema.listFundingDeposits.Response,
+    )
+    expect(body).toEqual({
+      data: [FundingDeposit.toPublic(deposit)],
+      meta: { totalCount: 1, totalCountCapped: false },
+      nextCursor: null,
+    })
+
+    const empty = await TestApp.json(
+      await app.request(
+        '/v1/funding/deposits?sourceToken=unknown&include=totalCount',
+        as(fundingDepositFilterReader),
+      ),
+      Funding.schema.listFundingDeposits.Response,
+    )
+    expect(empty).toEqual({
+      data: [],
+      meta: { totalCount: 0, totalCountCapped: false },
+      nextCursor: null,
+    })
+  })
+})
+
 describe('GET /funding/deposits/:id', () => {
   test('returns the owned deposit without private reconciliation state', async () => {
     const app = transfersApp()
@@ -1544,6 +1716,43 @@ const fundingReader = {
   token: 'secret_funding_reader',
 } satisfies TestApp.kvStore.Key
 
+const fundingAddressListReader = {
+  id: 'key_funding_address_list',
+  orgId: 'org_funding_address_list',
+  scopes: ['funding:read'],
+  token: 'secret_funding_address_list',
+} satisfies TestApp.kvStore.Key
+
+const fundingAddressListProjectReader = {
+  id: 'key_funding_address_list_project',
+  orgId: fundingAddressListReader.orgId,
+  projectId: 'prj_funding_address_list',
+  scopes: ['funding:read'],
+  token: 'secret_funding_address_list_project',
+} satisfies TestApp.kvStore.Key
+
+const fundingDepositListReader = {
+  id: 'key_funding_deposit_list',
+  orgId: 'org_funding_deposit_list',
+  scopes: ['funding:read'],
+  token: 'secret_funding_deposit_list',
+} satisfies TestApp.kvStore.Key
+
+const fundingDepositFilterReader = {
+  id: 'key_funding_deposit_filter',
+  orgId: 'org_funding_deposit_filter',
+  scopes: ['funding:read'],
+  token: 'secret_funding_deposit_filter',
+} satisfies TestApp.kvStore.Key
+
+const fundingDepositListProjectReader = {
+  id: 'key_funding_deposit_list_project',
+  orgId: fundingDepositListReader.orgId,
+  projectId: 'prj_funding_deposit_list',
+  scopes: ['funding:read'],
+  token: 'secret_funding_deposit_list_project',
+} satisfies TestApp.kvStore.Key
+
 const fundingProjectReader = {
   id: 'key_funding_project',
   orgId: 'org_funding',
@@ -1589,6 +1798,11 @@ function transfersApp(options: TestApp.create.Options = {}) {
     auth: {
       keys: [
         TestApp.key,
+        fundingAddressListProjectReader,
+        fundingAddressListReader,
+        fundingDepositFilterReader,
+        fundingDepositListProjectReader,
+        fundingDepositListReader,
         fundingForeign,
         fundingForeignWriter,
         fundingProjectReader,