tapimo 0.7.1 → 0.7.2

package/src/db/tables/fundingDeposits.ts

@@ -0,0 +1,229 @@
+import type { JSONColumnType, Selectable } from 'kysely'
+
+import type * as Db from '../Db.js'
+import type * as db_Schema from '../Schema.js'
+
+/** Columns of the `funding_deposits` table. */
+export type Table = Omit<
+  db_Schema.FundingDeposit,
+  'providerRequestIds' | 'providerTransactionHashes'
+> & {
+  /** Private provider request identifiers stored as JSON. */
+  providerRequestIds: JSONColumnType<readonly string[], string, string>
+  /** Private provider transaction references stored as JSON. */
+  providerTransactionHashes: JSONColumnType<readonly string[], string, string>
+}
+
+/** A stored funding deposit. */
+export type Record = Selectable<Table>
+
+/** Ownership filter inherited from the deposit address. */
+export type Owner = {
+  /** Key environment. */
+  environment: Record['environment']
+  /** Owning organization id (`org_…`). */
+  orgId: string
+  /** Attributed project id for project-scoped API keys. */
+  projectId?: string | undefined
+}
+
+/** Inserts one provider-observed source transfer as a funding deposit. */
+export function insert(db: Db.Db, record: Record): Promise<Record> {
+  return db.kysely
+    .insertInto('funding_deposits')
+    .values({
+      ...record,
+      providerRequestIds: JSON.stringify(record.providerRequestIds),
+      providerTransactionHashes: JSON.stringify(record.providerTransactionHashes),
+    })
+    .returningAll()
+    .executeTakeFirstOrThrow()
+}
+
+/** Gets deposits created from one provider-observed source transaction. */
+export function listByProviderObservation(
+  db: Db.Db,
+  options: listByProviderObservation.Options,
+): Promise<Record[]> {
+  return db.kysely
+    .selectFrom('funding_deposits')
+    .selectAll()
+    .where('depositAddressId', '=', options.depositAddressId)
+    .where('providerRequestId', '=', options.providerRequestId)
+    .where('sourceTransactionHash', '=', options.sourceTransactionHash)
+    .orderBy('providerTransferIndex', 'asc')
+    .execute()
+}
+
+export declare namespace listByProviderObservation {
+  /** Provider observation fields that identify one source transaction. */
+  type Options = {
+    /** Funding deposit address that received the transfer. */
+    depositAddressId: string
+    /** Provider request that reported the transfer. */
+    providerRequestId: string
+    /** Provider-observed source transaction reference. */
+    sourceTransactionHash: string
+  }
+}
+
+/** Gets deposits associated with one address and source transaction. */
+export function listBySourceTransaction(
+  db: Db.Db,
+  options: listBySourceTransaction.Options,
+): Promise<Record[]> {
+  return db.kysely
+    .selectFrom('funding_deposits')
+    .selectAll()
+    .where('depositAddressId', '=', options.depositAddressId)
+    .where('sourceTransactionHash', '=', options.sourceTransactionHash)
+    .orderBy('sourceTransferIndex', 'asc')
+    .execute()
+}
+
+export declare namespace listBySourceTransaction {
+  /** Source transaction fields scoped to one deposit address. */
+  type Options = {
+    /** Funding deposit address that received the transfer. */
+    depositAddressId: string
+    /** Provider-observed source transaction reference. */
+    sourceTransactionHash: string
+  }
+}
+
+/** Gets a funding deposit without ownership scoping. */
+export function get(db: Db.Db, id: string): Promise<Record | undefined> {
+  return db.kysely
+    .selectFrom('funding_deposits')
+    .selectAll()
+    .where('id', '=', id)
+    .executeTakeFirst()
+}
+
+/** Gets an owner-visible funding deposit. */
+export function getOwned(db: Db.Db, owner: Owner, id: string): Promise<Record | undefined> {
+  let query = db.kysely
+    .selectFrom('funding_deposits')
+    .selectAll()
+    .where('environment', '=', owner.environment)
+    .where('id', '=', id)
+    .where('orgId', '=', owner.orgId)
+  if (owner.projectId !== undefined) query = query.where('projectId', '=', owner.projectId)
+  return query.executeTakeFirst()
+}
+
+/** Lists one owner-visible address's deposits newest-first. */
+export function listByAddress(
+  db: Db.Db,
+  owner: Owner,
+  addressId: string,
+  options: listByAddress.Options,
+): Promise<Record[]> {
+  const { cursor, limit } = options
+  let query = db.kysely
+    .selectFrom('funding_deposits')
+    .selectAll()
+    .where('depositAddressId', '=', addressId)
+    .where('environment', '=', owner.environment)
+    .where('orgId', '=', owner.orgId)
+  if (owner.projectId !== undefined) query = query.where('projectId', '=', owner.projectId)
+  if (cursor)
+    query = query.where((eb) =>
+      eb.or([
+        eb('createdAt', '<', cursor.createdAt),
+        eb.and([eb('createdAt', '=', cursor.createdAt), eb('id', '<', cursor.id)]),
+      ]),
+    )
+  return query.orderBy('createdAt', 'desc').orderBy('id', 'desc').limit(limit).execute()
+}
+
+export declare namespace listByAddress {
+  /** Cursor fields for the last deposit returned by the previous page. */
+  type Cursor = {
+    /** Deposit creation time. */
+    createdAt: string
+    /** Deposit id, used as a deterministic tie-breaker. */
+    id: string
+  }
+
+  /** Paging options for one address's deposits. */
+  type Options = {
+    /** Exclusive lower bound from the previous page. */
+    cursor?: Cursor | undefined
+    /** Maximum rows to return. */
+    limit: number
+  }
+}
+
+/** Applies a version-guarded deposit update. */
+export function update(db: Db.Db, options: update.Options): Promise<Record | undefined> {
+  return db.kysely
+    .updateTable('funding_deposits')
+    .set({
+      providerOutputAmount: options.providerOutputAmount,
+      providerRequestId: options.providerRequestId,
+      providerRequestIds: JSON.stringify(options.providerRequestIds),
+      providerState: options.providerState,
+      providerTransactionHashes: JSON.stringify(options.providerTransactionHashes),
+      providerTransferIndex: options.providerTransferIndex,
+      retryState: options.retryState,
+      settlementTransaction: options.settlementTransaction,
+      settlementTransactionHash: options.settlementTransactionHash,
+      snapshot: options.snapshot,
+      sourceTransferIndex: options.sourceTransferIndex,
+      status: options.status,
+      statusReason: options.statusReason,
+      subsidyAmount: options.subsidyAmount,
+      tempoGasPaid: options.tempoGasPaid,
+      updatedAt: options.updatedAt,
+      version: options.version,
+    })
+    .where('id', '=', options.id)
+    .where('version', '=', options.expectedVersion)
+    .returningAll()
+    .executeTakeFirst()
+}
+
+export declare namespace update {
+  /** Guarded deposit update fields. */
+  type Options = {
+    /** Stored version required for the update. */
+    expectedVersion: number
+    /** Funding deposit id (`fdp_…`). */
+    id: string
+    /** Provider output amount confirmed on Tempo. */
+    providerOutputAmount: Record['providerOutputAmount']
+    /** Provider request that first reported the deposit. */
+    providerRequestId: Record['providerRequestId']
+    /** Private provider request identifiers. */
+    providerRequestIds: Record['providerRequestIds']
+    /** Bounded private provider state. */
+    providerState: Record['providerState']
+    /** Provider-leg transaction references. */
+    providerTransactionHashes: Record['providerTransactionHashes']
+    /** Deposit position within the provider request. */
+    providerTransferIndex: Record['providerTransferIndex']
+    /** Bounded private retry state. */
+    retryState: Record['retryState']
+    /** Persisted settlement transaction bytes for exactly-once rebroadcast. */
+    settlementTransaction: Record['settlementTransaction']
+    /** Persisted settlement transaction hash. */
+    settlementTransactionHash: Record['settlementTransactionHash']
+    /** Replacement public snapshot. */
+    snapshot: Record['snapshot']
+    /** Verified transfer position in the source transaction, or null. */
+    sourceTransferIndex: Record['sourceTransferIndex']
+    /** Replacement lifecycle status. */
+    status: Record['status']
+    /** Replacement customer-safe reason. */
+    statusReason: Record['statusReason']
+    /** Destination token amount supplied by Tempo. */
+    subsidyAmount: Record['subsidyAmount']
+    /** Tempo gas paid for settlement, in base units. */
+    tempoGasPaid: Record['tempoGasPaid']
+    /** New material update time. */
+    updatedAt: string
+    /** New material version. */
+    version: number
+  }
+}

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

