tapimo 0.7.0 → 0.7.2

package/src/db/tables/fundingTransferTransactions.ts

@@ -0,0 +1,37 @@
+import type { Selectable } from 'kysely'
+
+import type * as Db from '../Db.js'
+import type * as db_Schema from '../Schema.js'
+
+/** Columns of the `funding_transfer_transactions` table. */
+export type Table = db_Schema.FundingTransferTransaction
+/** One verified transaction reference on a transfer. */
+export type Record = Selectable<Table>
+
+/**
+ * Inserts a transaction reference, lowercasing EVM hashes while preserving
+ * other references. Repeats return `undefined`; conflicting source ownership throws.
+ */
+export function insert(db: Db.Db, record: Record): Promise<Record | undefined> {
+  return db.kysely
+    .insertInto('funding_transfer_transactions')
+    .values({
+      ...record,
+      transactionRef: record.chainId.startsWith('eip155:')
+        ? record.transactionRef.toLowerCase()
+        : record.transactionRef,
+    })
+    .onConflict((oc) => oc.columns(['transferId', 'role', 'transactionRef']).doNothing())
+    .returningAll()
+    .executeTakeFirst()
+}
+
+/** Lists a transfer's transaction references, oldest first. */
+export function listByTransfer(db: Db.Db, transferId: string): Promise<Record[]> {
+  return db.kysely
+    .selectFrom('funding_transfer_transactions')
+    .selectAll()
+    .where('transferId', '=', transferId)
+    .orderBy('createdAt', 'asc')
+    .execute()
+}

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

@@ -0,0 +1,89 @@
+import * as Transfer from '../../internal/funding/Transfer.js'
+import * as TestApp from '../../../test/App.js'
+import * as TestFunding from '../../../test/Funding.js'
+import * as FundingTransfers from './fundingTransfers.js'
+
+const db = TestApp.database()
+
+const owner = { environment: 'production', orgId: 'org_list' } as const
+
+let counter = 0
+function seed(input: Partial<Transfer.create.Input> = {}) {
+  // Distinct create times keep ids strictly ordered for paging assertions.
+  return Transfer.create(db, {
+    apiKeyId: 'key_test',
+    environment: 'production',
+    id: Transfer.generateId(new Date(Date.UTC(2026, 0, 1, 0, 0, counter++))),
+    orgId: owner.orgId,
+    snapshot: TestFunding.transferSnapshot(),
+    ...input,
+  })
+}
+
+describe('list', () => {
+  test('pages newest-first by id with owner isolation', async () => {
+    const first = await seed()
+    const second = await seed({ projectId: 'prj_a' })
+    const third = await seed()
+    await seed({ orgId: 'org_other' })
+    await seed({ environment: 'sandbox' })
+
+    const page = await FundingTransfers.list(db, owner, { limit: 3 })
+    expect(page.map((row) => row.id)).toEqual([third.id, second.id, first.id])
+
+    const rest = await FundingTransfers.list(db, owner, { cursor: third.id, limit: 3 })
+    expect(rest.map((row) => row.id)).toEqual([second.id, first.id])
+  })
+
+  test('narrows project-attributed owners to their project', async () => {
+    const rows = await FundingTransfers.list(db, { ...owner, projectId: 'prj_a' }, { limit: 10 })
+    expect(rows.every((row) => row.projectId === 'prj_a')).toBe(true)
+    expect(rows.length).toBeGreaterThan(0)
+  })
+
+  test('filters by status', async () => {
+    const record = await seed()
+    await Transfer.transition(db, { expectedVersion: 1, id: record.id, status: 'expired' })
+    const rows = await FundingTransfers.list(db, owner, { limit: 10, status: 'expired' })
+    expect(rows.map((row) => row.id)).toEqual([record.id])
+  })
+})
+
+describe('count', () => {
+  test('shares the list filter and stops at the cap', async () => {
+    const total = await FundingTransfers.count(db, owner, { cap: 100 })
+    expect(total).toBeGreaterThanOrEqual(3)
+    expect(await FundingTransfers.count(db, owner, { cap: 2 })).toBe(3)
+    expect(await FundingTransfers.count(db, { ...owner, orgId: 'org_none' }, { cap: 100 })).toBe(0)
+  })
+})
+
+describe('getOwned', () => {
+  test('returns owned rows and hides foreign ones', async () => {
+    const record = await seed()
+    expect((await FundingTransfers.getOwned(db, owner, record.id))?.id).toBe(record.id)
+    expect(
+      await FundingTransfers.getOwned(db, { ...owner, orgId: 'org_other' }, record.id),
+    ).toBeUndefined()
+    expect(
+      await FundingTransfers.getOwned(db, { ...owner, projectId: 'prj_a' }, record.id),
+    ).toBeUndefined()
+  })
+})
+
+describe('update', () => {
+  test('applies only against the expected version', async () => {
+    const record = await seed()
+    const options = {
+      expectedVersion: 1,
+      id: record.id,
+      snapshot: record.snapshot,
+      status: 'processing',
+      statusReason: null,
+      updatedAt: '2026-01-01T00:10:00.000Z',
+      version: 2,
+    } as const
+    expect((await FundingTransfers.update(db, options))?.version).toBe(2)
+    expect(await FundingTransfers.update(db, options)).toBeUndefined()
+  })
+})

