Fix four B2B keeper gaps found in the live sandbox tests

apps/api/src/api/services/monerium-b2b/chain.ts

@@ -129,6 +129,7 @@ export const forwarderAbi = [
     type: "function"
   },
   { inputs: [], name: "forwardAll", outputs: [], stateMutability: "nonpayable", type: "function" },
+  { inputs: [], name: "applyFeePolicy", outputs: [], stateMutability: "nonpayable", type: "function" },
   {
     inputs: [
       { name: "eureAmount", type: "uint256" },
@@ -166,7 +167,14 @@ export const forwarderAbi = [
     type: "function"
   },
   { inputs: [], name: "targetPpm", outputs: [{ name: "", type: "uint32" }], stateMutability: "view", type: "function" },
-  { inputs: [], name: "floorPpm", outputs: [{ name: "", type: "uint32" }], stateMutability: "view", type: "function" }
+  { inputs: [], name: "floorPpm", outputs: [{ name: "", type: "uint32" }], stateMutability: "view", type: "function" },
+  {
+    inputs: [],
+    name: "pendingFeePolicyEffectiveAt",
+    outputs: [{ name: "", type: "uint64" }],
+    stateMutability: "view",
+    type: "function"
+  }
 ] as const;
 
 export const factoryAbi = [
@@ -200,8 +208,19 @@ export const chainlinkAbi = parseAbi([
   "function latestRoundData() view returns (uint80 roundId, int256 answer, uint256 startedAt, uint256 updatedAt, uint80 answeredInRound)"
 ]);
 
-/** Uniswap V3 QuoterV2 on Ethereum mainnet (the pinned quoting contract, PRD §7.4). */
-export const MAINNET_QUOTER_V2: Address = "0x61fFE014bA17989E743c5F6cB21bF9697530B21e";
+/**
+ * Pinned Uniswap V3 QuoterV2 per chain id (PRD §7.4): Ethereum mainnet and the Sepolia
+ * sandbox, each on the same Uniswap v3 deployment as the chain's pools and router.
+ */
+const QUOTER_V2_BY_CHAIN_ID: Record<number, Address> = {
+  1: "0x61fFE014bA17989E743c5F6cB21bF9697530B21e",
+  11155111: "0xEd1f6473345F45b75F8179591dd5bA1888cf2FB3"
+};
+
+/** The pinned QuoterV2 for `chainId`; null on a chain without one (no quoting there). */
+export function quoterV2ForChainId(chainId: number): Address | null {
+  return QUOTER_V2_BY_CHAIN_ID[chainId] ?? null;
+}
 
 export const quoterV2Abi = parseAbi([
   "function quoteExactInput(bytes path, uint256 amountIn) returns (uint256 amountOut, uint160[] sqrtPriceX96AfterList, uint32[] initializedTicksCrossedList, uint256 gasEstimate)"
@@ -419,11 +438,11 @@ export async function readEnabledRoutes(factory: Address): Promise<Array<{ index
   return routes.filter(route => route.enabled).map(({ index, path }) => ({ index, path }));
 }
 
-/** Static QuoterV2 quote for `amountIn` over a packed path. Mainnet only (MAINNET_QUOTER_V2 pin). */
-export async function quoteRouteOutput(path: Hex, amountIn: bigint): Promise<bigint> {
+/** Static quote for `amountIn` over a packed path on `quoter` (from quoterV2ForChainId). */
+export async function quoteRouteOutput(quoter: Address, path: Hex, amountIn: bigint): Promise<bigint> {
   const { result } = await getPublicClient().simulateContract({
     abi: quoterV2Abi,
-    address: MAINNET_QUOTER_V2,
+    address: quoter,
     args: [path, amountIn],
     functionName: "quoteExactInput"
   });

apps/api/src/api/services/monerium-b2b/deposit-processor.test.ts

@@ -495,6 +495,35 @@ describe("order-event inbox processing (end to end)", () => {
     expect(await MoneriumWebhookEvent.count({ where: { processedAt: null } })).toBe(0);
   });
 
+  it("leaves a refunded deposit untouched when a later delivery carries the payer", async () => {
+    const account = await createAccount();
+    const deposit = await MoneriumFiatDeposit.create({
+      accountId: account.id,
+      amountRaw: (1005n * 10n ** 17n).toString(),
+      currency: "eur",
+      moneriumOrderId: ORDER_ID,
+      status: Refunded,
+      txHash: "0xmint"
+    });
+    const refundedAt = deposit.updatedAt;
+    await MoneriumWebhookEvent.create({
+      eventId: "evt-late-payer",
+      payload: orderEvent("processed", {
+        counterpart: {
+          details: { name: "Payer GmbH" },
+          identifier: { iban: "DE89370400440532013000", standard: "iban" }
+        }
+      })
+    });
+
+    expect(await processMoneriumWebhookInbox(PROCESSOR_DEPS)).toBe(1);
+    await deposit.reload();
+    // updated_at dates refundedAt, so a late fill would re-date the refund.
+    expect(deposit.updatedAt).toEqual(refundedAt);
+    expect(deposit.payerIban).toBeNull();
+    expect(deposit.payerName).toBeNull();
+  });
+
   it("terminally discards malformed amounts without delaying later orders", async () => {
     await createAccount();
     await MoneriumWebhookEvent.create({

apps/api/src/api/services/monerium-b2b/deposit-processor.ts

@@ -384,9 +384,11 @@ async function processInboxRow(row: MoneriumWebhookEvent, deps: DepositProcessor
         status?: MoneriumFiatDepositStatus;
         txHash?: string;
       } = {};
-      // The refund target: filled once, never overwritten by a later delivery.
-      if (event.payerIban && !existing.payerIban) updates.payerIban = event.payerIban;
-      if (event.payerName && !existing.payerName) updates.payerName = event.payerName;
+      // The refund target: filled once, never overwritten by a later delivery, and never
+      // after the refund (the write would move updated_at, which dates refundedAt).
+      const fillPayer = existing.status !== MoneriumFiatDepositStatus.Refunded;
+      if (fillPayer && event.payerIban && !existing.payerIban) updates.payerIban = event.payerIban;
+      if (fillPayer && event.payerName && !existing.payerName) updates.payerName = event.payerName;
       const alreadyPastMint = targetStatus === MoneriumFiatDepositStatus.Minted && PAST_MINT_STATUSES.includes(existing.status);
       if (targetStatus && targetStatus !== existing.status && !alreadyPastMint) {
         if (isForwardTransition(existing.status, targetStatus)) {

apps/api/src/api/services/monerium-b2b/manager-events.test.ts

@@ -17,6 +17,7 @@ import { provisionMoneriumB2bAccount } from "./account-provisioning";
 import { NOTIFY_CONFIRMATION_DEPTH } from "./chain";
 import { markDepositForRecovery } from "./conversion-executor";
 import { emitMoneriumDepositEvents, maskIban } from "./manager-events";
+import { runRecoveryOrchestrator, setDepositStatus } from "./recovery";
 
 const FORWARDER = "0x1111111111111111111111111111111111111111";
 const DESTINATION = "0x2222222222222222222222222222222222222222";
@@ -335,6 +336,89 @@ describe("monerium b2b manager events", () => {
     expect(maskIban("EE08 7224 5745 6244 9516")).toBe("EE08…9516");
   });
 
+  it("reports a refund closed by hand as refunded at its refunded transition", async () => {
+    const { mapped } = await setupAccountWithWebhook([WebhookEventType.DEPOSIT_RETURNED, WebhookEventType.DEPOSIT_UPDATED]);
+    const deposit = await MoneriumFiatDeposit.create({
+      accountId: mapped.accountId,
+      amountRaw: "500000000000000000",
+      blockNumber: 999,
+      chainId: 11155111,
+      currency: "eur",
+      logIndex: 1,
+      moneriumOrderId: "order-1",
+      payerIban: "DE89370400440532013000",
+      receivedEventAt: new Date(),
+      refundReason: "window_missed",
+      refundStartedAt: new Date(),
+      status: MoneriumFiatDepositStatus.Recovering,
+      txHash: "0xmint"
+    });
+    // The admin PATCH path: no recover execution, no MoneriumRecovery row.
+    expect(await setDepositStatus(deposit, MoneriumFiatDepositStatus.Refunded)).toBeNull();
+    await deposit.reload();
+    const refundedAt = deposit.updatedAt.toISOString();
+    await new Promise(resolve => setTimeout(resolve, 5));
+
+    await emitMoneriumDepositEvents(depsAtBlock(null));
+    await emitMoneriumDepositEvents(depsAtBlock(null));
+    const updates = (await WebhookDelivery.findAll())
+      .map(delivery => delivery.payload as unknown as { eventType: string; payload: Record<string, unknown> })
+      .filter(payload => payload.eventType === WebhookEventType.DEPOSIT_UPDATED);
+    expect(updates).toHaveLength(1);
+    expect(updates[0].payload).toMatchObject({
+      refund: { recoverTxHash: null, redeemOrderId: null, refundedAt },
+      status: "refunded"
+    });
+  });
+
+  it("dates a failed refund closed by hand at its refunded transition, not at the failure or the row's close", async () => {
+    const { mapped } = await setupAccountWithWebhook([WebhookEventType.DEPOSIT_RETURNED, WebhookEventType.DEPOSIT_UPDATED]);
+    const deposit = await MoneriumFiatDeposit.create({
+      accountId: mapped.accountId,
+      amountRaw: "500000000000000000",
+      blockNumber: 999,
+      chainId: 11155111,
+      currency: "eur",
+      logIndex: 1,
+      moneriumOrderId: "order-1",
+      payerIban: "DE89370400440532013000",
+      receivedEventAt: new Date(),
+      refundReason: "window_missed",
+      refundStartedAt: new Date(),
+      status: MoneriumFiatDepositStatus.RecoveryFailed,
+      txHash: "0xmint"
+    });
+    // The orchestrator parked the refund at topping_up: the row's last write is the failure.
+    const recovery = await MoneriumRecovery.create({
+      depositId: deposit.id,
+      error: "float top-up reverted",
+      eureRecoveredRaw: deposit.amountRaw,
+      phase: MoneriumRecoveryPhase.ToppingUp,
+      usdcRecoveredRaw: "0"
+    });
+    await new Promise(resolve => setTimeout(resolve, 5));
+    // The operator refunds by hand and closes it through the admin PATCH (recovery_failed -> refunded).
+    expect(await setDepositStatus(deposit, MoneriumFiatDepositStatus.Refunded)).toBeNull();
+    await deposit.reload();
+    expect(deposit.updatedAt.getTime()).toBeGreaterThan(recovery.updatedAt.getTime());
+    await new Promise(resolve => setTimeout(resolve, 5));
+    // The next keeper cycle closes the parked row before the events run.
+    await runRecoveryOrchestrator(() => Promise.reject(new Error("a refunded head never needs deps")));
+    await recovery.reload();
+    expect(recovery.phase).toBe(MoneriumRecoveryPhase.Redeemed);
+    expect(recovery.updatedAt.getTime()).toBeGreaterThan(deposit.updatedAt.getTime());
+
+    await emitMoneriumDepositEvents(depsAtBlock(null));
+    const updates = (await WebhookDelivery.findAll())
+      .map(delivery => delivery.payload as unknown as { eventType: string; payload: Record<string, unknown> })
+      .filter(payload => payload.eventType === WebhookEventType.DEPOSIT_UPDATED);
+    expect(updates).toHaveLength(1);
+    expect(updates[0].payload).toMatchObject({
+      refund: { refundedAt: deposit.updatedAt.toISOString() },
+      status: "refunded"
+    });
+  });
+
   it("only enqueues to the controlling manager's webhooks", async () => {
     const { mapped } = await setupAccountWithWebhook([WebhookEventType.DEPOSIT_RECEIVED]);
     const otherManager = await createTestUser();

apps/api/src/api/services/monerium-b2b/manager-events.ts

@@ -177,7 +177,10 @@ export async function depositSnapshots(
               reason: deposit.refundReason as DepositRefundReason | null,
               recoverTxHash: recover?.txHash ?? null,
               redeemOrderId: recovery?.redeemOrderId ?? null,
-              refundedAt: deposit.status === MoneriumFiatDepositStatus.Refunded ? iso(recovery?.updatedAt) : null,
+              // Dated by the deposit's refunded transition, its last write (the received/returned markers
+              // are silent, the status is terminal): the orchestrator closes the recovery row after it, or
+              // a cycle later for a refund closed by hand, so that row's time would drift between snapshots.
+              refundedAt: deposit.status === MoneriumFiatDepositStatus.Refunded ? iso(deposit.updatedAt) : null,
               startedAt: iso(deposit.refundStartedAt)
             }
           : null,
@@ -240,7 +243,8 @@ async function emitReceivedEvents(): Promise<void> {
       // Marked emitted even with zero subscribers: webhooks are forward-looking, a
       // later registration must not receive the whole history. A crash between the
       // enqueue and this marker is absorbed by the outbox (webhook_id, event_id) dedup.
-      await deposit.update({ receivedEventAt: new Date() });
+      // Silent: updated_at dates a refunded deposit's refundedAt.
+      await deposit.update({ receivedEventAt: new Date() }, { silent: true });
     } catch (error) {
       // Per-deposit isolation: one failing deposit must not block its siblings.
       logger.error(`monerium-b2b: DEPOSIT_RECEIVED emission failed for deposit ${deposit.id}:`, error);
@@ -351,7 +355,8 @@ async function emitReturnedEvents(): Promise<void> {
         timestamp: new Date().toISOString()
       };
       await enqueueForManager(WebhookEventType.DEPOSIT_RETURNED, managerProfileId, payload);
-      await deposit.update({ returnedEventAt: new Date() });
+      // Silent: updated_at stays the refunded transition, which dates refundedAt.
+      await deposit.update({ returnedEventAt: new Date() }, { silent: true });
     } catch (error) {
       logger.error(`monerium-b2b: DEPOSIT_RETURNED emission failed for deposit ${deposit.id}:`, error);
     }