@@ -0,0 +1,182 @@
+import * as TestApp from '../../../test/App.js'
+import * as FundingIdempotency from './fundingIdempotency.js'
+
+const db = TestApp.database()
+
+const now = new Date('2026-01-01T00:00:00.000Z')
+const replayTtlMs = 86_400_000
+const ttlMs = 60_000
+
+beforeEach(() => vi.useFakeTimers({ now, toFake: ['Date'] }))
+afterEach(() => vi.useRealTimers())
+
+function input(overrides: Partial<FundingIdempotency.claim.Input> = {}) {
+  return {
+    apiKeyId: 'key_test',
+    keyHash: `hash_${Math.random().toString(36).slice(2)}`,
+    requestHash: 'req_aaaa',
+    ttlMs,
+    ...overrides,
+  }
+}
+
+describe('claim', () => {
+  test('claims, blocks equivalent concurrent requests, and flags mismatches', async () => {
+    const first = input()
+    expect(await FundingIdempotency.claim(db, first)).toEqual({
+      createdAt: now.toISOString(),
+      type: 'claimed',
+    })
+    expect(await FundingIdempotency.claim(db, first)).toEqual({ type: 'pending' })
+    expect(await FundingIdempotency.claim(db, { ...first, requestHash: 'req_bbbb' })).toEqual({
+      type: 'mismatch',
+    })
+  })
+
+  test('replays the stored response after completion', async () => {
+    const claimed = input()
+    const result = await FundingIdempotency.claim(db, claimed)
+    expect(result.type).toBe('claimed')
+    if (result.type !== 'claimed') return
+    const completedAt = new Date('2026-01-01T00:00:30.000Z')
+    vi.setSystemTime(completedAt)
+    await FundingIdempotency.complete(db, {
+      apiKeyId: claimed.apiKeyId,
+      createdAt: result.createdAt,
+      keyHash: claimed.keyHash,
+      replayTtlMs,
+      response: '{"id":"ftr_test"}',
+      transferId: 'ftr_test',
+    })
+    await expect(
+      db.kysely
+        .selectFrom('funding_idempotency_requests')
+        .select('expiresAt')
+        .where('apiKeyId', '=', claimed.apiKeyId)
+        .where('keyHash', '=', claimed.keyHash)
+        .executeTakeFirstOrThrow(),
+    ).resolves.toEqual({ expiresAt: '2026-01-02T00:00:30.000Z' })
+    expect(await FundingIdempotency.claim(db, claimed)).toEqual({
+      response: '{"id":"ftr_test"}',
+      type: 'replay',
+    })
+    // A different request against the completed key still conflicts.
+    expect(await FundingIdempotency.claim(db, { ...claimed, requestHash: 'req_bbbb' })).toEqual({
+      type: 'mismatch',
+    })
+  })
+
+  test('completes non-transfer resources without a transfer id', async () => {
+    const claimed = input()
+    const result = await FundingIdempotency.claim(db, claimed)
+    expect(result.type).toBe('claimed')
+    if (result.type !== 'claimed') return
+    await FundingIdempotency.complete(db, {
+      apiKeyId: claimed.apiKeyId,
+      createdAt: result.createdAt,
+      keyHash: claimed.keyHash,
+      replayTtlMs,
+      response: '{"id":"fda_test"}',
+    })
+
+    await expect(
+      db.kysely
+        .selectFrom('funding_idempotency_requests')
+        .select('transferId')
+        .where('apiKeyId', '=', claimed.apiKeyId)
+        .where('keyHash', '=', claimed.keyHash)
+        .executeTakeFirstOrThrow(),
+    ).resolves.toEqual({ transferId: null })
+  })
+
+  test('reclaims an expired row in place', async () => {
+    const claimed = input()
+    await FundingIdempotency.claim(db, claimed)
+    const afterExpiry = new Date('2026-01-01T00:01:00.001Z')
+    vi.setSystemTime(afterExpiry)
+    expect(await FundingIdempotency.claim(db, claimed)).toEqual({
+      createdAt: afterExpiry.toISOString(),
+      type: 'claimed',
+    })
+  })
+
+  test('release frees a pending claim for retry', async () => {
+    const claimed = input()
+    const result = await FundingIdempotency.claim(db, claimed)
+    expect(result.type).toBe('claimed')
+    if (result.type !== 'claimed') return
+    await FundingIdempotency.release(db, {
+      apiKeyId: claimed.apiKeyId,
+      createdAt: result.createdAt,
+      keyHash: claimed.keyHash,
+    })
+    expect(await FundingIdempotency.claim(db, claimed)).toEqual({
+      createdAt: now.toISOString(),
+      type: 'claimed',
+    })
+  })
+
+  test('stale completion and release cannot mutate a replacement claim', async () => {
+    const claimed = input()
+    const original = await FundingIdempotency.claim(db, claimed)
+    expect(original.type).toBe('claimed')
+    if (original.type !== 'claimed') return
+
+    const afterExpiry = new Date('2026-01-01T00:01:00.001Z')
+    vi.setSystemTime(afterExpiry)
+    const replacement = await FundingIdempotency.claim(db, claimed)
+    expect(replacement.type).toBe('claimed')
+    if (replacement.type !== 'claimed') return
+
+    const identity = {
+      apiKeyId: claimed.apiKeyId,
+      createdAt: original.createdAt,
+      keyHash: claimed.keyHash,
+    }
+    expect(
+      await FundingIdempotency.complete(db, {
+        ...identity,
+        replayTtlMs,
+        response: '{"id":"ftr_stale"}',
+        transferId: 'ftr_stale',
+      }),
+    ).toBeUndefined()
+    await FundingIdempotency.release(db, identity)
+    expect(await FundingIdempotency.claim(db, claimed)).toEqual({
+      type: 'pending',
+    })
+  })
+})
+
+describe('checkpoint', () => {
+  test('resumes a provider result and completes it', async () => {
+    const claimed = input()
+    const result = await FundingIdempotency.claim(db, claimed)
+    expect(result.type).toBe('claimed')
+    if (result.type !== 'claimed') return
+    await FundingIdempotency.checkpoint(db, {
+      apiKeyId: claimed.apiKeyId,
+      createdAt: result.createdAt,
+      keyHash: claimed.keyHash,
+      replayTtlMs,
+      response: '{"requestId":"relay_request_1"}',
+    })
+
+    expect(await FundingIdempotency.claim(db, claimed)).toEqual({
+      createdAt: now.toISOString(),
+      response: '{"requestId":"relay_request_1"}',
+      type: 'resume',
+    })
+    await FundingIdempotency.complete(db, {
+      apiKeyId: claimed.apiKeyId,
+      createdAt: result.createdAt,
+      keyHash: claimed.keyHash,
+      replayTtlMs,
+      response: '{"id":"fda_test"}',
+    })
+    expect(await FundingIdempotency.claim(db, claimed)).toEqual({
+      response: '{"id":"fda_test"}',
+      type: 'replay',
+    })
+  })
+})

