tapimo 0.13.0 → 0.14.0

package/src/apps/data/routes/fee-amm.ts

@@ -693,25 +693,24 @@ export async function feeTokenSet(
   const addresses = await Timing.time(c, 'fee_token_set', () =>
     Store.memoize(
       async () => {
-        // Dynamic raw-`logs` query (hence the cast), mirroring the pools
-        // listing's FeeManager `Mint` filter but collapsing to the distinct
-        // user-side tokens — and scoped to the verified candidates via
-        // `topic2 IN (…)` so the result is bounded by the verified list.
-        const topics = candidates.map((address) => `'${padTopic(address as `0x${string}`)}'`)
-        const result = await tidx.fetch({
-          chainId,
-          engine: 'clickhouse',
-          query: `
-            SELECT DISTINCT topic2
-            FROM logs
-            WHERE address = '${feeManager}' AND selector IN ('${mintTopic}', '${legacyMintTopic}')
-              AND topic2 IN (${topics.join(', ')})
-          ` as string,
-        })
         const tokens = new Set<string>([pathUsd])
-        for (const row of result.rows) {
-          const token = unpadTopic(Value.toText(row['topic2']))?.toLowerCase()
-          if (token !== undefined && Schema.Address.safeParse(token).success) tokens.add(token)
+        // PostgreSQL's `topic2` index proves negative lookups without scanning
+        // FeeManager history. Probe serially so an uncapped verified list
+        // cannot fan out indexer load.
+        for (const address of candidates) {
+          const topic = padTopic(address as `0x${string}`)
+          const result = await tidx.fetch({
+            chainId,
+            engine: 'postgres',
+            query: `
+              SELECT 1 AS present
+              FROM logs
+              WHERE address = '${feeManager}' AND selector IN ('${mintTopic}', '${legacyMintTopic}')
+                AND topic2 = '${topic}'
+              LIMIT 1
+            ` as string,
+          })
+          if (result.rows.length > 0) tokens.add(address)
         }
         return Array.from(tokens)
       },

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

@@ -130,6 +130,9 @@ describe('feature gate', () => {
     expect(catalogBody.data.map((eventType) => eventType.type)).not.toContain(
       'funding:deposit.updated',
     )
+    expect(catalogBody.data.map((eventType) => eventType.type)).not.toContain(
+      'funding:transfer.updated',
+    )
     expect(created.status).toBe(400)
   })
 })
@@ -209,6 +212,7 @@ describe('access matrix', () => {
       [
         "block:created",
         "funding:deposit.updated",
+        "funding:transfer.updated",
         "log:emitted",
         "token:transfer",
         "transaction:included",
@@ -261,7 +265,7 @@ describe('CRUD lifecycle', () => {
     expect(body.error?.code).toBe('api_key_forbidden')
   })
 
-  test('captures funding deposit ownership scope without reading the RPC head', async () => {
+  test('captures funding transfer ownership scope without reading the RPC head', async () => {
     const db = TestApp.database()
     const projectWriter = {
       id: 'key_funding_webhook_project',
@@ -275,7 +279,7 @@ describe('CRUD lifecycle', () => {
       {
         json: {
           destination: { type: 'url', url: 'https://example.com/funding' },
-          eventType: 'funding:deposit.updated',
+          eventType: 'funding:transfer.updated',
           filters: { status: 'completed' },
         },
       },
@@ -341,7 +345,7 @@ describe('CRUD lifecycle', () => {
       chainId: 4217,
       destination: { type: 'url', url: 'https://example.com/project-b' },
       environment: 'production',
-      eventType: 'funding:deposit.updated',
+      eventType: 'funding:transfer.updated',
       owner: { orgId: shared.orgId, type: 'api_key' },
       projectId: projectB.projectId,
     })
@@ -1158,8 +1162,12 @@ describe('retry delivery', () => {
       auth: { keys: [writer, reader, other] },
       db,
     })
-    const created = await app.v1.webhooks.$post({ json: validBody }, as(writer))
-    const { id } = await TestApp.json(created, Webhooks.schema.createWebhook.Response)
+    const { id } = await Core.createSubscription(db, {
+      chainId: 4217,
+      destination: validBody.destination,
+      eventType: validBody.eventType,
+      owner: { orgId: writer.orgId, type: 'api_key' },
+    })
     await Core.recordDelivery(db, {
       attempt: 1,
       createdAt: new Date(1_700_000_000_000).toISOString(),
@@ -1316,6 +1324,7 @@ describe('OpenAPI visibility', () => {
         "Log event",
         "Block event",
         "Funding deposit updated event",
+        "Funding transfer updated event",
         "Ping (test delivery)",
       ]
     `)
@@ -1422,6 +1431,13 @@ describe('OpenAPI visibility', () => {
           ],
           "title": "Funding deposit subscription",
         },
+        {
+          "filters": [
+            "id",
+            "status",
+          ],
+          "title": "Funding transfer subscription",
+        },
       ]
     `)
   })

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

@@ -18,6 +18,7 @@ import * as WebhookDestination from '../../../internal/WebhookDestination.js'
 import * as WebhookTransfer from '../../../internal/WebhookTransfer.js'
 import * as Webhooks from '../../../internal/Webhooks.js'
 import * as FundingDeposit from '../../../internal/funding/Deposit.js'
+import * as FundingTransfer from '../../../internal/funding/Transfer.js'
 import * as Transactions from './transactions.js'
 import * as Transfers from './transfers.js'
 
@@ -42,6 +43,7 @@ const redactedSlackUrl = 'https://hooks.slack.com/…'
 export const eventTypes = [
   'block:created',
   'funding:deposit.updated',
+  'funding:transfer.updated',
   'log:emitted',
   'token:transfer',
   'transaction:included',
@@ -50,6 +52,20 @@ export const eventTypes = [
 /** Event types a subscription can listen to. Derived from {@link eventTypes}. */
 export type EventType = (typeof eventTypes)[number]
 
+/** Funding resource events produced by the API instead of chain scans. */
+export const fundingEventTypes = [
+  'funding:deposit.updated',
+  'funding:transfer.updated',
+] as const satisfies readonly EventType[]
+
+/** Event type carrying an owner-scoped funding resource. */
+export type FundingEventType = (typeof fundingEventTypes)[number]
+
+/** Returns whether an event type carries an owner-scoped funding resource. */
+export function isFundingEventType(eventType: EventType): eventType is FundingEventType {
+  return (fundingEventTypes as readonly EventType[]).includes(eventType)
+}
+
 /** Subscribable event types surfaced by `GET /webhooks/event-types`. */
 const eventTypeDescriptions = [
   {
@@ -62,6 +78,11 @@ const eventTypeDescriptions = [
       'A funding deposit materially changed after verified reconciliation, filterable by deposit address, recipient, or status.',
     type: 'funding:deposit.updated',
   },
+  {
+    description:
+      'A funding transfer materially changed, filterable by transfer ID or lifecycle status.',
+    type: 'funding:transfer.updated',
+  },
   {
     description:
       'Any contract event log, filtered by emitting address, event signature/topics, or decoded arguments.',
@@ -465,6 +486,17 @@ export namespace schema {
       z.meta({ title: 'Funding deposit filters' }),
     )
 
+  /** `funding:transfer.updated` subscription filters. All are optional and AND-combined. */
+  export const FundingTransferFilters = z
+    .strictObject({
+      id: z.optional(FundingTransfer.schema.FundingTransfer.shape.id),
+      status: z.optional(FundingTransfer.schema.Status),
+    })
+    .check(
+      z.describe('Filters that narrow which funding transfer changes trigger this webhook.'),
+      z.meta({ title: 'Funding transfer filters' }),
+    )
+
   /**
    * Optional human context describing what a subscription is for. Surfaced by
    * destinations (Slack header + description, Better Stack log fields) and echoed
@@ -917,6 +949,9 @@ export namespace schema {
   /** Public funding deposit after a committed material change. */
   export const FundingDepositEvent = FundingDeposit.schema.FundingDeposit
 
+  /** Public funding transfer after a committed material change. */
+  export const FundingTransferEvent = FundingTransfer.schema.FundingTransfer
+
   /** A `ping` (synthetic test-delivery) payload, sent by `POST /webhooks/:id/ping`. */
   export const PingEvent = z
     .object({
@@ -982,6 +1017,13 @@ export namespace schema {
           type: z.literal('funding:deposit.updated'),
         })
         .check(z.meta({ title: 'Funding deposit updated event' })),
+      z
+        .object({
+          ...envelopeBase,
+          data: FundingTransferEvent,
+          type: z.literal('funding:transfer.updated'),
+        })
+        .check(z.meta({ title: 'Funding transfer updated event' })),
       z
         .object({ ...envelopeBase, data: PingEvent, type: z.literal('ping') })
         .check(z.meta({ title: 'Ping (test delivery)' })),
@@ -1089,6 +1131,20 @@ export namespace schema {
             filters: z.optional(FundingDepositFilters),
           })
           .check(z.meta({ title: 'Funding deposit subscription' })),
+        z
+          .object({
+            chainId: z.optional(Schema.ChainId).check(z.meta({ examples: [4217] })),
+            context: z.optional(Context),
+            destination: Destination,
+            eventType: z
+              .literal('funding:transfer.updated')
+              .check(
+                z.describe('Event type for committed funding transfer changes.'),
+                z.meta({ examples: ['funding:transfer.updated'] }),
+              ),
+            filters: z.optional(FundingTransferFilters),
+          })
+          .check(z.meta({ title: 'Funding transfer subscription' })),
       ])
       .check(z.describe('Details for creating a webhook subscription.'))
 
@@ -1293,7 +1349,7 @@ export function webhooks(options: webhooks.Options = {}) {
   const hidden = !options.enabled
   const availableEventTypes = eventTypeDescriptions.filter(
     (eventType) =>
-      eventType.type !== 'funding:deposit.updated' ||
+      !isFundingEventType(eventType.type) ||
       options.applicationEventTypes?.includes(eventType.type),
   )
   const availableEventTypeSet = new Set(availableEventTypes.map((eventType) => eventType.type))
@@ -1410,7 +1466,7 @@ export function webhooks(options: webhooks.Options = {}) {
               message: 'Webhook event type is not available in this deployment',
               status: 400,
             })
-          if (body.eventType === 'funding:deposit.updated') {
+          if (isFundingEventType(body.eventType)) {
             if (principal?.type !== 'api_key') return unauthorized(c)
             if (
               !principal.apiKey.scopes.some(
@@ -1434,10 +1490,9 @@ export function webhooks(options: webhooks.Options = {}) {
             const maxPerOwner = webhook.maxPerOwner ?? defaultMaxPerOwner
             if ((await Webhooks.countSubscriptions(db, owner)) >= maxPerOwner)
               throw new Webhooks.LimitExceededError(maxPerOwner)
-            const startBlockNumber =
-              body.eventType === 'funding:deposit.updated'
-                ? undefined
-                : await getRpcHead(c.get('getClient')(chainId))
+            const startBlockNumber = isFundingEventType(body.eventType)
+              ? undefined
+              : await getRpcHead(c.get('getClient')(chainId))
             const subscription = await Webhooks.createSubscription(
               db,
               {
@@ -2089,6 +2144,7 @@ export async function getRpcHead(client: Viem.getClient.ReturnType): Promise<num
 const filterSchemas = {
   'block:created': schema.BlockFilters,
   'funding:deposit.updated': schema.FundingDepositFilters,
+  'funding:transfer.updated': schema.FundingTransferFilters,
   'log:emitted': schema.LogFilters,
   'token:transfer': schema.TransferFilters,
   'transaction:included': schema.TxFilters,
@@ -2611,8 +2667,7 @@ function toPublic(subscription: Webhooks.Subscription) {
     ...(subscription.context === undefined ? {} : { context: subscription.context }),
     createdAt: subscription.createdAt,
     destination: redactDestination(subscription.destination),
-    ...(subscription.eventType === 'funding:deposit.updated' &&
-    subscription.environment !== undefined
+    ...(isFundingEventType(subscription.eventType) && subscription.environment !== undefined
       ? { environment: subscription.environment }
       : {}),
     eventType: subscription.eventType,

package/src/apps/funding/App.ts

@@ -3,6 +3,8 @@ import { Hono } from 'hono'
 import type * as App from '../../App.js'
 import type * as FundingDepositAddress from '../../internal/funding/DepositAddress.js'
 import type * as FundingProvider from '../../internal/funding/Provider.js'
+import type * as FundingTransferReconciliation from '../../internal/funding/TransferReconciliation.js'
+import type * as Webhooks from '../../internal/Webhooks.js'
 import * as Metadata from '../metadata.js'
 import { chains } from './routes/chains.js'
 import { depositAddresses } from './routes/deposit-addresses.js'
@@ -24,7 +26,7 @@ export function funding(options: funding.Options = {}) {
     .route('/', chains())
     .route('/', providers())
     .route('/', depositAddresses(options))
-    .route('/', transfers())
+    .route('/', transfers(options))
   return Metadata.defaultChain(Metadata.attach(app, openapi))
 }
 
@@ -32,9 +34,17 @@ export declare namespace funding {
   /** Inbound funding route configuration. */
   type Options = {
     /** Enqueues one deposit address for asynchronous reconciliation. */
-    dispatchReconciliation?:
+    dispatchDepositReconciliation?:
       | ((message: FundingProvider.Webhook.receive.Dispatchable) => Promise<void>)
       | undefined
+    /** Enqueues one registered transfer for destination reconciliation. */
+    dispatchTransferReconciliation?:
+      | ((message: FundingTransferReconciliation.Message) => Promise<void>)
+      | undefined
+    /** Enqueues webhook updates staged with transfer mutations. */
+    dispatchTransferUpdates?:
+      | ((references: readonly Webhooks.QueueReference[]) => Promise<number>)
+      | undefined
     /** Registers a created address with a source-chain observer. */
     registerDepositAddress?: ((address: FundingDepositAddress.Public) => Promise<void>) | undefined
   }

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

@@ -1497,7 +1497,7 @@ describe('POST /funding/deposit-addresses/:id/reconcile', () => {
     const dispatched: FundingProvider.Webhook.receive.Dispatchable[] = []
     const app = transfersApp({
       funding: {
-        dispatchReconciliation: async (message) => {
+        dispatchDepositReconciliation: async (message) => {
           dispatched.push(message)
         },
       },
@@ -1546,7 +1546,7 @@ describe('POST /funding/deposit-addresses/:id/reconcile', () => {
     const dispatched: FundingProvider.Webhook.receive.Dispatchable[] = []
     const app = transfersApp({
       funding: {
-        dispatchReconciliation: async (message) => {
+        dispatchDepositReconciliation: async (message) => {
           dispatched.push(message)
         },
       },
@@ -1574,7 +1574,7 @@ describe('POST /funding/deposit-addresses/:id/reconcile', () => {
     const dispatched: FundingProvider.Webhook.receive.Dispatchable[] = []
     const configured = transfersApp({
       funding: {
-        dispatchReconciliation: async (message) => {
+        dispatchDepositReconciliation: async (message) => {
           dispatched.push(message)
         },
       },
@@ -1611,7 +1611,7 @@ describe('POST /funding/deposit-addresses/:id/reconcile', () => {
   test('returns an upstream error when the queue rejects the message', async () => {
     const app = transfersApp({
       funding: {
-        dispatchReconciliation: async () => {
+        dispatchDepositReconciliation: async () => {
           throw new Error('queue unavailable')
         },
       },

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

@@ -981,7 +981,7 @@ export function depositAddresses(options: depositAddresses.Options = {}) {
               message: 'Funding deposit address is not active',
               status: 409,
             })
-          const dispatch = options.dispatchReconciliation
+          const dispatch = options.dispatchDepositReconciliation
           if (!dispatch)
             return Response.error(c, {
               code: 'not_implemented',
@@ -1164,7 +1164,7 @@ export declare namespace depositAddresses {
   /** Deposit-address route dependencies. */
   type Options = {
     /** Enqueues one deposit address for asynchronous reconciliation. */
-    dispatchReconciliation?:
+    dispatchDepositReconciliation?:
       | ((message: FundingProvider.Webhook.receive.Dispatchable) => Promise<void>)
       | undefined
     /** Registers a created address with a source-chain observer. */