package/src/db/tables/fundingTransfers.ts

@@ -0,0 +1,153 @@
+import type { Selectable } from 'kysely'
+
+import type * as Db from '../Db.js'
+import type * as db_Schema from '../Schema.js'
+
+/** Columns of the `funding_transfers` table. */
+export type Table = db_Schema.FundingTransfer
+/** A stored funding transfer. */
+export type Record = Selectable<Table>
+
+/**
+ * Ownership filter derived from the API-key principal, never from the
+ * request. A `projectId` narrows reads to that project; organization-attributed
+ * keys omit it and see every project in their organization and environment.
+ */
+export type Owner = {
+  /** Key environment. */
+  environment: Record['environment']
+  /** Owning organization id (`org_…`). */
+  orgId: string
+  /** Attributed project id, for project-attributed keys. */
+  projectId?: string | undefined
+}
+
+/** Inserts a transfer row. Callers commit the matching event in the same transaction. */
+export function insert(db: Db.Db, record: Record): Promise<Record> {
+  return db.kysely
+    .insertInto('funding_transfers')
+    .values(record)
+    .returningAll()
+    .executeTakeFirstOrThrow()
+}
+
+/** Gets a transfer by id without ownership scoping (domain and reconciler use). */
+export function get(db: Db.Db, id: string): Promise<Record | undefined> {
+  return db.kysely
+    .selectFrom('funding_transfers')
+    .selectAll()
+    .where('id', '=', id)
+    .executeTakeFirst()
+}
+
+/** Gets an owner-visible transfer by id; `undefined` for absent or foreign rows. */
+export function getOwned(db: Db.Db, owner: Owner, id: string): Promise<Record | undefined> {
+  let query = db.kysely
+    .selectFrom('funding_transfers')
+    .selectAll()
+    .where('id', '=', id)
+    .where('orgId', '=', owner.orgId)
+    .where('environment', '=', owner.environment)
+  if (owner.projectId !== undefined) query = query.where('projectId', '=', owner.projectId)
+  return query.executeTakeFirst()
+}
+
+/**
+ * Lists an owner's transfers newest-first. Ids embed a timestamp, so lexical
+ * key order is chronological and the cursor is the last returned id.
+ */
+export function list(db: Db.Db, owner: Owner, options: list.Options): Promise<Record[]> {
+  let query = db.kysely
+    .selectFrom('funding_transfers')
+    .selectAll()
+    .where('orgId', '=', owner.orgId)
+    .where('environment', '=', owner.environment)
+  if (owner.projectId !== undefined) query = query.where('projectId', '=', owner.projectId)
+  if (options.status !== undefined) query = query.where('status', '=', options.status)
+  if (options.cursor !== undefined) query = query.where('id', '<', options.cursor)
+  return query.orderBy('id', 'desc').limit(options.limit).execute()
+}
+
+export declare namespace list {
+  /** Paging and filter options. */
+  type Options = {
+    /** Exclusive lower bound: the last id of the previous page. */
+    cursor?: string | undefined
+    /** Maximum rows to return (fetch one extra to detect a further page). */
+    limit: number
+    /** Restricts to one lifecycle status. */
+    status?: Record['status'] | undefined
+  }
+}
+
+/**
+ * Counts an owner's transfers through a capped subquery sharing the list
+ * filter, so the count cannot scan unboundedly. A result above `cap` means
+ * the true count was truncated.
+ */
+export async function count(db: Db.Db, owner: Owner, options: count.Options): Promise<number> {
+  const row = await db.kysely
+    .selectFrom((eb) => {
+      let query = eb
+        .selectFrom('funding_transfers')
+        .select('id')
+        .where('orgId', '=', owner.orgId)
+        .where('environment', '=', owner.environment)
+      if (owner.projectId !== undefined) query = query.where('projectId', '=', owner.projectId)
+      if (options.status !== undefined) query = query.where('status', '=', options.status)
+      return query.limit(options.cap + 1).as('page')
+    })
+    .select(({ fn }) => fn.countAll<string>().as('count'))
+    .executeTakeFirstOrThrow()
+  return Number(row.count)
+}
+
+export declare namespace count {
+  /** Count options sharing the list filter. */
+  type Options = {
+    /** Row ceiling; a result above it signals a truncated count. */
+    cap: number
+    /** Restricts to one lifecycle status. */
+    status?: Record['status'] | undefined
+  }
+}
+
+/**
+ * Applies a version-guarded update; `undefined` when the row moved past
+ * `expectedVersion` (or vanished) so the caller retries against fresh state.
+ */
+export function update(db: Db.Db, options: update.Options): Promise<Record | undefined> {
+  return db.kysely
+    .updateTable('funding_transfers')
+    .set({
+      snapshot: options.snapshot,
+      status: options.status,
+      statusReason: options.statusReason,
+      updatedAt: options.updatedAt,
+      version: options.version,
+    })
+    .where('id', '=', options.id)
+    .where('version', '=', options.expectedVersion)
+    .returningAll()
+    .executeTakeFirst()
+}
+
+export declare namespace update {
+  /** Guarded update fields. */
+  type Options = {
+    /** The version the update was computed against. */
+    expectedVersion: number
+    /** Transfer id (`ftr_…`). */
+    id: string
+    /** Replacement public snapshot. */
+    snapshot: Record['snapshot']
+    /** New lifecycle status. */
+    status: Record['status']
+    /** Customer-safe reason, or null to clear. */
+    statusReason: Record['statusReason']
+    /** Mutation timestamp (ISO 8601). */
+    updatedAt: string
+    /** The incremented version. */
+    version: number
+  }
+}

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

