tapimo 0.6.0 → 0.7.1

package/src/db/tables/organizations.ts

@@ -1,8 +1,11 @@
-import { sql, type Selectable } from 'kysely'
+import { sql, type ExpressionBuilder, type Selectable } from 'kysely'
 
 import * as Id from '../../internal/Id.js'
+import * as Viem from '../../internal/Viem.js'
+import * as SponsoredTransactions from './sponsoredTransactions.js'
 import type * as Db from '../Db.js'
 import type * as db_Schema from '../Schema.js'
+import type * as EnabledBillingSources from './enabledBillingSources.js'
 import type * as Memberships from './memberships.js'
 
 /** Columns of the `organizations` table, derived from `Schema.Organization`. */
@@ -50,8 +53,8 @@ export declare namespace create {
 }
 
 /**
- * Inserts an organization owned by `userId` — the org row plus its `owner`
- * membership, atomically.
+ * Inserts an organization, its owner membership, and initial billing sources
+ * atomically.
  *
  * @param db - The database.
  * @param input - The organization to insert.
@@ -82,6 +85,18 @@ export function createOwned(db: Db.Db, input: createOwned.Input): Promise<Record
         userId: input.userId,
       })
       .execute()
+    if (input.enabledBillingSources?.length)
+      await trx
+        .insertInto('enabled_billing_sources')
+        .values(
+          input.enabledBillingSources.map((source) => ({
+            createdAt: now,
+            createdBy: input.userId,
+            orgId: record.id,
+            source,
+          })),
+        )
+        .execute()
     return record
   })
 }
@@ -89,6 +104,8 @@ export function createOwned(db: Db.Db, input: createOwned.Input): Promise<Record
 export declare namespace createOwned {
   /** Fields accepted when inserting a user-owned organization. */
   type Input = {
+    /** Billing sources enabled when the organization is created. */
+    enabledBillingSources?: readonly EnabledBillingSources.Source[] | undefined
     /** Human-readable organization name. */
     name: string
     /** Owning user id (`usr_…`), granted the `owner` membership. */
@@ -105,12 +122,17 @@ export declare namespace createOwned {
  */
 export function deleteOrganization(db: Db.Db, id: string): Promise<boolean> {
   return db.kysely.transaction().execute(async (trx) => {
+    const failedSince = new Date(
+      Date.now() - SponsoredTransactions.failedIntentRecoveryTtlMs,
+    ).toISOString()
     const unreported = await trx
       .selectFrom('sponsored_transactions')
       .select('id')
       .where('orgId', '=', id)
       .where('billable', '=', true)
+      .where('chainId', '=', Viem.chainId.mainnet)
       .where('meterReportedAt', 'is', null)
+      .where(unreportedSponsorshipStatus(failedSince))
       .limit(1)
       .executeTakeFirst()
     if (unreported) throw new UnreportedSponsorshipsError()
@@ -121,6 +143,7 @@ export function deleteOrganization(db: Db.Db, id: string): Promise<boolean> {
       .where('ownerId', '=', id)
       .execute()
     await trx.deleteFrom('billing_settings').where('orgId', '=', id).execute()
+    await trx.deleteFrom('enabled_billing_sources').where('orgId', '=', id).execute()
     await trx.deleteFrom('invitations').where('orgId', '=', id).execute()
     await trx.deleteFrom('invite_link_redemptions').where('orgId', '=', id).execute()
     await trx.deleteFrom('invite_links').where('orgId', '=', id).execute()
@@ -136,12 +159,17 @@ export function deleteOrganization(db: Db.Db, id: string): Promise<boolean> {
 
 /** Whether an organization has billable sponsorships awaiting settlement. */
 export async function hasUnreportedSponsorships(db: Db.Db, id: string): Promise<boolean> {
+  const failedSince = new Date(
+    Date.now() - SponsoredTransactions.failedIntentRecoveryTtlMs,
+  ).toISOString()
   const record = await db.kysely
     .selectFrom('sponsored_transactions')
     .select('id')
     .where('orgId', '=', id)
     .where('billable', '=', true)
+    .where('chainId', '=', Viem.chainId.mainnet)
     .where('meterReportedAt', 'is', null)
+    .where(unreportedSponsorshipStatus(failedSince))
     .limit(1)
     .executeTakeFirst()
   return record !== undefined
@@ -413,6 +441,19 @@ export declare namespace upsert {
   }
 }
 
+/** Blocks rows that can still settle or recover into billable mainnet spend. */
+function unreportedSponsorshipStatus(failedSince: string) {
+  return (eb: ExpressionBuilder<Db.Database, 'sponsored_transactions'>) =>
+    eb.or([
+      eb('status', '!=', 'failed'),
+      eb.and([
+        eb('status', '=', 'failed'),
+        eb('transactionHash', 'is', null),
+        eb('finalizedAt', '>=', failedSince),
+      ]),
+    ])
+}
+
 /** Organization deletion is blocked until billable sponsorships settle. */
 export class UnreportedSponsorshipsError extends Error {
   override name = 'Organizations.UnreportedSponsorshipsError'

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/handlers/internal/utils.ts

@@ -3,6 +3,8 @@ import { KeyAuthorization, Transaction as core_Transaction, TxEnvelopeTempo } fr
 import { type Client, BaseError } from 'viem'
 import * as z from 'zod/mini'
 
+import * as ApiResponse from '../../internal/Response.js'
+
 export function resolveChainId(value: unknown) {
   if (typeof value === 'number') return value
   if (typeof value === 'bigint') return Number(value)
@@ -97,24 +99,38 @@ export function rpcErrorJson(request: RpcRequest.RpcRequest, error: unknown) {
       { request },
     )
 
-  if ((error as { name?: string | undefined }).name === 'ZodError')
+  if (error instanceof z.core.$ZodError)
     return RpcResponse.from(
       {
         error: {
           code: RpcResponse.InvalidParamsError.code,
-          message: (error as Error).message,
+          data: {
+            code: 'invalid_params',
+            issues: ApiResponse.validationDetails(error.issues.slice(0, 10)),
+          },
+          message: 'Invalid params.',
         },
       },
       { request },
     )
 
   const inner = resolveError(error)
-  const message = inner.message ?? (error as Error).message
-  const code = inner.code ?? -32603
-  const data = inner.data
+  if (inner.code === undefined || inner.message === undefined)
+    return RpcResponse.from(
+      {
+        error: {
+          code: RpcResponse.InternalError.code,
+          data: { code: 'internal_error' },
+          message: 'Internal error',
+        },
+      },
+      { request },
+    )
+
+  const { code, data, message } = inner
   return RpcResponse.from(
     {
-      error: { code, message, ...(data ? { data } : {}) },
+      error: { code, message, ...(data === undefined ? {} : { data }) },
     },
     { request },
   )

package/src/handlers/relay.errors.test.ts

@@ -0,0 +1,153 @@
+import * as z from 'zod/mini'
+
+import * as Relay from '../../test/Relay.js'
+
+describe('request errors', () => {
+  test('returns Parse error for invalid JSON', async () => {
+    const server = await Relay.createServer((await Relay.relay()).listener)
+
+    try {
+      const response = await fetch(server.url, {
+        body: '{',
+        headers: { 'Content-Type': 'application/json' },
+        method: 'POST',
+      })
+
+      expect(await response.json()).toMatchInlineSnapshot(`
+        {
+          "error": {
+            "code": -32700,
+            "message": "Parse error",
+          },
+          "id": null,
+          "jsonrpc": "2.0",
+        }
+      `)
+    } finally {
+      await server.closeAsync()
+    }
+  })
+
+  test.each([
+    ['non-object request', 'null'],
+    ['invalid version', JSON.stringify({ id: 1, jsonrpc: '1.0', method: 'eth_chainId' })],
+    ['empty batch', '[]'],
+  ])('returns Invalid Request for %s', async (_name, body) => {
+    const server = await Relay.createServer((await Relay.relay()).listener)
+
+    try {
+      const response = await fetch(server.url, {
+        body,
+        headers: { 'Content-Type': 'application/json' },
+        method: 'POST',
+      })
+
+      expect(await response.json()).toMatchInlineSnapshot(`
+        {
+          "error": {
+            "code": -32600,
+            "message": "Invalid Request",
+          },
+          "id": null,
+          "jsonrpc": "2.0",
+        }
+      `)
+    } finally {
+      await server.closeAsync()
+    }
+  })
+
+  test('returns one Invalid Request error for a malformed batch member', async () => {
+    const server = await Relay.createServer(
+      (
+        await Relay.relay({
+          getClient: () => {
+            throw new Error('transport credential must not leak')
+          },
+        })
+      ).listener,
+    )
+
+    try {
+      const response = await fetch(server.url, {
+        body: JSON.stringify([
+          { id: 1, jsonrpc: '2.0', method: 'eth_chainId' },
+          { id: 2, jsonrpc: '1.0', method: 'eth_chainId' },
+        ]),
+        headers: { 'Content-Type': 'application/json' },
+        method: 'POST',
+      })
+
+      expect(await response.json()).toMatchInlineSnapshot(`
+        [
+          {
+            "error": {
+              "code": -32603,
+              "data": {
+                "code": "internal_error",
+              },
+              "message": "Internal error",
+            },
+            "id": 1,
+            "jsonrpc": "2.0",
+          },
+          {
+            "error": {
+              "code": -32600,
+              "message": "Invalid Request",
+            },
+            "id": null,
+            "jsonrpc": "2.0",
+          },
+        ]
+      `)
+    } finally {
+      await server.closeAsync()
+    }
+  })
+
+  test('returns bounded structured issues for invalid params', async () => {
+    const schema = z.object({ value: z.string() })
+    const server = await Relay.createServer(
+      (
+        await Relay.relay({
+          onRequest: async () => {
+            schema.parse({ value: 1 })
+          },
+        })
+      ).listener,
+    )
+
+    try {
+      const response = await fetch(server.url, {
+        body: JSON.stringify({ id: 1, jsonrpc: '2.0', method: 'eth_chainId' }),
+        headers: { 'Content-Type': 'application/json' },
+        method: 'POST',
+      })
+
+      expect(await response.json()).toMatchInlineSnapshot(`
+        {
+          "error": {
+            "code": -32602,
+            "data": {
+              "code": "invalid_params",
+              "issues": [
+                {
+                  "message": "Invalid input",
+                  "path": [
+                    "value",
+                  ],
+                },
+              ],
+            },
+            "message": "Invalid params.",
+          },
+          "id": 1,
+          "jsonrpc": "2.0",
+        }
+      `)
+    } finally {
+      await server.closeAsync()
+    }
+  })
+})

package/src/handlers/relay.ts

@@ -639,20 +639,30 @@ export function relay(options: relay.Options = {}): Handler {
 
   async function handlePost(c: { req: { raw: Request; param: (key: string) => string } }) {
     const chainId = Utils.resolveChainId(c.req.param('chainId'))
-    const body = await c.req.raw.json()
+    const body = await c.req.raw.json().catch(() => undefined)
+    if (body === undefined) return Response.json(rpcProtocolError('parse'))
+
     const isBatch = Array.isArray(body)
 
     if (!isBatch) {
+      if (!isRpcRequest(body)) return Response.json(rpcProtocolError('invalid_request'))
       const request = RpcRequest.from(body as never) as RpcRequest.RpcRequest<RpcSchema.Ox>
-      return Response.json(await handleRequest(request, { chainId }))
+      const response = await handleRequest(request, { chainId }).catch((error) =>
+        Utils.rpcErrorJson(request, error),
+      )
+      return Response.json(response)
     }
 
+    if (body.length === 0) return Response.json(rpcProtocolError('invalid_request'))
+
     const responses = await Promise.all(
-      (body as unknown[]).map((item) =>
-        handleRequest(RpcRequest.from(item as never) as RpcRequest.RpcRequest<RpcSchema.Ox>, {
-          chainId,
-        }),
-      ),
+      body.map((item) => {
+        if (!isRpcRequest(item)) return Promise.resolve(rpcProtocolError('invalid_request'))
+        return handleRequest(
+          RpcRequest.from(item as never) as RpcRequest.RpcRequest<RpcSchema.Ox>,
+          { chainId },
+        ).catch((error) => Utils.rpcErrorJson(item as RpcRequest.RpcRequest, error))
+      }),
     )
     return Response.json(responses)
   }
@@ -663,6 +673,31 @@ export function relay(options: relay.Options = {}): Handler {
   return router
 }
 
+function isRpcRequest(value: unknown): value is Record<string, unknown> {
+  if (!value || typeof value !== 'object' || Array.isArray(value)) return false
+  const request = value as Record<string, unknown>
+  if (request['jsonrpc'] !== '2.0' || typeof request['method'] !== 'string') return false
+
+  const id = request['id']
+  if (id !== undefined && id !== null && typeof id !== 'number' && typeof id !== 'string')
+    return false
+
+  const params = request['params']
+  if (params === undefined || Array.isArray(params)) return true
+  return Boolean(params) && typeof params === 'object'
+}
+
+function rpcProtocolError(type: 'invalid_request' | 'parse') {
+  return {
+    error:
+      type === 'parse'
+        ? { code: RpcResponse.ParseError.code, message: 'Parse error' }
+        : { code: RpcResponse.InvalidRequestError.code, message: 'Invalid Request' },
+    id: null,
+    jsonrpc: '2.0',
+  }
+}
+
 function defaultGetClient(options: { apiKey?: string | undefined }) {
   const clients = new Map<number, Client>()
   for (const chain of defaultChains) {

package/src/internal/Auth.test.ts

@@ -671,7 +671,7 @@ describe('require', () => {
         headers: { 'tempo-api-key': sandboxToken },
       })
       expect(response.status).toBe(200)
-      // The public ceiling (60), not the API-key default (100).
+      // The public ceiling (60), not the API-key default (10,000).
       expect(response.headers.get('RateLimit-Limit')).toMatchInlineSnapshot(`"60"`)
     })
 
@@ -684,8 +684,8 @@ describe('require', () => {
         headers: { 'tempo-api-key': sandboxToken },
       })
       expect(response.status).toBe(200)
-      // The API-key default (100), not the public ceiling (60).
-      expect(response.headers.get('RateLimit-Limit')).toMatchInlineSnapshot(`"100"`)
+      // The API-key default (10,000), not the public ceiling (60).
+      expect(response.headers.get('RateLimit-Limit')).toMatchInlineSnapshot(`"10000"`)
     })
 
     test('throttles a sandbox key to the public quota when billing is unknown', async () => {