tapimo 0.9.0 → 0.10.1

package/src/internal/Webhooks.ts

@@ -3,6 +3,7 @@ import { Hash, Hex } from 'ox'
 import type * as app_Webhooks from '../apps/data/routes/webhooks.js'
 import type * as Db from '../db/Db.js'
 import * as WebhookDeliveries from '../db/tables/webhookDeliveries.js'
+import * as WebhookQueueEvents from '../db/tables/webhookQueueEvents.js'
 import * as WebhookSubscriptions from '../db/tables/webhookSubscriptions.js'
 import type * as Metrics from '../Metrics.js'
 import * as Cursor from './Cursor.js'
@@ -326,9 +327,59 @@ export async function listActive(
   chainId: number,
   eventType: EventType,
 ): Promise<Subscription[]> {
+  const pairs = await listActiveWithCursors(db, chainId, eventType)
+  return pairs.map((pair) => pair.subscription)
+}
+
+/**
+ * Lists a stream's live active subscriptions paired with their poller cursors,
+ * from one query. The poller's per-tick lookup.
+ */
+export async function listActiveWithCursors(
+  db: Db.Db,
+  chainId: number,
+  eventType: EventType,
+): Promise<{ cursor: string | null; subscription: Subscription }[]> {
   return WebhookSubscriptions.listActive(db, chainId, eventType, new Date().toISOString())
 }
 