package/src/db/tables/fundingIdempotency.ts

@@ -0,0 +1,180 @@
+import type { Selectable } from 'kysely'
+
+import type * as Db from '../Db.js'
+import type * as db_Schema from '../Schema.js'
+
+/** Columns of the `funding_idempotency_requests` table. */
+export type Table = db_Schema.FundingIdempotencyRequest
+/** A stored idempotency claim. */
+export type Record = Selectable<Table>
+
+/**
+ * Claims `(apiKeyId, keyHash)` for one creation attempt. A live claim rejects
+ * mismatches, blocks pending work, resumes checkpoints, or replays completion.
+ */
+export async function claim(db: Db.Db, input: claim.Input): Promise<claim.Result> {
+  const now = new Date()
+  const record: Record = {
+    apiKeyId: input.apiKeyId,
+    createdAt: now.toISOString(),
+    expiresAt: new Date(now.getTime() + input.ttlMs).toISOString(),
+    keyHash: input.keyHash,
+    requestHash: input.requestHash,
+    response: null,
+    status: 'pending',
+    transferId: null,
+  }
+  const inserted = await db.kysely
+    .insertInto('funding_idempotency_requests')
+    .values(record)
+    .onConflict((oc) => oc.columns(['apiKeyId', 'keyHash']).doNothing())
+    .returningAll()
+    .executeTakeFirst()
+  if (inserted) return { createdAt: inserted.createdAt, type: 'claimed' }
+
+  // Reclaim an expired row in place; the guard keeps two callers from both
+  // reclaiming (only one UPDATE matches the still-expired predicate).
+  const reclaimed = await db.kysely
+    .updateTable('funding_idempotency_requests')
+    .set(record)
+    .where('apiKeyId', '=', input.apiKeyId)
+    .where('keyHash', '=', input.keyHash)
+    .where('expiresAt', '<=', now.toISOString())
+    .returningAll()
+    .executeTakeFirst()
+  if (reclaimed) return { createdAt: reclaimed.createdAt, type: 'claimed' }
+
+  const existing = await db.kysely
+    .selectFrom('funding_idempotency_requests')
+    .selectAll()
+    .where('apiKeyId', '=', input.apiKeyId)
+    .where('keyHash', '=', input.keyHash)
+    .executeTakeFirst()
+  // The row vanished between the insert and the read (released claim); retry.
+  if (!existing) return claim(db, input)
+  if (existing.requestHash !== input.requestHash) return { type: 'mismatch' }
+  if (existing.status === 'pending') return { type: 'pending' }
+  if (existing.status === 'provisioned')
+    return {
+      createdAt: existing.createdAt,
+      response: existing.response ?? '',
+      type: 'resume',
+    }
+  return { response: existing.response ?? '', type: 'replay' }
+}
+
+export declare namespace claim {
+  /** Claim identity and retention. */
+  type Input = {
+    /** API key id (`key_…`) the claim is scoped to. */
+    apiKeyId: string
+    /** SHA-256 of the caller Idempotency-Key. */
+    keyHash: string
+    /** SHA-256 fingerprint of the canonical validated request. */
+    requestHash: string
+    /** Lease duration for the pending execution, in milliseconds. */
+    ttlMs: number
+  }
+
+  /** Outcome of a claim attempt. */
+  type Result =
+    | { createdAt: string; type: 'claimed' }
+    | { type: 'mismatch' }
+    | { type: 'pending' }
+    | { response: string; type: 'replay' }
+    | { createdAt: string; response: string; type: 'resume' }
+}
+
+/** Stores a provider result before committing its API resource and replay response. */
+export function checkpoint(db: Db.Db, input: checkpoint.Input): Promise<Record | undefined> {
+  const now = new Date()
+  return db.kysely
+    .updateTable('funding_idempotency_requests')
+    .set({
+      expiresAt: new Date(now.getTime() + input.replayTtlMs).toISOString(),
+      response: input.response,
+      status: 'provisioned',
+    })
+    .where('apiKeyId', '=', input.apiKeyId)
+    .where('createdAt', '=', input.createdAt)
+    .where('keyHash', '=', input.keyHash)
+    .where('status', '=', 'pending')
+    .returningAll()
+    .executeTakeFirst()
+}
+
+export declare namespace checkpoint {
+  /** Provider result and owned claim required for durable recovery. */
+  type Input = {
+    /** API key id (`key_…`) the claim is scoped to. */
+    apiKeyId: string
+    /** Creation time returned by the successful claim. */
+    createdAt: string
+    /** SHA-256 of the caller Idempotency-Key. */
+    keyHash: string
+    /** Recovery checkpoint retention in milliseconds. */
+    replayTtlMs: number
+    /** Serialized provider result required to resume resource creation. */
+    response: string
+  }
+}
+
+/** Completes an owned pending or provisioned claim with its replay response. */
+export function complete(db: Db.Db, input: complete.Input): Promise<Record | undefined> {
+  const now = new Date()
+  return db.kysely
+    .updateTable('funding_idempotency_requests')
+    .set({
+      expiresAt: new Date(now.getTime() + input.replayTtlMs).toISOString(),
+      response: input.response,
+      status: 'completed',
+      transferId: input.transferId ?? null,
+    })
+    .where('apiKeyId', '=', input.apiKeyId)
+    .where('createdAt', '=', input.createdAt)
+    .where('keyHash', '=', input.keyHash)
+    .where('status', 'in', ['pending', 'provisioned'])
+    .returningAll()
+    .executeTakeFirst()
+}
+
+export declare namespace complete {
+  /** Completion fields. */
+  type Input = {
+    /** API key id (`key_…`) the claim is scoped to. */
+    apiKeyId: string
+    /** Creation time returned by the successful claim. */
+    createdAt: string
+    /** SHA-256 of the caller Idempotency-Key. */
+    keyHash: string
+    /** Successful-response replay retention from completion, in milliseconds. */
+    replayTtlMs: number
+    /** Serialized success response replayed for the retention window. */
+    response: string
+    /** Transfer id (`ftr_…`) when the request created a funding transfer. */
+    transferId?: string | undefined
+  }
+}
+
+/** Releases a pending claim after a retryable failure. */
+export async function release(db: Db.Db, input: release.Input): Promise<void> {
+  await db.kysely
+    .deleteFrom('funding_idempotency_requests')
+    .where('apiKeyId', '=', input.apiKeyId)
+    .where('createdAt', '=', input.createdAt)
+    .where('keyHash', '=', input.keyHash)
+    .where('status', '=', 'pending')
+    .execute()
+}
+
+export declare namespace release {
+  /** Pending claim identity. */
+  type Input = {
+    /** API key id (`key_…`) the claim is scoped to. */
+    apiKeyId: string
+    /** Creation time returned by the successful claim. */
+    createdAt: string
+    /** SHA-256 of the caller Idempotency-Key. */
+    keyHash: string
+  }
+}

