Reference-priced forwarder swaps with whole-deposit settlement and an automatic refund path

apps/api/src/api/controllers/admin/moneriumB2b.controller.test.ts

@@ -5,19 +5,23 @@ import KycCase from "../../../models/kycCase.model";
 import ManagedProfile from "../../../models/managedProfile.model";
 import ManagedProfileManager from "../../../models/managedProfileManager.model";
 import MoneriumAccount, { MoneriumAccountStatus } from "../../../models/moneriumAccount.model";
+import MoneriumConversionExecution, {
+  MoneriumConversionExecutionStatus
+} from "../../../models/moneriumConversionExecution.model";
+import MoneriumFiatDeposit, { MoneriumFiatDepositStatus } from "../../../models/moneriumFiatDeposit.model";
 import ProviderCustomer, { VerificationStatus } from "../../../models/providerCustomer.model";
 import User from "../../../models/user.model";
 import { resetTestDatabase, setupTestDatabase } from "../../../test-utils/db";
 import { createTestUser } from "../../../test-utils/factories";
 import moneriumB2bRoutes from "../../routes/v1/admin/monerium-b2b.route";
 import { forwarderConfigMismatch } from "../../services/monerium-b2b/account-provisioning";
+import { refundAccountFor } from "../../services/monerium-b2b/refund-wallet";
 
 const BASE_PATH = "/v1/admin/monerium-b2b";
 const ADMIN_HEADERS = { Authorization: "Bearer test-admin-secret", "Content-Type": "application/json" };
 
 const FORWARDER = "0x1111111111111111111111111111111111111111";
 const DESTINATION = "0x2222222222222222222222222222222222222222";
