tapimo 0.9.0 → 0.10.0

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

@@ -176,7 +176,12 @@ export function zones() {
       name: 'tempo-api:zone-withdrawals:v1',
       key: (c) => {
         const principal = Auth.getPrincipal(c)
-        return `${principal?.type ?? 'unknown'}:${principal?.id ?? 'unknown'}:${Cache.urlKey(c, schema.listZoneWithdrawals.Query)}`
+        const url = new URL(Cache.urlKey(c, schema.listZoneWithdrawals.Query))
+        url.searchParams.set(
+          'principal',
+          `${principal?.type ?? 'unknown'}:${principal?.id ?? 'unknown'}`,
+        )
+        return url.toString()
       },
     }),
     async (c) => {

package/src/apps/funding/routes/quotes.test.ts

@@ -271,7 +271,7 @@ describe('GET /funding/quotes', () => {
       const response_promise = app.request(quoteUrl({ ...baseUsdcQuery, provider: 'across' }), {
         headers: TestApp.auth.headers,
       })
-      await vi.advanceTimersByTimeAsync(2_000)
+      await vi.advanceTimersByTimeAsync(5_000)
       const response = await response_promise
 
       expect(response.status).toBe(502)

package/src/apps/mpp/Mpp.test.ts

@@ -91,6 +91,17 @@ describe('MPP relay', () => {
     expect(await response.json()).toEqual({ success: true })
   })
 
+  test('verifies a zero-amount proof credential', async () => {
+    const app = TestApp.create({ auth: { keys: [key] } })
+    const input = await credential({ amount: '0' })
+    const response = await post(app, '/v1/mpp/validate', input)
+
+    expect(payloadType(input)).toBe('proof')
+    expect(input.source).toBeDefined()
+    expect(response.status).toBe(200)
+    expect(await response.json()).toEqual({ success: true })
+  })
+
   test('validates and finalizes a pushed credential without a second submission', async () => {
     const app = TestApp.create({ auth: { keys: [key] } })
     const input = await credential({ mode: 'push', supportedModes: ['push'] })
@@ -619,7 +630,7 @@ type CredentialPayload = { hash?: string; type?: unknown }
 
 async function credential(options: credential.Options = {}): Promise<Mpp.RelayInput> {
   const issuer = createIssuer(options)
-  const challenge = await issuer.challenge.tempo.charge({ amount: '1' })
+  const challenge = await issuer.challenge.tempo.charge({ amount: options.amount ?? '1' })
   const authorization = await createClient(options).createCredential(
     new Response(null, {
       headers: { 'www-authenticate': Mppx.Challenge.serialize(challenge) },
@@ -631,6 +642,7 @@ async function credential(options: credential.Options = {}): Promise<Mpp.RelayIn
 
 declare namespace credential {
   type Options = {
+    amount?: string | undefined
     feePayer?: boolean | undefined
     mode?: 'pull' | 'push' | undefined
     supportedModes?: ('pull' | 'push')[] | undefined

package/src/apps/mpp/Mpp.ts

@@ -67,6 +67,8 @@ export type RelayInput = {
   challenge: Challenge
   /** Method-specific MPP credential payload. */
   payload: unknown
+  /** Optional payer identifier supplied with the credential. */
+  source?: string | undefined
 }
 
 /** Broadcast MPP payment receipt. */
@@ -200,6 +202,12 @@ export namespace schema {
           z.describe('The method-specific MPP credential payload.'),
           z.meta({ examples: [{ signature: `0x${'aa'.repeat(65)}`, type: 'transaction' }] }),
         ),
+      source: z
+        .optional(z.string())
+        .check(
+          z.describe('An optional payer identifier supplied with the credential.'),
+          z.meta({ examples: ['did:pkh:eip155:4217:0x1234567890abcdef1234567890abcdef12345678'] }),
+        ),
     }),
     'An MPP payment credential and its challenge.',
   )

package/src/apps/mpp/internal/Adapter.ts

@@ -49,7 +49,7 @@ export function create(options: create.Options): Adapter {
   /** Validates and screens a credential, rejecting when either check fails. */
   async function validateOrThrow(input: Mpp.RelayInput) {
     const result = await time('mpp_validate', () =>
-      Mppx.Method.validateCredential(methods, Mppx.Credential.from(input)),
+      Mppx.Method.validateCredential(methods, credential(input)),
     )
     await time('mpp_screen', () => screenManager.screen(Utils.addresses(result)))
   }
@@ -65,7 +65,7 @@ export function create(options: create.Options): Adapter {
       try {
         await validateOrThrow(input)
         const result = await time('mpp_broadcast', () =>
-          Mppx.Method.broadcastCredential(methods, Mppx.Credential.from(input)),
+          Mppx.Method.broadcastCredential(methods, credential(input)),
         )
         return {
           receipt: {
@@ -91,6 +91,14 @@ export function create(options: create.Options): Adapter {
   }
 }
 
+function credential(input: Mpp.RelayInput) {
+  return Mppx.Credential.from({
+    challenge: input.challenge,
+    payload: input.payload,
+    ...(input.source === undefined ? {} : { source: input.source }),
+  })
+}
+
 export declare namespace create {
   /** Dependencies used to validate and broadcast Tempo credentials. */
   type Options = {

package/src/db/Db.test.ts

@@ -5,6 +5,7 @@ import * as Runtime from '../../test/runtime.js'
 import * as Db from './Db.js'
 import * as Invitations from './tables/invitations.js'
 import * as Organizations from './tables/organizations.js'
+import * as WebhookSubscriptions from './tables/webhookSubscriptions.js'
 
 const create = () => Db.postgres({ connectionString: Runtime.postgresUrl, schema: `t_${nanoid()}` })
 
@@ -39,14 +40,47 @@ describe('postgres', () => {
     await db.close()
   })
 
-  test('behavior: concurrent migrate tolerates the ledger race', async () => {
+  test('behavior: defers schema creation until migration', async () => {
     const schema = `t_${nanoid()}`
-    // Pre-create the schema so concurrent migrate races only on the
-    // `migrations` ledger, not `CREATE SCHEMA`.
-    const seed = Db.postgres({ connectionString: Runtime.postgresUrl, schema })
-    await Organizations.get(seed, 'x').catch(() => {})
-    await seed.close()
+    const db = Db.postgres({ connectionString: Runtime.postgresUrl, schema })
+    const exists = async () =>
+      (
+        await sql<{
+          exists: boolean
+        }>`SELECT EXISTS (SELECT 1 FROM pg_namespace WHERE nspname = ${schema}) AS exists`.execute(
+          db.kysely,
+        )
+      ).rows[0]!.exists
+
+    await sql`SELECT 1`.execute(db.kysely)
+    expect(await exists()).toBe(false)
+    await db.migrate()
+    expect(await exists()).toBe(true)
+    await db.close()
+  })
+
+  test('behavior: qualifies repository queries with the configured schema', async () => {
+    const db = Db.postgres({
+      connectionString: Runtime.postgresUrl,
+      schema: `t_MixedCase_${nanoid()}`,
+    })
+    await sql`SET search_path TO public`.execute(db.kysely)
+    await db.migrate()
+    await sql`SET search_path TO public`.execute(db.kysely)
+    await db.transaction(async (tx) => {
+      await Organizations.create(tx, { id: 'org_qualified', name: 'Qualified' })
+    })
+    expect((await Organizations.get(db, 'org_qualified'))?.name).toBe('Qualified')
+    expect(
+      await WebhookSubscriptions.compareAndSetCursors(db, {
+        cursors: [{ cursor: 'next', expectedCursor: null, subscriptionId: 'wh_missing' }],
+      }),
+    ).toEqual(new Set())
+    await db.close()
+  })
 
+  test('behavior: concurrent migrate tolerates the ledger race', async () => {
+    const schema = `t_${nanoid()}`
     // Several runners migrate the same fresh schema at once (mirrors parallel
     // deploys). The session advisory lock serializes them; none throw.
     const dbs = Array.from({ length: 5 }, () =>

package/src/db/Db.ts

@@ -7,6 +7,7 @@ import {
   PostgresDialect,
   type RawBuilder,
   sql,
+  WithSchemaPlugin,
 } from 'kysely'
 import * as pg from 'pg'
 
@@ -1301,6 +1302,15 @@ function raw(db: Kysely<Database>, statement: RawBuilder<unknown>) {
  * @returns The database.
  */
 export function from(dialect: Dialect): Db {
+  return fromDialect(dialect)
+}
+
+/** Builds a database with internal dialect-specific options. */
+function fromDialect(dialect: Dialect, options: fromDialect.Options = {}): Db {
+  const root = new Kysely<Database>({ dialect, plugins: [new CamelCasePlugin()] })
+  // Qualify repository queries instead of relying on session search_path;
+  // transaction poolers reset session state between statements.
+  const kysely = options.schema ? root.withPlugin(new WithSchemaPlugin(options.schema)) : root
   // Builds Db over a top-level Kysely handle or transaction-scoped Kysely handle.
   function build(kysely: Kysely<Database>): Db {
     // Prevents same-handle nested transactions from deadlocking capped pools.
@@ -1314,9 +1324,19 @@ export function from(dialect: Dialect): Db {
       async migrate() {
         // A session advisory lock serializes the full run, including bootstrap
         // DDL and ledger inserts. Pin one connection and unlock in `finally`.
-        await kysely.connection().execute(async (db) => {
+        await root.connection().execute(async (db) => {
           await sql`SELECT pg_advisory_lock(${migrateLockKey})`.execute(db)
           try {
+            if (options.schema) {
+              await db.executeQuery(
+                CompiledQuery.raw(
+                  `CREATE SCHEMA IF NOT EXISTS ${pg.escapeIdentifier(options.schema)}`,
+                ),
+              )
+              await sql`SELECT set_config('search_path', quote_ident(${options.schema}), false)`.execute(
+                db,
+              )
+            }
             await sql`CREATE TABLE IF NOT EXISTS migrations (name TEXT PRIMARY KEY, checksum TEXT NOT NULL, applied_at TEXT NOT NULL)`.execute(
               db,
             )
@@ -1378,12 +1398,20 @@ export function from(dialect: Dialect): Db {
       },
     }
   }
-  return build(new Kysely<Database>({ dialect, plugins: [new CamelCasePlugin()] }))
+  return build(kysely)
+}
+
+declare namespace fromDialect {
+  /** Internal database construction options. */
+  type Options = {
+    /** Schema that Kysely qualifies on every repository query. */
+    schema?: string | undefined
+  }
 }
 
 /**
  * Creates a Postgres-backed {@link Db} via Kysely's `PostgresDialect`. Optional
- * `schema` scopes every pooled connection and caps the pool for test isolation.
+ * `schema` qualifies repository queries, scopes migrations, and caps the pool.
  *
  * @param options - Postgres options.
  * @returns The database.
@@ -1391,21 +1419,7 @@ export function from(dialect: Dialect): Db {
 export function postgres(options: postgres.Options): Db {
   const { connectionString, schema } = options
   const pool = new pg.Pool(schema ? { connectionString, max: 1 } : { connectionString })
-  return from(
-    new PostgresDialect({
-      pool,
-      ...(schema
-        ? {
-            onCreateConnection: async (connection) => {
-              await connection.executeQuery(
-                CompiledQuery.raw(`CREATE SCHEMA IF NOT EXISTS "${schema}"`),
-              )
-              await connection.executeQuery(CompiledQuery.raw(`SET search_path TO "${schema}"`))
-            },
-          }
-        : {}),
-    }),
-  )
+  return fromDialect(new PostgresDialect({ pool }), { schema })
 }
 
 export declare namespace postgres {
@@ -1413,7 +1427,7 @@ export declare namespace postgres {
   type Options = {
     /** Postgres connection string (`postgresql://…`). */
     connectionString: string
-    /** Schema to create and scope the session to (isolates concurrent tests). */
+    /** Schema to qualify and create during migration (isolates concurrent tests). */
     schema?: string | undefined
   }
 }

package/src/db/tables/sponsoredTransactions.ts

@@ -1,4 +1,4 @@
-import type { ExpressionBuilder, Selectable, SqlBool } from 'kysely'
+import type { ExpressionBuilder, Selectable } from 'kysely'
 import { sql } from 'kysely'
 
 import * as Id from '../../internal/Id.js'
@@ -222,7 +222,14 @@ export async function assignTransactionHash(
         .where('status', '=', record.status)
         .where('transactionHash', 'is', null)
       if (record.status === 'failed')
-        query = query.where(sql<SqlBool>`exists (select 1 from organizations where organizations.id = sponsored_transactions.org_id)`) // prettier-ignore
+        query = query.where((eb) =>
+          eb.exists(
+            eb
+              .selectFrom('organizations')
+              .select('organizations.id')
+              .whereRef('organizations.id', '=', 'sponsored_transactions.orgId'),
+          ),
+        )
       const updated = await query.executeTakeFirst()
       if (updated.numUpdatedRows === 0n) return
       if (record.status === 'failed' && record.billable && limit) {

package/src/db/tables/webhookSubscriptions.ts

@@ -273,20 +273,21 @@ export async function remove(
 
 /**
  * Lists live `active` subscriptions for a `(chainId, eventType)` stream — the
- * poller's per-stream lookup, served by the partial status index.
+ * poller's per-stream lookup, served by the partial status index. Each row
+ * carries its poller cursor so the poller avoids a per-subscription read.
  *
  * @param db - The database.
  * @param chainId - Chain the stream belongs to.
  * @param eventType - Event type of the stream.
  * @param now - ISO timestamp expiry is evaluated against.
- * @returns The subscriptions, in id (chronological) order.
+ * @returns Cursor-and-subscription pairs, in id (chronological) order.
  */
 export async function listActive(
   db: Db.Db,
   chainId: number,
   eventType: Webhooks.EventType,
   now: string,
-): Promise<Webhooks.Subscription[]> {
+): Promise<{ cursor: string | null; subscription: Webhooks.Subscription }[]> {
   const rows = await db.kysely
     .selectFrom('webhook_subscriptions')
     .selectAll()
@@ -296,7 +297,69 @@ export async function listActive(
     .where(live(now))
     .orderBy('id')
     .execute()
-  return rows.map(toSubscription)
+  return rows.map((row) => ({ cursor: row.pollerCursor, subscription: toSubscription(row) }))
+}
+
+/**
+ * Lists every live `active` subscription on a chain in one read. The poller
+ * groups the rows by event type so empty streams cost no extra database reads.
+ *
+ * @param db - The database.
+ * @param options - Chain, configured event types, and expiry time.
+ * @returns Cursor-and-subscription pairs ordered by event type, then id.
+ */
+export async function listActiveForChain(
+  db: Db.Db,
+  options: listActiveForChain.Options,
+): Promise<{ cursor: string | null; subscription: Webhooks.Subscription }[]> {
+  if (options.eventTypes.length === 0) return []
+  const rows = await db.kysely
+    .selectFrom('webhook_subscriptions')
+    .selectAll()
+    .where('chainId', '=', options.chainId)
+    .where('eventType', 'in', options.eventTypes)
+    .where('status', '=', 'active')
+    .where(live(options.now))
+    .orderBy('eventType')
+    .orderBy('id')
+    .execute()
+  return rows.map((row) => ({ cursor: row.pollerCursor, subscription: toSubscription(row) }))
+}
+
+export declare namespace listActiveForChain {
+  /** Filters for the poller's chain-level subscription read. */
+  type Options = {
+    /** Chain whose subscriptions to read. */
+    chainId: number
+    /** Event types configured for this poller tick. */
+    eventTypes: readonly Webhooks.EventType[]
+    /** ISO timestamp expiry is evaluated against. */
+    now: string
+  }
+}
+
+/**
+ * Reads the poller cursors of every live `active` subscription on a chain,
+ * across event types. Feeds the cron's cursor-freshness fallback gate.
+ *
+ * @param db - The database.
+ * @param chainId - Chain whose cursors to read.
+ * @param now - ISO timestamp expiry is evaluated against.
+ * @returns The non-null cursors, unordered.
+ */
+export async function listActiveCursors(
+  db: Db.Db,
+  chainId: number,
+  now: string,
+): Promise<string[]> {
+  const rows = await db.kysely
+    .selectFrom('webhook_subscriptions')
+    .select('pollerCursor')
+    .where('chainId', '=', chainId)
+    .where('status', '=', 'active')
+    .where(live(now))
+    .execute()
+  return rows.flatMap((row) => (row.pollerCursor === null ? [] : [row.pollerCursor]))
 }
 
 /**
@@ -367,6 +430,55 @@ export declare namespace compareAndSetCursor {
   }
 }
 
+/**
+ * Writes multiple poller cursors when each stored value still matches the
+ * caller's observed value.
+ *
+ * @param db - The database.
+ * @param options - Candidate cursor writes.
+ * @returns Subscription ids whose cursors were updated.
+ */
+export async function compareAndSetCursors(
+  db: Db.Db,
+  options: compareAndSetCursors.Options,
+): Promise<Set<string>> {
+  if (options.cursors.length === 0) return new Set()
+  const values = JSON.stringify(options.cursors)
+  type Candidate = {
+    cursor: string
+    expectedCursor: string | null
+    subscriptionId: string
+  }
+  const result = await db.kysely
+    .with(
+      'candidates',
+      () => sql<Candidate>`(
+      SELECT
+        candidate."subscriptionId" AS subscription_id,
+        candidate."expectedCursor" AS expected_cursor,
+        candidate.cursor
+      FROM jsonb_to_recordset(${values}::jsonb)
+        AS candidate("subscriptionId" text, "expectedCursor" text, cursor text)
+    )`,
+    )
+    .updateTable('webhook_subscriptions as subscription')
+    .from('candidates as candidate')
+    .set((eb) => ({ pollerCursor: eb.ref('candidate.cursor') }))
+    .whereRef('subscription.id', '=', 'candidate.subscriptionId')
+    .whereRef('subscription.pollerCursor', 'is not distinct from', 'candidate.expectedCursor')
+    .returning('subscription.id as subscriptionId')
+    .execute()
+  return new Set(result.map((row) => row.subscriptionId))
+}
+
+export declare namespace compareAndSetCursors {
+  /** Options for {@link compareAndSetCursors}. */
+  type Options = {
+    /** Candidate cursor writes. */
+    cursors: readonly compareAndSetCursor.Options[]
+  }
+}
+
 /**
  * Records a successful delivery: resets the consecutive-failure counter and
  * stamps `lastDeliveryAt`.

package/src/internal/EarnVaults.test.ts

@@ -76,7 +76,7 @@ describe('resolve', () => {
       const getClient = Viem.createGetClient({
         defaultChainId: tempoTestnet.id,
         rpc: TestViem.rpc,
-        zones: [Zones.zoneE],
+        zones: [Zones.zoneModerato],
       })
       const { instantLiquidity, sharePrice, state, ...discovery } = await EarnVaults.resolve({
         getClient,
@@ -84,7 +84,7 @@ describe('resolve', () => {
           chainId: tempoTestnet.id,
           vaultAddress,
         },
-        zones: [Zones.zoneE],
+        zones: [Zones.zoneModerato],
       })
       expect({
         depositsPaused: state.depositsPaused,