+/** Reads every live active subscription on a chain in one poller query. */
+export async function listActiveForChain(
+  db: Db.Db,
+  options: listActiveForChain.Options,
+): Promise<{ cursor: string | null; subscription: Subscription }[]> {
+  return WebhookSubscriptions.listActiveForChain(db, {
+    chainId: options.chainId,
+    eventTypes: options.eventTypes,
+    now: new Date().toISOString(),
+  })
+}
+
+export declare namespace listActiveForChain {
+  /** Filters for the poller's chain-level subscription read. */
+  type Options = Pick<WebhookSubscriptions.listActiveForChain.Options, 'chainId' | 'eventTypes'>
+}
+
+/**
+ * Reads the freshest cursor block across a chain's active subscriptions, or
+ * null when none carry a cursor. Creation checkpoints count at their recorded
+ * head, so a brand-new subscription reads as fresh.
+ */
+export async function maxCursorBlock(db: Db.Db, chainId: number): Promise<number | null> {
+  const cursors = await WebhookSubscriptions.listActiveCursors(
+    db,
+    chainId,
+    new Date().toISOString(),
+  )
+  let max: number | null = null
+  for (const cursor of cursors) {
+    const decoded = Cursor.decode(cursor, ['int', 'int']) ?? Cursor.decode(cursor, ['int'])
+    const block = decoded?.[0]
+    if (typeof block === 'number' && (max === null || block > max)) max = block
+  }
+  return max
+}
+
 /** Reads a subscription's keyset cursor. Returns null when unset. */
 export async function getCursor(db: Db.Db, subscriptionId: string): Promise<string | null> {
   return WebhookSubscriptions.getCursor(db, subscriptionId)
@@ -347,6 +398,19 @@ export declare namespace compareAndSetCursor {
   type Options = WebhookSubscriptions.compareAndSetCursor.Options
 }
 
+/** Writes cursors whose stored values match their expected cursors. */
+export async function compareAndSetCursors(
+  db: Db.Db,
+  options: compareAndSetCursors.Options,
+): Promise<Set<string>> {
+  return WebhookSubscriptions.compareAndSetCursors(db, options)
+}
+
+export declare namespace compareAndSetCursors {
+  /** Options for {@link compareAndSetCursors}. */
+  type Options = WebhookSubscriptions.compareAndSetCursors.Options
+}
+
 /** Writes a subscription's keyset cursor. */
 export async function setCursor(db: Db.Db, subscriptionId: string, cursor: string): Promise<void> {
   await WebhookSubscriptions.setCursor(db, subscriptionId, cursor)
@@ -360,6 +424,7 @@ export async function setCursor(db: Db.Db, subscriptionId: string, cursor: strin
 export async function pruneExpired(db: Db.Db, options: pruneExpired.Options = {}): Promise<void> {
   const iso = (options.now ?? (() => new Date()))().toISOString()
   await WebhookDeliveries.pruneExpired(db, iso)
+  await WebhookQueueEvents.pruneExpired(db, iso)
   await WebhookSubscriptions.pruneExpired(db, iso)
 }
 
@@ -377,6 +442,263 @@ export declare namespace pruneExpired {
  */
 export const deliveryRetentionMs = 7 * 24 * 60 * 60 * 1_000
 
+/** A compact Cloudflare Queue message referencing a durable staged envelope. */
+export type QueueReference = {
+  /** Idempotent event id of the staged envelope. */
+  eventId: string
+  /** Subscription that owns the staged envelope. */
+  subscriptionId: string
+}
+
+/** A full envelope staged outside Cloudflare Queues. */
+export type QueueEvent = QueueReference & {
+  /** ISO timestamp when the envelope was staged. */
+  createdAt: string
+  /** Full envelope loaded by the Queue consumer. */
+  envelope: Envelope
+  /** ISO timestamp after which an unconsumed envelope may be pruned. */
+  expiresAt: string
+}
+
+/** A claim newer than this counts as an in-flight attempt; above the 10s destination timeout default. */
+export const deliveryAttemptStaleMs = 60_000
+
+/**
+ * Retry backoff by attempt count: 5s, 25s, ~2m, ~10m, ~52m, then hourly.
+ * Endpoint outages retry on this schedule until delivery or auto-disable.
+ */
+export function retryDelayMs(attemptCount: number): number {
+  return Math.min(5_000 * 5 ** Math.max(0, attemptCount - 1), 3_600_000)
+}
+
+/**
+ * Stages full envelopes as delivery obligations and returns compact
+ * references safe for Queue admission. Existing rows are left untouched, so
+ * the first staged envelope wins and terminal outcomes never resurrect.
+ */
+export async function ensureQueueEvents(
+  db: Db.Db,
+  dispatchables: readonly ensureQueueEvents.Dispatchable[],
+  options: ensureQueueEvents.Options = {},
+): Promise<ensureQueueEvents.Result> {
+  const now = (options.now ?? (() => new Date()))()
+  const expiresAt = new Date(now.getTime() + (options.ttl ?? deliveryRetentionMs)).toISOString()
+  const events = dispatchables.map(({ envelope, subscription }) => ({
+    createdAt: now.toISOString(),
+    envelope,
+    eventId: envelope.id,
+    // Inert while pending; the meaningful dedupe deadline is stamped at
+    // terminal transitions.
+    expiresAt,
+    // Due immediately; the value orders the sweep so it is never null here.
+    nextAttemptAt: now.toISOString(),
+    subscriptionId: subscription.id,
+  }))
+  return {
+    created: await WebhookQueueEvents.ensure(db, events),
+    references: events.map(({ eventId, subscriptionId }) => ({ eventId, subscriptionId })),
+  }
+}
+
+export declare namespace ensureQueueEvents {
+  /** One full envelope and the subscription that produced it. */
+  type Dispatchable = {
+    /** Webhook envelope. */
+    envelope: Envelope
+    /** Subscription that owns the envelope. */
+    subscription: Subscription
+  }
+
+  /** Staged-envelope retention options. */
+  type Options = {
+    /** Clock used for staging timestamps. */
+    now?: (() => Date) | undefined
+    /** Staged-envelope TTL in ms; defaults to {@link deliveryRetentionMs}. */
+    ttl?: number | undefined
+  }
+
+  /** Created-row count plus references for every requested obligation. */
+  type Result = {
+    /** Newly staged obligations. */
+    created: number
+    /** Compact references for all inputs, including pre-existing rows. */
+    references: QueueReference[]
+  }
+}
+
+/** Claims one due pending obligation; misses classify why the claim is unavailable. */
+export function claimQueueEvent(
+  db: Db.Db,
+  reference: QueueReference,
+): Promise<WebhookQueueEvents.claim.Result> {
+  const now = new Date()
+  return WebhookQueueEvents.claim(db, reference, {
+    now: now.toISOString(),
+    staleBefore: new Date(now.getTime() - deliveryAttemptStaleMs).toISOString(),
+  })
+}
+
+/**
+ * Marks a claimed obligation terminal and restarts its retention window, so
+ * the dedupe row outlives replays. Fenced by the claim marker: a stale
+ * claimant's completion returns false instead of clobbering a newer claim.
+ */
+export function completeQueueEvent(
+  db: Db.Db,
+  reference: QueueReference,
+  options: completeQueueEvent.Options,
+): Promise<boolean> {
+  return WebhookQueueEvents.complete(db, reference, {
+    ...options,
+    expiresAt: new Date(Date.now() + deliveryRetentionMs).toISOString(),
+  })
+}
+
+export declare namespace completeQueueEvent {
+  /** Fenced terminal transition. */
+  type Options = {
+    /** Claim marker from the claimed record's `attemptingAt`. */
+    claimedAt: string
+    /** Terminal obligation outcome. */
+    status: WebhookQueueEvents.TerminalStatus
+  }
+}
+
+/**
+ * Releases a claim and schedules the next attempt on the retry backoff.
+ * Fenced by the claim marker like {@link completeQueueEvent}.
+ */
+export function scheduleQueueEventRetry(
+  db: Db.Db,
+  reference: QueueReference,
+  options: scheduleQueueEventRetry.Options,
+): Promise<boolean> {
+  return WebhookQueueEvents.schedule(db, reference, {
+    claimedAt: options.claimedAt,
+    nextAttemptAt: new Date(Date.now() + retryDelayMs(options.attemptCount)).toISOString(),
+  })
+}
+
+export declare namespace scheduleQueueEventRetry {
+  /** Fenced retry scheduling. */
+  type Options = {
+    /** Attempts claimed so far; drives the backoff position. */
+    attemptCount: number
+    /** Claim marker from the claimed record's `attemptingAt`. */
+    claimedAt: string
+  }
+}
+
+/** Lists due pending references for the sweeper, oldest first. */
+export function dueQueueEvents(db: Db.Db, limit: number): Promise<QueueReference[]> {
+  const now = new Date()
+  return WebhookQueueEvents.due(db, {
+    limit,
+    now: now.toISOString(),
+    staleBefore: new Date(now.getTime() - deliveryAttemptStaleMs).toISOString(),
+  })
+}
+
+/** Returns the authoritative pending-obligation snapshot. */
+export function pendingQueueEvents(db: Db.Db): Promise<WebhookQueueEvents.pending.Result> {
+  const now = new Date()
+  return WebhookQueueEvents.pending(db, {
+    now: now.toISOString(),
+    staleBefore: new Date(now.getTime() - deliveryAttemptStaleMs).toISOString(),
+  })
+}
+
+/** Reads a full staged envelope for a compact Queue reference. */
+export async function getQueueEvent(
+  db: Db.Db,
+  reference: QueueReference,
+): Promise<QueueEvent | null> {
+  return WebhookQueueEvents.get(db, reference)
+}
+
+/** Loads a staged envelope and delivers it with the subscription's current configuration. */
+export async function deliverQueueEventAndRecord(
+  db: Db.Db,
+  reference: QueueReference,
+  options: deliverAndRecord.Options = {},
+): Promise<deliverQueueEventAndRecord.Result> {
+  const dequeuedAt = Date.now()
+  const event = await getQueueEvent(db, reference)
+  if (!event) return { status: 'missing' }
+  return deliverClaimedAndRecord(db, event, { ...options, dequeuedAt })
+}
+
+/**
+ * Delivers an already-loaded obligation envelope with the subscription's
+ * current configuration, skipping the staged-row read a claim already paid.
+ */
+export async function deliverClaimedAndRecord(
+  db: Db.Db,
+  claimed: deliverClaimedAndRecord.Claimed,
+  options: deliverClaimedAndRecord.Options = {},
+): Promise<deliverClaimedAndRecord.Result> {
+  const dequeuedAt = options.dequeuedAt ?? Date.now()
+  const subscriptionReadStartedAt = Date.now()
+  const subscription = await WebhookSubscriptions.getById(
+    db,
+    claimed.subscriptionId,
+    new Date().toISOString(),
+  )
+  if (!subscription || subscription.status !== 'active') return { status: 'skipped' }
+  return {
+    result: await deliverAndRecord(db, subscription, claimed.envelope, {
+      ...options,
+      dequeuedAt,
+      subscriptionReadMs: Date.now() - subscriptionReadStartedAt,
+    }),
+    status: 'delivered',
+  }
+}
+
+export declare namespace deliverClaimedAndRecord {
+  /** Envelope and owning subscription id from a claimed obligation. */
+  type Claimed = {
+    /** Immutable event envelope to deliver. */
+    envelope: Envelope
+    /** Subscription re-resolved for current status and secret. */
+    subscriptionId: string
+  }
+
+  /** Delivery options plus the dequeue timestamp of the claiming path. */
+  type Options = deliverAndRecord.Options & {
+    /** Epoch ms the claiming message was dequeued; defaults to now. */
+    dequeuedAt?: number | undefined
+  }
+
+  /** A delivered event or an inactive subscription. */
+  type Result =
+    | {
+        /** Transport result from the current subscription state. */
+        result: WebhookDestination.Result
+        /** The envelope was delivered. */
+        status: 'delivered'
+      }
+    | {
+        /** The current subscription is inactive or deleted. */
+        status: 'skipped'
+      }
+}
+
+export declare namespace deliverQueueEventAndRecord {
+  /** A delivered event, inactive subscription, or stale duplicate reference. */
+  type Result =
+    | {
+        /** Transport result from the current subscription state. */
+        result: WebhookDestination.Result
+        /** The staged event was delivered. */
+        status: 'delivered'
+      }
+    | {
+        /** The staged event or current subscription was not deliverable. */
+        status: 'missing' | 'skipped'
+      }
+}
+
 /** Records one delivery-log row (stateful, owner-agnostic; scoped per subscription). */
 export async function recordDelivery(
   db: Db.Db,
@@ -522,35 +844,31 @@ export async function deliverAndRecord(
   envelope: Envelope,
   options: deliverAndRecord.Options = {},
 ): Promise<WebhookDestination.Result> {
+  const startedAt = Date.now()
   // Snapshot the attempt before recordSuccess/recordFailure mutate the counter.
-  const attempt = subscription.failureCount + 1
-  const result = await WebhookDestination.from(subscription.destination).deliver({
-    envelope,
-    secret: subscription.secret,
-    ...(options.fetch === undefined ? {} : { fetch: options.fetch }),
-    ...(options.timeoutMs === undefined ? {} : { timeoutMs: options.timeoutMs }),
-  })
+  const attempt = options.attempt ?? subscription.failureCount + 1
+  const result = await (async () => {
+    try {
+      return await WebhookDestination.from(subscription.destination).deliver({
+        envelope,
+        secret: subscription.secret,
+        ...(options.fetch === undefined ? {} : { fetch: options.fetch }),
+        ...(options.timeoutMs === undefined ? {} : { timeoutMs: options.timeoutMs }),
+      })
+    } catch {
+      // A formatting failure is a failed attempt, not an exception that bypasses
+      // subscription failure state and delivery metrics on every queue retry.
+      return { error: 'delivery failed before request', ok: false }
+    }
+  })()
+  const stateWriteStartedAt = Date.now()
   if (result.ok) await recordSuccess(db, subscription, options)
   else await recordFailure(db, subscription, options)
-
-  // Emit a `webhook:delivery` metric. recordSuccess/recordFailure are immutable
-  // (they spread into a new record), so `subscription.failureCount` here is still
-  // the pre-mutation snapshot the sink needs to derive the attempt bucket.
-  // Best-effort, like delivery logging.
-  const metrics = options.metrics ? MetricSink.webhooks(options.metrics) : undefined
-  if (metrics) {
-    metrics.record({
-      envelope,
-      result,
-      subscription,
-      trigger: options.trigger ?? 'queue',
-      type: 'webhook:delivery',
-    })
-    metrics.flush()
-  }
+  const stateWriteMs = Date.now() - stateWriteStartedAt
 
   // Append a delivery-log row. Best-effort: a logging failure must never change
   // the delivery outcome the caller (Queue consumer / inline path) acts on.
+  const deliveryLogStartedAt = Date.now()
   try {
     await recordDelivery(
       db,
@@ -560,15 +878,73 @@ export async function deliverAndRecord(
   } catch {
     // delivery logging is best-effort
   }
+  const completedAt = Date.now()
+
+  // Emit after all delivery work so the timings cover every stage. The
+  // subscription is immutable, preserving the pre-attempt failure count.
+  const metrics = options.metrics ? MetricSink.webhooks(options.metrics) : undefined
+  if (metrics) {
+    const eventAt = eventTimestamp(envelope)
+    const envelopeAt = Date.parse(envelope.createdAt)
+    const dequeuedAt = options.dequeuedAt ?? startedAt
+    metrics.record({
+      envelope,
+      queueAttempt: options.queueAttempt,
+      result,
+      subscription,
+      attempt,
+      timings: {
+        deliveryLogMs: completedAt - deliveryLogStartedAt,
+        envelopeToQueueMs:
+          options.queuedAt === undefined || Number.isNaN(envelopeAt)
+            ? undefined
+            : Math.max(0, options.queuedAt - envelopeAt),
+        endToEndMs: eventAt === undefined ? undefined : Math.max(0, completedAt - eventAt),
+        eventToEnvelopeMs:
+          eventAt === undefined || Number.isNaN(envelopeAt)
+            ? undefined
+            : Math.max(0, envelopeAt - eventAt),
+        processingMs: Math.max(0, completedAt - dequeuedAt),
+        queueWaitMs:
+          options.queuedAt === undefined ? undefined : Math.max(0, dequeuedAt - options.queuedAt),
+        stateWriteMs,
+        subscriptionReadMs: options.subscriptionReadMs,
+      },
+      trigger: options.trigger ?? 'queue',
+      type: 'webhook:delivery',
+    })
+    metrics.flush()
+  }
 
   return result
 }
 
+/** Reads an event timestamp from an envelope, falling back to its creation time. */
+function eventTimestamp(envelope: Envelope): number | undefined {
+  const value =
+    typeof envelope.data === 'object' &&
+    envelope.data !== null &&
+    'timestamp' in envelope.data &&
+    typeof envelope.data.timestamp === 'string'
+      ? envelope.data.timestamp
+      : envelope.createdAt
+  const timestamp = Date.parse(value)
+  return Number.isNaN(timestamp) ? undefined : timestamp
+}
+
 export declare namespace deliverAndRecord {
   /** Options for {@link deliverAndRecord}. */
   type Options = {
+    /**
+     * Delivery-log attempt number; the ledger claim count on the queue path.
+     * Defaults to the subscription failure counter, which concurrent
+     * deliveries can read stale.
+     */
+    attempt?: number | undefined
     /** Delivery-log row TTL in ms; defaults to {@link deliveryRetentionMs}. */
     deliveryRetentionMs?: number | undefined
+    /** Queue dequeue time as epoch milliseconds, captured before subscription lookup. */
+    dequeuedAt?: number | undefined
     /** `fetch` implementation passed through to {@link deliver}. */
     fetch?: typeof globalThis.fetch | undefined
     /** Consecutive failures before auto-disabling (default {@link maxFailures}). */
@@ -577,6 +953,12 @@ export declare namespace deliverAndRecord {
     metrics?: Metrics.Metrics | undefined
     /** Clock used for timestamps; injectable for tests. */
     now?: (() => Date) | undefined
+    /** Cloudflare Queue delivery attempt, starting at one; absent for inline delivery paths. */
+    queueAttempt?: number | undefined
+    /** Queue enqueue time as epoch milliseconds, used to isolate queue wait. */
+    queuedAt?: number | undefined
+    /** Authoritative subscription lookup duration, supplied by the queue path. */
+    subscriptionReadMs?: number | undefined
     /** Delivery timeout in ms passed through to {@link deliver}. */
     timeoutMs?: number | undefined
     /** Where this attempt originated; tags the `webhook:delivery` event (default `queue`). */
@@ -594,10 +976,16 @@ export async function deliverCurrentAndRecord(
   envelope: Envelope,
   options: deliverAndRecord.Options = {},
 ): Promise<deliverCurrentAndRecord.Result> {
+  const dequeuedAt = Date.now()
+  const subscriptionReadStartedAt = dequeuedAt
   const subscription = await getSubscription(db, queued.owner, queued.id)
   if (!subscription || subscription.status !== 'active') return { status: 'skipped' }
   return {
-    result: await deliverAndRecord(db, subscription, envelope, options),
+    result: await deliverAndRecord(db, subscription, envelope, {
+      ...options,
+      dequeuedAt,
+      subscriptionReadMs: Date.now() - subscriptionReadStartedAt,
+    }),
     status: 'delivered',
   }
 }

package/src/internal/funding/Provider.test.ts

@@ -13,7 +13,7 @@ const providers = [
     integratorId: '0xdead',
     userAddress: '0x1111111111111111111111111111111111111111',
   }),
-  Relay.relay({ userAddress: '0x1111111111111111111111111111111111111111' }),
+  Relay.relay({ userAddresses: TestFunding.relayQuoteUsers }),
   Rhino.rhino(),
   Squid.squid({
     integratorId: 'squid-integrator-id',
@@ -286,6 +286,38 @@ describe('getQuotes', () => {
     },
   )
 
+  test('allows provider quotes within the default deadline', async () => {
+    vi.useFakeTimers()
+    try {
+      const quotes = FundingProvider.getQuotes({
+        ...baseUsdcRequest,
+        providers: [
+          withGetQuote(
+            'relay',
+            () =>
+              new Promise((resolve) => {
+                setTimeout(
+                  () =>
+                    resolve({
+                      destinationAmount: '990000',
+                      sampledAt: '2026-01-01T00:00:00Z',
+                      status: 'available',
+                    }),
+                  3_000,
+                )
+              }),
+          ),
+        ],
+      })
+
+      await vi.advanceTimersByTimeAsync(3_000)
+
+      await expect(quotes).resolves.toHaveLength(1)
+    } finally {
+      vi.useRealTimers()
+    }
+  })
+
   test('aborts providers that exceed the quote deadline', async () => {
     const attempts: FundingProvider.ProviderAttempt[] = []
     let aborted = false
@@ -730,26 +762,34 @@ describe('prepareTransfer', () => {
     })
   })
 
-  test('rounds the slippage floor upward', async () => {
+  test('enforces provider-style slippage rounding', async () => {
+    const inputs: FundingProvider.prepareTransfer.Parameters[] = []
     const prepare = (destinationAmountMin: string) =>
       FundingProvider.prepareTransfer({
         ...prepareOptions,
         providers: [
-          withPrepareTransfer('relay', async () => ({
-            ...preparedResult(),
-            destinationAmount: '10001',
-            destinationAmountMin,
-          })),
+          withPrepareTransfer('relay', async (input) => {
+            inputs.push(input)
+            return {
+              ...preparedResult(),
+              destinationAmount: '10001',
+              destinationAmountMin,
+            }
+          }),
         ],
         slippageBps: 1,
       })
 
-    await expect(prepare('9999')).rejects.toMatchObject({
+    await expect(prepare('9998')).rejects.toMatchObject({
       providerFailure: { failure: 'payload', id: 'relay', operation: 'prepareTransfer' },
     })
+    await expect(prepare('9999')).resolves.toMatchObject({
+      result: { destinationAmount: '10001', destinationAmountMin: '9999' },
+    })
     await expect(prepare('10000')).resolves.toMatchObject({
       result: { destinationAmount: '10001', destinationAmountMin: '10000' },
     })
+    expect(inputs.map((input) => input.slippageBps)).toEqual([1, 1, 1])
   })
 
   test.each([

package/src/internal/funding/Provider.ts

@@ -250,6 +250,8 @@ export namespace schema {
     destinationTransactionHashes: z.array(z.string()),
     id: z.string().check(z.minLength(1)),
     providerState: z.optional(z.record(z.string(), z.unknown())),
+    refundAmountExpected: z.optional(z.string().check(z.regex(/^\d+$/))),
+    refundTransactionHashes: z.array(z.string()),
     sourceTransactionHashes: z.array(z.string()),
     status: z.string().check(z.minLength(1)),
     updatedAt: z.iso.datetime(),
@@ -773,7 +775,9 @@ export type ProviderFailure = {
   provider: Provider
 }
 
-const defaultTimeoutMs = 2_000
+// Slow provider responses can still contain valid quotes; keep the boundary
+// above observed Relay latency while bounding the total request duration.
+const defaultQuoteTimeoutMs = 5_000
 
 /** Returns normalized chains and source tokens supported by quote providers. */
 export function getChains(options: getChains.Options) {
@@ -847,7 +851,7 @@ export async function getQuotes(options: getQuotes.Options) {
             sourceChain: options.sourceChain,
             sourceToken: options.sourceToken,
           },
-          timeoutMs: options.providerTimeoutMs ?? defaultTimeoutMs,
+          timeoutMs: options.providerTimeoutMs ?? defaultQuoteTimeoutMs,
         })
         attempts.set(index, {
           durationMs: performance.now() - start,
@@ -1123,13 +1127,14 @@ export async function prepareTransfer(
         if (Date.parse(expiresAt) <= Date.now()) throw new ProviderPayloadError()
         if (BigInt(result.destinationAmountMin) > BigInt(result.destinationAmount))
           throw new ProviderPayloadError()
-        // A provider that ignores the caller's slippage bound is unusable for
-        // this request; enforce the bound against the quoted minimum.
+        // Providers may floor slippage-adjusted amounts to whole base units;
+        // reject only minima below that allowed rounding.
         if (options.slippageBps !== undefined) {
           const basisPointScale = 10_000n
-          const numerator = BigInt(result.destinationAmount) * BigInt(10_000 - options.slippageBps)
-          const floor = (numerator + basisPointScale - 1n) / basisPointScale
-          if (BigInt(result.destinationAmountMin) < floor) throw new ProviderPayloadError()
+          const minimumAllowed =
+            (BigInt(result.destinationAmount) * BigInt(10_000 - options.slippageBps)) /
+            basisPointScale
+          if (BigInt(result.destinationAmountMin) < minimumAllowed) throw new ProviderPayloadError()
         }
         if (result.action.type === 'evm:calls')
           try {

package/src/internal/funding/Reconciliation.local.test.ts

@@ -17,7 +17,6 @@ import * as Evidence from './Evidence.js'
 import * as Reconciliation from './Reconciliation.js'
 import * as Subsidy from './Subsidy.js'
 
-const db = TestApp.database()
 const runtime = Runtime.get()
 const chain = {
   addressFormat: 'hex',
@@ -28,6 +27,8 @@ const chain = {
 
 describe.skipIf(runtime.mode !== 'localnet')('reconcileRequest', () => {
   test('settles an underfilled deposit through the native DEX', async () => {
+    // Vitest retries reuse module state, so each attempt needs a fresh database.
+    const db = TestApp.database()
     const destinationTokenAddress = runtime.fixtures?.crossTokenTransfer?.destinationToken
     if (!destinationTokenAddress) throw new Error('Expected a seeded local DEX pair.')
     const rpcUrl = runtime.rpcUrl
@@ -120,6 +121,7 @@ describe.skipIf(runtime.mode !== 'localnet')('reconcileRequest', () => {
       createdAt: new Date().toISOString(),
       destinationTransactionHashes: [destinationReceipt.receipt.transactionHash],
       id: 'local-deposit-request',
+      refundTransactionHashes: [],
       sourceTransactionHashes: [sourceReceipt.receipt.transactionHash],
       status: 'success',
       updatedAt: new Date().toISOString(),