@@ -2,6 +2,7 @@ import { nanoid } from 'nanoid'
 
 import * as Runtime from '../../../test/runtime.js'
 import * as Webhooks from '../../internal/Webhooks.js'
+import * as Viem from '../../internal/Viem.js'
 import * as Db from '../Db.js'
 import * as EnabledBillingSources from './enabledBillingSources.js'
 import * as Memberships from './memberships.js'
@@ -216,6 +217,7 @@ describe('deleteOrganization', () => {
       transactionHash: `0x${'aa'.repeat(32)}`,
     })
 
+    expect(await Organizations.hasUnreportedSponsorships(db, 'org_1')).toBe(true)
     await expect(Organizations.deleteOrganization(db, 'org_1')).rejects.toThrow(
       Organizations.UnreportedSponsorshipsError,
     )
@@ -227,6 +229,92 @@ describe('deleteOrganization', () => {
     await db.close()
   })
 
+  test('behavior: deletes an org with only failed or non-mainnet sponsorships', async () => {
+    const db = create()
+    await db.migrate()
+    await Organizations.create(db, { id: 'org_1', name: 'One' })
+    const failed = await SponsoredTransactions.upsert(db, {
+      apiKeyId: 'key_1',
+      billable: true,
+      chainId: Viem.chainId.mainnet,
+      environment: 'production',
+      orgId: 'org_1',
+      projectId: 'prj_1',
+      signPayload: `0x${'bb'.repeat(32)}`,
+      transaction: `0x76${'cc'.repeat(16)}`,
+      transactionHash: `0x${'aa'.repeat(32)}`,
+    })
+    await SponsoredTransactions.fail(db, failed.id, '2026-01-01T00:00:00.000Z')
+    const testnet = await SponsoredTransactions.upsert(db, {
+      apiKeyId: 'key_1',
+      billable: true,
+      chainId: Viem.chainId.testnet,
+      environment: 'production',
+      orgId: 'org_1',
+      projectId: 'prj_1',
+      signPayload: `0x${'dd'.repeat(32)}`,
+      transaction: `0x76${'ee'.repeat(16)}`,
+      transactionHash: `0x${'ff'.repeat(32)}`,
+    })
+    await SponsoredTransactions.finalize(db, testnet.id, {
+      feeAmount: '100',
+      finalizedAt: '2026-01-01T00:00:00.000Z',
+    })
+
+    expect(await Organizations.hasUnreportedSponsorships(db, 'org_1')).toBe(false)
+    expect(await Organizations.deleteOrganization(db, 'org_1')).toBe(true)
+    await db.close()
+  })
+
+  test('behavior: preserves an org with a recoverable failed fill intent', async () => {
+    const db = create()
+    await db.migrate()
+    await Organizations.create(db, { id: 'org_1', name: 'One' })
+    const failed = await SponsoredTransactions.upsert(db, {
+      apiKeyId: 'key_1',
+      billable: true,
+      chainId: Viem.chainId.mainnet,
+      environment: 'production',
+      orgId: 'org_1',
+      projectId: 'prj_1',
+      signPayload: `0x${'bb'.repeat(32)}`,
+      transaction: `0x76${'cc'.repeat(16)}`,
+    })
+    await SponsoredTransactions.fail(db, failed.id, new Date().toISOString())
+
+    expect(await Organizations.hasUnreportedSponsorships(db, 'org_1')).toBe(true)
+    await expect(Organizations.deleteOrganization(db, 'org_1')).rejects.toThrow(
+      Organizations.UnreportedSponsorshipsError,
+    )
+    expect(await Organizations.get(db, 'org_1')).toBeDefined()
+    await db.close()
+  })
+
+  test('behavior: deletes an org with only expired failed fill intents', async () => {
+    const db = create()
+    await db.migrate()
+    await Organizations.create(db, { id: 'org_1', name: 'One' })
+    const failed = await SponsoredTransactions.upsert(db, {
+      apiKeyId: 'key_1',
+      billable: true,
+      chainId: Viem.chainId.mainnet,
+      environment: 'production',
+      orgId: 'org_1',
+      projectId: 'prj_1',
+      signPayload: `0x${'bb'.repeat(32)}`,
+      transaction: `0x76${'cc'.repeat(16)}`,
+    })
+    await SponsoredTransactions.fail(
+      db,
+      failed.id,
+      new Date(Date.now() - SponsoredTransactions.failedIntentRecoveryTtlMs - 1).toISOString(),
+    )
+
+    expect(await Organizations.hasUnreportedSponsorships(db, 'org_1')).toBe(false)
+    expect(await Organizations.deleteOrganization(db, 'org_1')).toBe(true)
+    await db.close()
+  })
+
   test('behavior: deletes enabled billing sources', async () => {
     const db = create()
     await db.migrate()

package/src/db/tables/organizations.ts

@@ -1,6 +1,8 @@
-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'
@@ -120,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()
@@ -152,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
@@ -174,6 +186,22 @@ export function get(db: Db.Db, id: string): Promise<Record | undefined> {
   return db.kysely.selectFrom('organizations').selectAll().where('id', '=', id).executeTakeFirst()
 }
 
+/**
+ * Reads organizations by id for operational attribution displays.
+ *
+ * @param db - The database.
+ * @param ids - Organization ids to read.
+ * @returns Matching organization records.
+ */
+export function listByIds(db: Db.Db, ids: readonly string[]): Promise<Record[]> {
+  if (ids.length === 0) return Promise.resolve([])
+  return db.kysely
+    .selectFrom('organizations')
+    .selectAll()
+    .where('id', 'in', [...ids])
+    .execute()
+}
+
 /**
  * Reads an organization with current member and project counts.
  *
@@ -429,6 +457,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/projects.ts

@@ -65,6 +65,22 @@ export function get(db: Db.Db, id: string): Promise<Record | undefined> {
   return db.kysely.selectFrom('projects').selectAll().where('id', '=', id).executeTakeFirst()
 }
 
+/**
+ * Reads projects by id for operational attribution displays.
+ *
+ * @param db - The database.
+ * @param ids - Project ids to read.
+ * @returns Matching project records.
+ */
+export function listByIds(db: Db.Db, ids: readonly string[]): Promise<Record[]> {
+  if (ids.length === 0) return Promise.resolve([])
+  return db.kysely
+    .selectFrom('projects')
+    .selectAll()
+    .where('id', 'in', [...ids])
+    .execute()
+}
+
 /**
  * Lists an organization's projects, newest first.
  *

package/src/db/tables/requestUsage.ts

@@ -43,6 +43,12 @@ export type Bucket = db_Schema.RequestUsageBucket
 /** A stored request-count meter event. */
 export type MeterEvent = db_Schema.RequestUsageMeterEvent
 
+/** Aggregate state for pending meter events in one billing environment. */
+export type PendingStatus = {
+  count: number
+  oldestAttemptedAt: string | undefined
+}
+
 /** Identifies one hourly bucket for an org in an environment. */
 export type BucketKey = {
   /** UTC hour start (ISO 8601). */
@@ -91,6 +97,23 @@ export async function listPending(db: Db.Db, environment: Environment): Promise<
   return rows.map(toMeterEvent)
 }
 
+/**
+ * Reads the number and age anchor of meter events still awaiting Stripe.
+ *
+ * @param db - The database.
+ * @param environment - The billing environment to inspect.
+ * @returns The pending-event count and oldest first attempt.
+ */
+export async function getPendingStatus(db: Db.Db, environment: Environment): Promise<PendingStatus> {
+  const row = await db.kysely
+    .selectFrom('request_usage_meter_events')
+    .select((eb) => [eb.fn.countAll().as('count'), eb.fn.min('firstAttemptedAt').as('oldest')])
+    .where('environment', '=', environment)
+    .where('state', '=', 'pending')
+    .executeTakeFirstOrThrow()
+  return { count: Number(row.count), oldestAttemptedAt: row.oldest ?? undefined }
+}
+
 /**
  * Inserts a frozen `pending` meter event, claiming a delta. Idempotent on the
  * deterministic `identifier`: a re-seal after a crash resolves to the existing

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()}` })
@@ -61,6 +62,17 @@ describe('upsert', () => {
     await db.close()
   })
 
+  test('behavior: records organization-level sponsorship without a project', async () => {
+    const db = create()
+    await db.migrate()
+    const { projectId: _, ...organization } = input
+    const record = await SponsoredTransactions.upsert(db, organization)
+
+    expect(record.orgId).toMatchInlineSnapshot(`"org_1"`)
+    expect(record.projectId).toBeNull()
+    await db.close()
+  })
+
   test('behavior: preserves an explicit fee token', async () => {
     const db = create()
     await db.migrate()
@@ -160,7 +172,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 +188,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 +204,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 {