tapimo 0.8.0 → 0.10.0

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'
 
@@ -1271,6 +1272,15 @@ export const migrations: readonly Migration[] = [
         sql`ALTER TABLE funding_deposits DROP CONSTRAINT IF EXISTS funding_deposits_detection_trigger_check, ADD CONSTRAINT funding_deposits_detection_trigger_check CHECK (detection_trigger IN ('chain', 'manual', 'poll', 'webhook'))`,
       ),
   },
+  {
+    name: '0114_funding_deposit_addresses_owner_address_index',
+    up: (db) =>
+      db.schema
+        .createIndex('funding_deposit_addresses_owner_address_idx')
+        .ifNotExists()
+        .on('fundingDepositAddresses')
+        .columns(['orgId', 'environment', 'address', 'projectId']),
+  },
 ]
 
 /**
@@ -1292,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.
@@ -1305,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,
             )
@@ -1369,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.
@@ -1382,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 {
@@ -1404,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/fundingDeposits.test.ts

@@ -77,6 +77,107 @@ describe('listByAddress', () => {
   })
 })
 
+describe('listByDepositAddress', () => {
+  const seedAddressDeposit = (address: Awaited<ReturnType<typeof seedAddress>>, index: number) => {
+    const sourceTransactionHash = `fe${index.toString(16).padStart(62, '0')}`
+    return Deposit.create(db, {
+      now: new Date(Date.UTC(2026, 1, 2, 0, 0, index)),
+      providerRequestId: `relay_deposit_address_request_${index}`,
+      snapshot: TestFunding.depositSnapshot(address.id, {
+        provider: address.snapshot.provider,
+        sourceTransactionHashes: [sourceTransactionHash],
+      }),
+      sourceTransactionHash,
+      sourceTransferIndex: 0,
+    })
+  }
+
+  test('pages one reusable address across provider records newest-first', async () => {
+    const depositAddress = 'TQn9Y2khEsLJW1ChVWFMSMeRDow5KcbLSE'
+    const firstAddress = await seedAddress({
+      snapshot: TestFunding.depositAddressSnapshot({
+        address: depositAddress,
+        provider: { id: 'relay_deposit_address_first', name: 'Relay' },
+      }),
+    })
+    const secondAddress = await seedAddress({
+      snapshot: TestFunding.depositAddressSnapshot({
+        address: depositAddress,
+        provider: { id: 'relay_deposit_address_second', name: 'Relay' },
+        subsidize: true,
+      }),
+    })
+    const first = await seedAddressDeposit(firstAddress, 1)
+    const second = await seedAddressDeposit(secondAddress, 2)
+    const third = await seedAddressDeposit(firstAddress, 3)
+    const unrelatedAddress = await seedAddress({
+      snapshot: TestFunding.depositAddressSnapshot({
+        address: 'TF17BgPaZYbz8oxbjhriubPDsA7ArKoLX3',
+        provider: { id: 'relay_deposit_address_unrelated', name: 'Relay' },
+        recipient: `0x${'fe'.repeat(20)}`,
+      }),
+    })
+    await seedAddressDeposit(unrelatedAddress, 4)
+
+    const page = await FundingDeposits.listByDepositAddress(db, {
+      depositAddress,
+      limit: 2,
+      owner,
+    })
+    expect(page.map((row) => row.id)).toEqual([third.id, second.id])
+    const rest = await FundingDeposits.listByDepositAddress(db, {
+      cursor: { createdAt: second.createdAt, id: second.id },
+      depositAddress,
+      limit: 2,
+      owner,
+    })
+    expect(rest.map((row) => row.id)).toEqual([first.id])
+  })
+
+  test('narrows project-attributed owners to their project', async () => {
+    const depositAddress = 'TWd4WrZ9wn84f5x1hZhL4DHvk738ns5jwb'
+    const address = await seedAddress({
+      projectId: 'prj_deposit',
+      snapshot: TestFunding.depositAddressSnapshot({
+        address: depositAddress,
+        provider: { id: 'relay_deposit_address_project', name: 'Relay' },
+      }),
+    })
+    await seedAddressDeposit(address, 5)
+
+    expect(
+      await FundingDeposits.listByDepositAddress(db, {
+        depositAddress,
+        limit: 10,
+        owner: { ...owner, projectId: 'prj_other' },
+      }),
+    ).toEqual([])
+  })
+
+  test('normalizes EVM address casing', async () => {
+    const depositAddress = `0x${'Ab'.repeat(20)}`
+    const source = TestFunding.transferSnapshot()
+    const address = await seedAddress({
+      snapshot: TestFunding.depositAddressSnapshot({
+        address: depositAddress,
+        provider: { id: 'relay_deposit_address_evm', name: 'Relay' },
+        recipient: `0x${'fd'.repeat(20)}`,
+        refundAddress: depositAddress,
+        sourceChain: source.sourceChain,
+        sourceToken: source.sourceToken,
+      }),
+    })
+    const record = await seedAddressDeposit(address, 6)
+
+    const rows = await FundingDeposits.listByDepositAddress(db, {
+      depositAddress,
+      limit: 10,
+      owner,
+    })
+    expect(rows.map((row) => row.id)).toEqual([record.id])
+  })
+})
+
 describe('listByRecipient', () => {
   test('pages recipient deposits across addresses and hides foreign ownership', async () => {
     const recipient = '0xABcdEFABcdEFabcdEfAbCdefabcdeFABcDEFabCD'

package/src/db/tables/fundingDeposits.ts

@@ -187,7 +187,20 @@ export declare namespace listBySourceTransaction {
   }
 }
 
-/** Returns whether an address has a nonterminal source transfer awaiting provider attribution. */
+/** Lists nonterminal source transfers that await provider attribution. */
+export function listUnattributed(db: Db.Db, depositAddressId: string): Promise<Record[]> {
+  return db.kysely
+    .selectFrom('funding_deposits')
+    .selectAll()
+    .where('depositAddressId', '=', depositAddressId)
+    .where('providerRequestId', 'is', null)
+    .where('status', 'not in', ['completed', 'refunded'])
+    .orderBy('createdAt', 'asc')
+    .orderBy('id', 'asc')
+    .execute()
+}
+
+/** Returns whether an address has a source transfer awaiting provider attribution. */
 export async function hasUnattributed(db: Db.Db, depositAddressId: string): Promise<boolean> {
   return Boolean(
     await db.kysely
@@ -195,7 +208,6 @@ export async function hasUnattributed(db: Db.Db, depositAddressId: string): Prom
       .select('id')
       .where('depositAddressId', '=', depositAddressId)
       .where('providerRequestId', 'is', null)
-      .where('status', 'not in', ['completed', 'refunded'])
       .limit(1)
       .executeTakeFirst(),
   )
@@ -265,6 +277,63 @@ export declare namespace listByAddress {
   }
 }
 
