tapimo 0.7.0 → 0.7.1

package/src/db/tables/sponsoredTransactions.test.ts

@@ -2,6 +2,7 @@ import { nanoid } from 'nanoid'
 
 import * as Runtime from '../../../test/runtime.js'
 import * as Db from '../Db.js'
+import * as Organizations from './organizations.js'
 import * as SponsoredTransactions from './sponsoredTransactions.js'
 
 const create = () => Db.postgres({ connectionString: Runtime.postgresUrl, schema: `t_${nanoid()}` })
@@ -160,7 +161,8 @@ describe('listPending', () => {
 
     const pending = await SponsoredTransactions.listPending(db)
     // Inserts can share a millisecond, so assert membership, not order.
-    expect(pending.map((row) => row.transactionHash).sort()).toMatchInlineSnapshot(`
+    expect(pending.map((row) => row.transactionHash).sort((left, right) => String(left).localeCompare(String(right)))) // prettier-ignore
+      .toMatchInlineSnapshot(`
       [
         "0xa1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1",
         "0xa3a3a3a3a3a3a3a3a3a3a3a3a3a3a3a3a3a3a3a3a3a3a3a3a3a3a3a3a3a3a3a3",
@@ -175,9 +177,10 @@ describe('assignTransactionHash', () => {
   test('behavior: reopens a failed intent when reconciliation finds its hash', async () => {
     const db = create()
     await db.migrate()
+    await Organizations.create(db, { id: 'org_1', name: 'One' })
     const { transactionHash: _, ...intent } = input
     const record = await SponsoredTransactions.upsert(db, intent)
-    await SponsoredTransactions.fail(db, record.id, '2026-01-01T00:00:00.000Z')
+    await SponsoredTransactions.fail(db, record.id, new Date().toISOString())
 
     await SponsoredTransactions.assignTransactionHash(db, record.id, input.transactionHash)
 
@@ -190,9 +193,45 @@ describe('assignTransactionHash', () => {
     await db.close()
   })
 
+  test('behavior: does not reopen failed intents after the recovery window', async () => {
+    const db = create()
+    await db.migrate()
+    await Organizations.create(db, { id: 'org_1', name: 'One' })
+    const { transactionHash: _, ...intent } = input
+    const record = await SponsoredTransactions.upsert(db, intent)
+    await SponsoredTransactions.fail(
+      db,
+      record.id,
+      new Date(Date.now() - SponsoredTransactions.failedIntentRecoveryTtlMs - 1).toISOString(),
+    )
+
+    await SponsoredTransactions.assignTransactionHash(db, record.id, input.transactionHash)
+
+    const assigned = await SponsoredTransactions.get(db, record.id)
+    expect(assigned?.status).toMatchInlineSnapshot(`"failed"`)
+    expect(assigned?.transactionHash).toBeNull()
+    await db.close()
+  })
+
+  test('behavior: does not reopen failed intents for deleted orgs', async () => {
+    const db = create()
+    await db.migrate()
+    const { transactionHash: _, ...intent } = input
+    const record = await SponsoredTransactions.upsert(db, intent)
+    await SponsoredTransactions.fail(db, record.id, new Date().toISOString())
+
+    await SponsoredTransactions.assignTransactionHash(db, record.id, input.transactionHash)
+
+    const assigned = await SponsoredTransactions.get(db, record.id)
+    expect(assigned?.status).toMatchInlineSnapshot(`"failed"`)
+    expect(assigned?.transactionHash).toBeNull()
+    await db.close()
+  })
+
   test('behavior: keeps an over-limit failed intent retryable across a period rollover', async () => {
     const db = create()
     await db.migrate()
+    await Organizations.create(db, { id: 'org_1', name: 'One' })
     const { transactionHash: _, ...intent } = input
     vi.useFakeTimers({ now: new Date('2026-01-31T23:59:00.000Z') })
     try {

package/src/db/tables/sponsoredTransactions.ts

@@ -1,4 +1,4 @@
-import type { ExpressionBuilder, Selectable } from 'kysely'
+import type { ExpressionBuilder, Selectable, SqlBool } from 'kysely'
 import { sql } from 'kysely'
 
 import * as Id from '../../internal/Id.js'
@@ -11,6 +11,9 @@ export type Table = db_Schema.SponsoredTransaction
 /** A stored sponsored-transaction row. */
 export type Record = Selectable<Table>
 
+/** How long failed fill intents remain eligible for on-chain reconciliation. */
+export const failedIntentRecoveryTtlMs = 86_400_000
+
 /**
  * Records one sponsorship commitment as `pending`, keyed by its fee-payer
  * sign payload. Written after fee-payer signing and before any broadcast, so
@@ -199,9 +202,15 @@ export async function assignTransactionHash(
         !['failed', 'pending'].includes(record.status)
       )
         return
+      const failedSince = new Date(Date.now() - failedIntentRecoveryTtlMs).toISOString()
+      if (
+        record.status === 'failed' &&
+        (record.finalizedAt === null || record.finalizedAt < failedSince)
+      )
+        return
       if (record.status === 'failed' && record.billable && limit)
         await sql`select pg_advisory_xact_lock(${billingLockClass}, hashtext(${record.orgId}))`.execute(tx.kysely) // prettier-ignore
-      await tx.kysely
+      let query = tx.kysely
         .updateTable('sponsored_transactions')
         .set({
           ...(record.status === 'failed' ? { createdAt: new Date().toISOString() } : {}),
@@ -212,7 +221,10 @@ export async function assignTransactionHash(
         .where('id', '=', id)
         .where('status', '=', record.status)
         .where('transactionHash', 'is', null)
-        .execute()
+      if (record.status === 'failed')
+        query = query.where(sql<SqlBool>`exists (select 1 from organizations where organizations.id = sponsored_transactions.org_id)`) // prettier-ignore
+      const updated = await query.executeTakeFirst()
+      if (updated.numUpdatedRows === 0n) return
       if (record.status === 'failed' && record.billable && limit) {
         const committed = await spend(tx, {
           chainIds: limit.chainIds,

package/src/internal/EdgeCache.test.ts

@@ -219,7 +219,7 @@ describe('middleware', () => {
 
   test('rechecks route eligibility before every cache lookup', async () => {
     let eligible = true
-    const { app, downstreamCalls, store } = createApp({ eligibility: () => eligible })
+    const { app, downstreamCalls, store } = createApp({ eligibility: [() => eligible] })
 
     await app.request('/cached')
     eligible = false
@@ -229,6 +229,19 @@ describe('middleware', () => {
     expect(store.gets).toBe(1)
     expect(store.size).toBe(1)
   })
+
+  test('requires every route eligibility predicate to permit caching', async () => {
+    const { app, downstreamCalls, store } = createApp({
+      eligibility: [() => true, () => false],
+    })
+
+    await app.request('/cached')
+    await app.request('/cached')
+
+    expect(downstreamCalls()).toBe(2)
+    expect(store.gets).toBe(0)
+    expect(store.size).toBe(0)
+  })
 })
 
 type Environment = { Variables: EdgeCache.Variables }
@@ -263,7 +276,7 @@ function memoryStore() {
 
 function createApp(
   options: {
-    eligibility?: ((c: Context<Environment>) => boolean) | undefined
+    eligibility?: readonly ((c: Context<Environment>) => boolean)[] | undefined
     store?: Store.Store | undefined
   } = {},
 ) {
@@ -282,9 +295,9 @@ function createApp(
   const cacheable_marked = EdgeCache.markCacheable(
     createMiddleware<Environment>(async (_c, next) => next()),
   )
-  const cacheable = options.eligibility
-    ? EdgeCache.setEligibility(cacheable_marked, options.eligibility)
-    : cacheable_marked
+  for (const predicate of options.eligibility ?? [])
+    EdgeCache.setEligibility(cacheable_marked, predicate)
+  const cacheable = cacheable_marked
   app.get('/cached', cacheable, (c) => {
     c.set('edgeCache', { maxAge: 30, staleWhileRevalidate: 300 })
     c.header('Age', '123')

package/src/internal/EdgeCache.ts

@@ -154,12 +154,14 @@ export function markCacheable<const handler extends (...args: never[]) => unknow
   return Object.assign(handler, { [cacheableSymbol]: true })
 }
 
-/** Adds a request eligibility check to a cacheable route handler. */
+/** Adds a request eligibility check; every check must permit caching. */
 export function setEligibility<const handler extends (...args: never[]) => unknown>(
   handler: handler,
   predicate: (c: Context) => boolean,
 ): handler {
-  if (cacheableSymbol in handler) eligibility.set(handler, predicate)
+  const existing = eligibility.get(handler)
+  if (cacheableSymbol in handler)
+    eligibility.set(handler, existing ? (c) => existing(c) && predicate(c) : predicate)
   return handler
 }
 

package/src/internal/Schema.test.ts

@@ -32,3 +32,16 @@ describe('ChainIdQuery', () => {
     expect(Schema.ChainIdQuery.parse('42431')).toMatchInlineSnapshot(`42431`)
   })
 })
+
+describe('timestampBound', () => {
+  test('normalizes RFC 3339 offsets to UTC', () => {
+    const bound = Schema.timestampBound('swaps', 'from')
+
+    expect(bound.parse('2026-06-04T12:00:00+05:30')).toMatchInlineSnapshot(
+      `"2026-06-04T06:30:00.000Z"`,
+    )
+    expect(bound.parse('2026-06-04T12:00:00-05:00')).toMatchInlineSnapshot(
+      `"2026-06-04T17:00:00.000Z"`,
+    )
+  })
+})

package/src/internal/Schema.ts

@@ -495,16 +495,23 @@ export function blockNumberBound(noun: string, bound: 'from' | 'to') {
 
 /**
  * Optional inclusive ISO-8601 timestamp bound query parameter (`timestamp.from`
- * / `timestamp.to`). `noun` is the resource being listed (e.g. `transfers`).
+ * / `timestamp.to`), normalized to UTC. `noun` is the listed resource.
  */
 export function timestampBound(noun: string, bound: 'from' | 'to') {
   const direction = bound === 'from' ? 'at or after' : 'at or before'
-  return z.optional(z.iso.datetime({ offset: true })).check(
-    z.describe(`Only include ${noun} ${direction} this ISO 8601 timestamp.`),
-    z.meta({
-      examples: [bound === 'from' ? '2024-01-01T00:00:00Z' : '2024-12-31T23:59:59Z'],
-    }),
-  )
+  return z
+    .optional(
+      z.pipe(
+        z.iso.datetime({ offset: true }),
+        z.transform((value) => new Date(value).toISOString()),
+      ),
+    )
+    .check(
+      z.describe(`Only include ${noun} ${direction} this ISO 8601 timestamp.`),
+      z.meta({
+        examples: [bound === 'from' ? '2024-01-01T00:00:00Z' : '2024-12-31T23:59:59Z'],
+      }),
+    )
 }
 
 /**