package/src/db/tables/fundingTransferEvents.ts

@@ -0,0 +1,28 @@
+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_events` table. */
+export type Table = db_Schema.FundingTransferEvent
+/** One immutable public snapshot at a material version. */
+export type Record = Selectable<Table>
+
+/** Inserts an event row. Callers commit it with its transfer row in one transaction. */
+export function insert(db: Db.Db, record: Record): Promise<Record> {
+  return db.kysely
+    .insertInto('funding_transfer_events')
+    .values(record)
+    .returningAll()
+    .executeTakeFirstOrThrow()
+}
+
+/** Lists a transfer's events, oldest version first. */
+export function listByTransfer(db: Db.Db, transferId: string): Promise<Record[]> {
+  return db.kysely
+    .selectFrom('funding_transfer_events')
+    .selectAll()
+    .where('transferId', '=', transferId)
+    .orderBy('version', 'asc')
+    .execute()
+}

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

@@ -0,0 +1,69 @@
+import * as TestApp from '../../../test/App.js'
+import * as TestFunding from '../../../test/Funding.js'
+import * as Transfer from '../../internal/funding/Transfer.js'
+import * as FundingTransferTransactions from './fundingTransferTransactions.js'
+
+const db = TestApp.database()
+
+function createTransfer(id: string) {
+  return Transfer.create(db, {
+    apiKeyId: 'key_test',
+    environment: 'production',
+    id,
+    orgId: 'org_test',
+    snapshot: TestFunding.transferSnapshot(),
+  })
+}
+
+describe('insert', () => {
+  test('canonicalizes EVM hashes before enforcing source uniqueness', async () => {
+    const first = await createTransfer('ftr_evm_first')
+    const second = await createTransfer('ftr_evm_second')
+    const transactionRef = `0x${'aB'.repeat(32)}`
+
+    const inserted = await FundingTransferTransactions.insert(db, {
+      chainId: 'eip155:8453',
+      createdAt: '2026-01-01T00:00:01.000Z',
+      role: 'source',
+      transactionRef,
+      transferId: first.id,
+    })
+    expect(inserted?.transactionRef).toBe(transactionRef.toLowerCase())
+
+    await expect(
+      FundingTransferTransactions.insert(db, {
+        chainId: 'eip155:8453',
+        createdAt: '2026-01-01T00:00:02.000Z',
+        role: 'source',
+        transactionRef: transactionRef.toUpperCase(),
+        transferId: second.id,
+      }),
+    ).rejects.toMatchObject({ constraint: 'funding_transfer_transactions_source_unique' })
+  })
+
+  test('preserves case-sensitive non-EVM transaction references', async () => {
+    const first = await createTransfer('ftr_solana_first')
+    const second = await createTransfer('ftr_solana_second')
+    const transactionRef = 'A'.repeat(87)
+
+    const uppercase = await FundingTransferTransactions.insert(db, {
+      chainId: 'solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp',
+      createdAt: '2026-01-01T00:00:01.000Z',
+      role: 'source',
+      transactionRef,
+      transferId: first.id,
+    })
+    const lowercase = await FundingTransferTransactions.insert(db, {
+      chainId: 'solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp',
+      createdAt: '2026-01-01T00:00:02.000Z',
+      role: 'source',
+      transactionRef: transactionRef.toLowerCase(),
+      transferId: second.id,
+    })
+
+    expect([uppercase?.transactionRef, lowercase?.transactionRef]).toEqual([
+      transactionRef,
+      transactionRef.toLowerCase(),
+    ])
+  })
+})