+/** Lists deposits for one reusable source-chain address newest-first. */
+export function listByDepositAddress(
+  db: Db.Db,
+  options: listByDepositAddress.Options,
+): Promise<Record[]> {
+  const { cursor, depositAddress, limit, owner } = options
+  const address = /^0x[0-9a-fA-F]{40}$/.test(depositAddress)
+    ? depositAddress.toLowerCase()
+    : depositAddress
+  let query = db.kysely
+    .selectFrom('funding_deposits')
+    .innerJoin(
+      'funding_deposit_addresses',
+      'funding_deposit_addresses.id',
+      'funding_deposits.depositAddressId',
+    )
+    .selectAll('funding_deposits')
+    .where('funding_deposit_addresses.address', '=', address)
+    .where('funding_deposit_addresses.environment', '=', owner.environment)
+    .where('funding_deposit_addresses.orgId', '=', owner.orgId)
+    .where('funding_deposits.environment', '=', owner.environment)
+    .where('funding_deposits.orgId', '=', owner.orgId)
+  if (owner.projectId !== undefined)
+    query = query
+      .where('funding_deposit_addresses.projectId', '=', owner.projectId)
+      .where('funding_deposits.projectId', '=', owner.projectId)
+  if (cursor)
+    query = query.where((eb) =>
+      eb.or([
+        eb('funding_deposits.createdAt', '<', cursor.createdAt),
+        eb.and([
+          eb('funding_deposits.createdAt', '=', cursor.createdAt),
+          eb('funding_deposits.id', '<', cursor.id),
+        ]),
+      ]),
+    )
+  return query
+    .orderBy('funding_deposits.createdAt', 'desc')
+    .orderBy('funding_deposits.id', 'desc')
+    .limit(limit)
+    .execute()
+}
+
+export declare namespace listByDepositAddress {
+  /** Deposit address filter, ownership, and paging options. */
+  type Options = {
+    /** Exclusive lower bound from the previous page. */
+    cursor?: listByAddress.Cursor | undefined
+    /** Reusable source-chain address that received the funds. */
+    depositAddress: string
+    /** Maximum rows to return. */
+    limit: number
+    /** Ownership filter derived from the authenticated API key. */
+    owner: Owner
+  }
+}
+
 /** Lists one recipient's owner-visible deposits newest-first. */
 export function listByRecipient(db: Db.Db, options: listByRecipient.Options): Promise<Record[]> {
   const { cursor, limit, owner, recipient } = options

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/Auth.test.ts

@@ -1256,6 +1256,34 @@ describe('require', () => {
       })
     })
 
