tapimo 0.8.0 → 0.9.0

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/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/funding/Provider.ts

@@ -503,9 +503,9 @@ export declare namespace observeDepositAddressRequest {
     recipient: string
     /** Source-chain account credited by the provider deposit. */
     refundAddress: string
-    /** Pending provider request being accelerated. */
-    request: listDepositAddressRequests.ReturnType['requests'][number]
-    /** One verified source transfer attributed to the request. */
+    /** Provider request, when the provider has indexed the source transfer. */
+    request?: listDepositAddressRequests.ReturnType['requests'][number] | undefined
+    /** One verified source transfer received by the deposit address. */
     source: Source
     /** Chain containing the source transfer. */
     sourceChain: ChainRef
@@ -649,7 +649,7 @@ export type Provider<id extends string = string> = core_Provider.Provider<id, 'f
     input: listDepositAddressRequests.Parameters,
     signal: AbortSignal,
   ): Promise<listDepositAddressRequests.ReturnType>
-  /** Observes authenticated delivery for a pending reusable-address request, when supported. */
+  /** Observes authenticated delivery for a verified reusable-address transfer, when supported. */
   observeDepositAddressRequest?(
     input: observeDepositAddressRequest.Parameters,
     signal: AbortSignal,