-const FALLBACK = "0x3333333333333333333333333333333333333333";
 const FACTORY = "0x4444444444444444444444444444444444444444";
 
 describe("monerium b2b account mapping admin route", () => {
@@ -68,7 +72,6 @@ describe("monerium b2b account mapping admin route", () => {
       contactEmail: "ops@client.example.com",
       destination: DESTINATION,
       externalSubjectId: "client-1",
-      fallbackAddress: FALLBACK,
       forwarderAddress: FORWARDER,
       managerProfileId,
       moneriumProfileId: "0b8e7c2a-8f4e-4d43-9f2b-2f9f3c1d5a6e",
@@ -122,9 +125,9 @@ describe("monerium b2b account mapping admin route", () => {
     const row = await MoneriumAccount.findByPk(account.accountId);
     expect(row).toMatchObject({
       destination: DESTINATION,
-      fallbackAddress: FALLBACK,
-      feeBps: 0,
+      floorPpm: 1500,
       forwarderAddress: FORWARDER,
+      targetPpm: 1250,
       vortexProfileId: account.profileId
     });
   });
@@ -149,8 +152,6 @@ describe("monerium b2b account mapping admin route", () => {
     const managerProfileId = await createManager();
     await MoneriumAccount.create({
       destination: DESTINATION,
-      fallbackAddress: FALLBACK,
-      feeBps: 0,
       forwarderAddress: FORWARDER,
       profileId: "0b8e7c2a-8f4e-4d43-9f2b-2f9f3c1d5a6e"
     });
@@ -191,8 +192,8 @@ describe("monerium b2b account mapping admin route", () => {
     );
     expect(differentSubject.status).toBe(409);
 
-    // Same everything, different feeBps: divergence, not a silent idempotent replay.
-    const differentFee = await post(validBody(managerProfileId, { feeBps: 25 }));
+    // Same everything, different fee policy: divergence, not a silent idempotent replay.
+    const differentFee = await post(validBody(managerProfileId, { targetPpm: 1_000 }));
     expect(differentFee.status).toBe(409);
 
     expect(await MoneriumAccount.count()).toBe(1);
@@ -203,20 +204,51 @@ describe("monerium b2b account mapping admin route", () => {
   });
 
   it("compares submitted account data against the deployed clone config", () => {
+    const refundWallet = "0x9999999999999999999999999999999999999999";
     const expected = {
       destination: DESTINATION.toLowerCase(),
       factory: FACTORY.toLowerCase(),
-      fallbackAddress: FALLBACK.toLowerCase(),
-      feeBps: 0
+      floorPpm: 1500,
+      recoveryAddress: refundWallet,
+      targetPpm: 1250
+    };
+    const matching = {
+      destination: DESTINATION,
+      factory: FACTORY,
+      floorPpm: 1500,
+      isForwarder: true,
+      recoveryAddress: refundWallet,
+      targetPpm: 1250
     };
-    const matching = { destination: DESTINATION, factory: FACTORY, fallbackAddress: FALLBACK, feeBps: 0, isForwarder: true };
 
     expect(forwarderConfigMismatch(expected, matching)).toBeNull();
     expect(forwarderConfigMismatch(expected, { ...matching, factory: FORWARDER })).toContain("trusted factory");
     expect(forwarderConfigMismatch(expected, { ...matching, isForwarder: false })).toContain("not a clone");
-    expect(forwarderConfigMismatch(expected, { ...matching, destination: FALLBACK })).toContain("destination");
-    expect(forwarderConfigMismatch(expected, { ...matching, fallbackAddress: DESTINATION })).toContain("fallbackAddress");
-    expect(forwarderConfigMismatch(expected, { ...matching, feeBps: 30 })).toContain("feeBps");
+    expect(
+      forwarderConfigMismatch(expected, { ...matching, destination: "0x3333333333333333333333333333333333333333" })
+    ).toContain("destination");
+    expect(
+      forwarderConfigMismatch(expected, { ...matching, recoveryAddress: "0x7777777777777777777777777777777777777777" })
+    ).toContain("refund wallet");
+    expect(forwarderConfigMismatch(expected, { ...matching, targetPpm: 1_000 })).toContain("targetPpm");
+    expect(forwarderConfigMismatch(expected, { ...matching, floorPpm: 2_000 })).toContain("floorPpm");
+  });
+
+  it("returns a client's derived refund wallet for deploying its forwarder", async () => {
+    const savedSeed = config.moneriumB2b.refundSeed;
+    config.moneriumB2b.refundSeed = `0x${"11".repeat(32)}`;
+    try {
+      const profileId = "0B8E7C2A-8F4E-4D43-9F2B-2F9F3C1D5A6E";
+      const response = await fetch(`${baseUrl}/refund-address?moneriumProfileId=${profileId}`, { headers: ADMIN_HEADERS });
+      expect(response.status).toBe(200);
+      expect(await response.json()).toEqual({
+        moneriumProfileId: profileId.toLowerCase(),
+        refundAddress: refundAccountFor(profileId.toLowerCase()).address
+      });
+      expect((await fetch(`${baseUrl}/refund-address?moneriumProfileId=nope`, { headers: ADMIN_HEADERS })).status).toBe(400);
+    } finally {
+      config.moneriumB2b.refundSeed = savedSeed;
+    }
   });
 
   it("rejects invalid input and unknown managers", async () => {
@@ -225,10 +257,11 @@ describe("monerium b2b account mapping admin route", () => {
     for (const overrides of [
       { forwarderAddress: "not-an-address" },
       { destination: "0x12345" },
-      { fallbackAddress: "" },
       { moneriumProfileId: "not-a-uuid" },
-      { feeBps: 3.5 },
-      { feeBps: -1 },
+      { targetPpm: 3.5 },
+      { floorPpm: -1 },
+      { floorPpm: 10_001 },
+      { floorPpm: 1_000, targetPpm: 1_200 },
       { externalSubjectId: "" },
       { contactEmail: "not-an-email" }
     ]) {
@@ -291,6 +324,88 @@ describe("monerium b2b account mapping admin route", () => {
     expect((await patchStatus(crypto.randomUUID(), "active")).status).toBe(404);
   });
 
+  it("marks a settling deposit for recovery and lets an operator close or retry it", async () => {
+    const managerProfileId = await createManager();
+    const created = await post(validBody(managerProfileId));
+    const { account } = (await created.json()) as { account: { accountId: string } };
+    const deposit = await MoneriumFiatDeposit.create({
+      accountId: account.accountId,
+      amountRaw: "100000000000000000000",
+      blockNumber: 100,
+      chainId: 11155111,
+      currency: "eur",
+      logIndex: 1,
+      moneriumOrderId: "order-1",
+      status: MoneriumFiatDepositStatus.Converting,
+      txHash: "0xmint"
+    });
+    const recover = (depositId: string) =>
+      fetch(`${baseUrl}/deposits/${depositId}/recover`, { headers: ADMIN_HEADERS, method: "POST" });
+    const patchStatus = (depositId: string, status: unknown) =>
+      fetch(`${baseUrl}/deposits/${depositId}/status`, {
+        body: JSON.stringify({ status }),
+        headers: ADMIN_HEADERS,
+        method: "PATCH"
+      });
+
+    // A pending keeper transaction must settle first: the amounts to recover depend on it.
+    const pending = await MoneriumConversionExecution.create({
+      accountId: account.accountId,
+      depositId: deposit.id,
+      destination: DESTINATION,
+      eureInRaw: "60000000000000000000",
+      status: MoneriumConversionExecutionStatus.Pending
+    });
+    const blocked = await recover(deposit.id);
+    expect(blocked.status).toBe(409);
+    expect(await blocked.json()).toMatchObject({ error: { message: expect.stringContaining("pending execution") } });
+    await pending.update({ status: MoneriumConversionExecutionStatus.Failed });
+
+    const badReason = await fetch(`${baseUrl}/deposits/${deposit.id}/recover`, {
+      body: JSON.stringify({ reason: "because" }),
+      headers: ADMIN_HEADERS,
+      method: "POST"
+    });
+    expect(badReason.status).toBe(400);
+
+    const marked = await fetch(`${baseUrl}/deposits/${deposit.id}/recover`, {
+      body: JSON.stringify({ reason: "compliance" }),
+      headers: ADMIN_HEADERS,
+      method: "POST"
+    });
+    expect(marked.status).toBe(200);
+    expect(await marked.json()).toMatchObject({ deposit: { depositId: deposit.id, status: "recovering" } });
+    const markedRow = await MoneriumFiatDeposit.findByPk(deposit.id);
+    expect(markedRow?.status).toBe(MoneriumFiatDepositStatus.Recovering);
+    expect(markedRow?.refundReason).toBe("compliance");
+    expect(markedRow?.refundStartedAt).not.toBeNull();
+
+    // Forward-only: a recovering deposit cannot be marked again, but closes or retries.
+    expect((await recover(deposit.id)).status).toBe(409);
+    expect((await patchStatus(deposit.id, "forwarded")).status).toBe(400);
+    const failed = await patchStatus(deposit.id, "recovery_failed");
+    expect(failed.status).toBe(200);
+    const retried = await patchStatus(deposit.id, "recovering");
+    expect(retried.status).toBe(200);
+    const refunded = await patchStatus(deposit.id, "refunded");
+    expect(refunded.status).toBe(200);
+    expect(await refunded.json()).toEqual({ deposit: { depositId: deposit.id, status: "refunded" } });
+    expect((await patchStatus(deposit.id, "refunded")).status).toBe(200);
+    const reopened = await patchStatus(deposit.id, "recovering");
+    expect(reopened.status).toBe(409);
+    expect(await reopened.json()).toMatchObject({
+      error: {
+        code: "MONERIUM_B2B_INVALID_STATUS_TRANSITION",
+        message: "Monerium deposit cannot transition from refunded to recovering"
+      }
+    });
+    expect((await MoneriumFiatDeposit.findByPk(deposit.id))?.status).toBe(MoneriumFiatDepositStatus.Refunded);
+    expect((await patchStatus(crypto.randomUUID(), "refunded")).status).toBe(404);
+
+    expect((await recover(crypto.randomUUID())).status).toBe(404);
+    expect((await recover("not-a-uuid")).status).toBe(400);
+  });
+
   it("refuses managers not allowed to provision business customers", async () => {
     const profile = await createTestUser();
     await ManagedProfileManager.create({