+    test('session challenge rejects a chain outside the configured allowlist', async () => {
+      const mpp = Object.assign(
+        createMppServer({
+          chainId: Viem.chainId.mainnet,
+          getClient: ({ chainId = Viem.chainId.mainnet }) => Viem.getClient({ chainId }),
+        }),
+        { sessionChainIds: new Set([Viem.chainId.mainnet, Viem.chainId.testnet]) },
+      )
+      const app = createApp({
+        auth: {
+          apiKey: { resolve: TestApp.resolver({ keys: [{ ...key, token }] }) },
+          mpp,
+          rateLimit: overQuota(),
+        },
+        policy: {
+          mpp: { session: { amount: '1' } },
+          public: { rateLimit: { perMinute: 1 } },
+        },
+      })
+
+      const response = await app.request('/protected?chainId=31318')
+      const body = await response.json()
+
+      expect(response.status).toBe(429)
+      expect(response.headers.has('www-authenticate')).toBe(false)
+      expect(body).toMatchObject({ error: { code: 'payment_required' } })
+    })
+
     test('route session overrides propagate to the challenge', async () => {
       const mpp = createMppServer()
       const app = createApp({

package/src/internal/Auth.ts

@@ -117,6 +117,8 @@ type MppHandler = {
   session(options: Mpp.Session): MiddlewareHandler
   /** Resolves the chain from a challenge issued by this server. */
   sessionChainId?: ((c: hono_Context) => number | undefined) | undefined
+  /** Chains accepted from request-driven Tempo Session payment overrides. */
+  sessionChainIds?: ReadonlySet<number> | undefined
 }
 
 /**
@@ -504,6 +506,7 @@ export function middleware<
   const {
     rateLimit: mppRateLimit = defaultMppRateLimit,
     session: session_ = {},
+    sessionChainIds,
     ...mpp
   } = options.mpp === false ? {} : (options.mpp ?? {})
   const secretKey = resolveMppSecretKey(mpp.secretKey)
@@ -565,6 +568,7 @@ export function middleware<
               ],
             }).session,
             sessionChainId: (c) => paymentSessionChainId(c, secretKey),
+            ...(sessionChainIds ? { sessionChainIds: new Set(sessionChainIds) } : {}),
           },
         }),
     rateLimit: RateLimit.memory(options.rateLimit),
@@ -666,6 +670,8 @@ export declare namespace middleware {
     rateLimit?: RateLimit.Limit | undefined
     /** Global Tempo Session options passed to the MPP method instantiator. */
     session?: NonNullable<Parameters<typeof tempo.session>[0]> | undefined
+    /** Chains accepted from request-driven Tempo Session payment overrides. Omit to preserve the MPP client's chain support. */
+    sessionChainIds?: readonly number[] | undefined
   }
 }
 
@@ -1991,8 +1997,16 @@ async function requirePayment<environment extends Environment>(
   }
 
   const session = options.policy.mpp?.session ?? {}
+  const explicit = explicitChainId(c)
+  const sessionChainIds = options.auth.mpp?.sessionChainIds
+  if (explicit !== undefined && sessionChainIds && !sessionChainIds.has(explicit))
+    return jsonError(c, {
+      code: 'payment_required',
+      message: 'Payment is not available for the requested chain',
+      status: 429,
+    })
   const chainId =
-    explicitChainId(c) ??
+    explicit ??
     (c.req.method === 'POST' && session.scope?.startsWith('GET ')
       ? options.auth.mpp?.sessionChainId?.(c)
       : undefined)

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,