🥅 server: bridge credential fallback and retry on timeout

.changeset/twco-dcxi-kedl.md

@@ -0,0 +1,5 @@
+---
+"@exactly/server": patch
+---
+
+🥅 add bridge credential fallback and retry on timeout

server/database/schema.ts

@@ -35,7 +35,7 @@ export const credentials = pgTable(
     bridgeId: text("bridge_id"),
     source: text("source"),
   },
-  ({ account, bridgeId }) => [uniqueIndex("account_index").on(account), index("bridge_id_index").on(bridgeId)],
+  ({ account, bridgeId }) => [uniqueIndex("account_index").on(account), uniqueIndex("bridge_id_index").on(bridgeId)],
 );
 
 export const cards = pgTable(

server/hooks/bridge.ts

@@ -1,7 +1,7 @@
 import { vValidator } from "@hono/valibot-validator";
-import { captureException, setUser } from "@sentry/core";
+import { captureEvent, captureException, setUser } from "@sentry/core";
 import createDebug from "debug";
-import { eq } from "drizzle-orm";
+import { and, DrizzleQueryError, eq, isNull } from "drizzle-orm";
 import { Hono } from "hono";
 import { validator } from "hono/validator";
 import { createHash, createVerify } from "node:crypto";
@@ -11,7 +11,8 @@ import { Address } from "@exactly/common/validation";
 
 import database, { credentials } from "../database";
 import { sendPushNotification } from "../utils/onesignal";
-import { BridgeCurrency, publicKey } from "../utils/ramps/bridge";
+import { searchAccounts } from "../utils/persona";
+import { BridgeCurrency, getCustomer, publicKey } from "../utils/ramps/bridge";
 import { track } from "../utils/segment";
 import validatorHook from "../utils/validatorHook";
 
@@ -98,10 +99,57 @@ export default new Hono().post(
       payload.event_type === "customer.updated.status_transitioned"
         ? payload.event_object.id
         : payload.event_object.customer_id;
-    const credential = await database.query.credentials.findFirst({
+    let credential = await database.query.credentials.findFirst({
       columns: { account: true, source: true },
       where: eq(credentials.bridgeId, bridgeId),
     });
+    if (!credential && payload.event_type === "customer.updated.status_transitioned") {
+      credential = await getCustomer(bridgeId)
+        .then((customer) => (customer ? searchAccounts(customer.email) : undefined))
+        .then((accounts) => {
+          if (accounts && accounts.length > 1)
+            captureException(new Error("multiple persona accounts found"), {
+              level: "fatal",
+              contexts: { details: { bridgeId, matches: accounts.length } },
+            });
+          return accounts?.length === 1 ? accounts[0]?.attributes["reference-id"] : undefined;
+        })
+        .then((referenceId) =>
+          referenceId
+            ? database
+                .update(credentials)
+                .set({ bridgeId })
+                .where(and(eq(credentials.id, referenceId), isNull(credentials.bridgeId)))
+                .returning({ account: credentials.account, source: credentials.source })
+                .then(([updated]) => {
+                  if (!updated) throw new Error("credential already paired");
+                  captureEvent({
+                    message: "bridge credential paired",
+                    level: "warning",
+                    contexts: { details: { bridgeId, referenceId } },
+                  });
+                  return updated;
+                })
+                .catch((error: unknown): undefined => {
+                  if (
+                    !(
+                      (error instanceof Error && error.message === "credential already paired") ||
+                      (error instanceof DrizzleQueryError &&
+                        error.cause &&
+                        "code" in error.cause &&
+                        error.cause.code === "23505")
+                    )
+                  )
+                    throw error;
+                  captureEvent({
+                    message: "bridge credential already paired",
+                    level: "fatal",
+                    contexts: { details: { bridgeId } },
+                  });
+                })
+            : undefined,
+        );
+    }
     if (!credential) {
       captureException(new Error("credential not found"), {
         level: "error",

server/test/api/ramp.test.ts

@@ -908,6 +908,7 @@ const mantecaUser = {
 
 const bridgeCustomer = {
   id: "bridge-customer-123",
+  email: "test@example.com",
   status: "active" as const,
   endorsements: [],
 };

server/test/hooks/bridge.test.ts

@@ -1,7 +1,8 @@
 import "../mocks/onesignal";
 import "../mocks/sentry";
 
-import { captureException } from "@sentry/core";
+import { captureEvent, captureException } from "@sentry/core";
+import { eq } from "drizzle-orm";
 import { testClient } from "hono/testing";
 import { createHash, createPrivateKey, createSign, generateKeyPairSync } from "node:crypto";
 import { hexToBytes, padHex, zeroHash } from "viem";
@@ -13,14 +14,19 @@ import deriveAddress from "@exactly/common/deriveAddress";
 import database, { credentials } from "../../database";
 import app from "../../hooks/bridge";
 import * as onesignal from "../../utils/onesignal";
+import * as persona from "../../utils/persona";
+import * as bridge from "../../utils/ramps/bridge";
 import * as segment from "../../utils/segment";
 
 const appClient = testClient(app);
 
 describe("bridge hook", () => {
   const owner = privateKeyToAddress(padHex("0xb1e"));
+  const fallbackOwner = privateKeyToAddress(padHex("0xfa11"));
+  const conflictOwner = privateKeyToAddress(padHex("0xc0f1"));
   const factory = inject("ExaAccountFactory");
   const account = deriveAddress(factory, { x: padHex(owner), y: zeroHash });
+  const fallbackAccount = deriveAddress(factory, { x: padHex(fallbackOwner), y: zeroHash });
 
   beforeAll(async () => {
     await database.insert(credentials).values([
@@ -32,6 +38,19 @@ describe("bridge hook", () => {
         pandaId: "bridgePandaId",
         bridgeId: "bridgeCustomerId",
       },
+      {
+        id: "fallback-test",
+        publicKey: new Uint8Array(hexToBytes(fallbackOwner)),
+        account: fallbackAccount,
+        factory,
+      },
+      {
+        id: "conflict-test",
+        publicKey: new Uint8Array(hexToBytes(conflictOwner)),
+        account: deriveAddress(factory, { x: padHex(conflictOwner), y: zeroHash }),
+        factory,
+        bridgeId: "conflict-bridge-id",
+      },
     ]);
   });
 
@@ -202,6 +221,169 @@ describe("bridge hook", () => {
     );
   });
 
+  it("resolves credential via persona email fallback on status_transitioned", async () => {
+    vi.spyOn(segment, "track").mockReturnValue();
+    const sendPushNotification = vi.spyOn(onesignal, "sendPushNotification");
+    vi.spyOn(bridge, "getCustomer").mockResolvedValue({
+      id: "fallback-bridge-id",
+      email: "fallback@example.com",
+      status: "active",
+      endorsements: [],
+    });
+    vi.spyOn(persona, "searchAccounts").mockResolvedValue([{ attributes: { "reference-id": "fallback-test" } }]);
+    const payload = {
+      ...statusTransitioned,
+      event_object: { ...statusTransitioned.event_object, id: "fallback-bridge-id" },
+    };
+    const response = await appClient.index.$post({
+      header: { "x-webhook-signature": createSignature(payload) },
+      json: payload as never,
+    });
+
+    expect(response.status).toBe(200);
+    await expect(response.json()).resolves.toStrictEqual({ code: "ok" });
+    expect(captureException).not.toHaveBeenCalled();
+    expect(captureEvent).toHaveBeenCalledWith(
+      expect.objectContaining({
+        message: "bridge credential paired",
+        level: "warning",
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+        contexts: expect.objectContaining({
+          details: { bridgeId: "fallback-bridge-id", referenceId: "fallback-test" },
+        }),
+      }),
+    );
+    const updated = await database.query.credentials.findFirst({
+      columns: { bridgeId: true },
+      where: eq(credentials.id, "fallback-test"),
+    });
+    expect(updated?.bridgeId).toBe("fallback-bridge-id");
+    expect(segment.track).toHaveBeenCalledWith({
+      userId: fallbackAccount,
+      event: "RampAccount",
+      properties: { provider: "bridge", source: null },
+    });
+    expect(sendPushNotification).toHaveBeenCalledWith({
+      userId: fallbackAccount,
+      headings: { en: "Fiat onramp activated" },
+      contents: { en: "Your fiat onramp account has been activated" },
+    });
+  });
+
+  it("returns 200 with already paired on duplicate bridgeId fallback", async () => {
+    vi.spyOn(database.query.credentials, "findFirst").mockResolvedValueOnce(undefined); // eslint-disable-line unicorn/no-useless-undefined
+    vi.spyOn(bridge, "getCustomer").mockResolvedValue({
+      id: "conflict-bridge-id",
+      email: "conflict@example.com",
+      status: "active",
+      endorsements: [],
+    });
+    vi.spyOn(persona, "searchAccounts").mockResolvedValue([{ attributes: { "reference-id": "fallback-test" } }]);
+    const payload = {
+      ...statusTransitioned,
+      event_object: { ...statusTransitioned.event_object, id: "conflict-bridge-id" },
+    };
+    const response = await appClient.index.$post({
+      header: { "x-webhook-signature": createSignature(payload) },
+      json: payload as never,
+    });
+
+    expect(response.status).toBe(200);
+    await expect(response.json()).resolves.toStrictEqual({ code: "credential not found" });
+    expect(captureEvent).toHaveBeenCalledWith(
+      expect.objectContaining({
+        message: "bridge credential already paired",
+        level: "fatal",
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+        contexts: expect.objectContaining({ details: { bridgeId: "conflict-bridge-id" } }),
+      }),
+    );
+    expect(captureException).toHaveBeenCalledExactlyOnceWith(
+      expect.objectContaining({ message: "credential not found" }),
+      { level: "error", contexts: { details: { bridgeId: "conflict-bridge-id" } } },
+    );
+  });
+
+  it("returns credential not found when multiple persona accounts found on status_transitioned fallback", async () => {
+    vi.spyOn(bridge, "getCustomer").mockResolvedValue({
+      id: "multi-bridge-id",
+      email: "multi@example.com",
+      status: "active",
+      endorsements: [],
+    });
+    vi.spyOn(persona, "searchAccounts").mockResolvedValue([
+      { attributes: { "reference-id": "ref-1" } },
+      { attributes: { "reference-id": "ref-2" } },
+    ]);
+    const payload = {
+      ...statusTransitioned,
+      event_object: { ...statusTransitioned.event_object, id: "multi-bridge-id" },
+    };
+    const response = await appClient.index.$post({
+      header: { "x-webhook-signature": createSignature(payload) },
+      json: payload as never,
+    });
+
+    expect(response.status).toBe(200);
+    await expect(response.json()).resolves.toStrictEqual({ code: "credential not found" });
+    expect(captureException).toHaveBeenCalledWith(
+      expect.objectContaining({ message: "multiple persona accounts found" }),
+      { level: "fatal", contexts: { details: { bridgeId: "multi-bridge-id", matches: 2 } } },
+    );
+  });
+
+  it("returns credential not found when status_transitioned fallback finds no accounts", async () => {
+    vi.spyOn(bridge, "getCustomer").mockResolvedValue({
+      id: "empty-bridge-id",
+      email: "empty@example.com",
+      status: "active",
+      endorsements: [],
+    });
+    vi.spyOn(persona, "searchAccounts").mockResolvedValue([]);
+    const payload = {
+      ...statusTransitioned,
+      event_object: { ...statusTransitioned.event_object, id: "empty-bridge-id" },
+    };
+    const response = await appClient.index.$post({
+      header: { "x-webhook-signature": createSignature(payload) },
+      json: payload as never,
+    });
+
+    expect(response.status).toBe(200);
+    await expect(response.json()).resolves.toStrictEqual({ code: "credential not found" });
+    expect(captureException).toHaveBeenCalledExactlyOnceWith(
+      expect.objectContaining({ message: "credential not found" }),
+      { level: "error", contexts: { details: { bridgeId: "empty-bridge-id" } } },
+    );
+  });
+
+  it("returns credential not found when status_transitioned fallback reference-id has no credential", async () => {
+    vi.spyOn(bridge, "getCustomer").mockResolvedValue({
+      id: "orphan-bridge-id",
+      email: "orphan@example.com",
+      status: "active",
+      endorsements: [],
+    });
+    vi.spyOn(persona, "searchAccounts").mockResolvedValue([
+      { attributes: { "reference-id": "nonexistent-credential" } },
+    ]);
+    const payload = {
+      ...statusTransitioned,
+      event_object: { ...statusTransitioned.event_object, id: "orphan-bridge-id" },
+    };
+    const response = await appClient.index.$post({
+      header: { "x-webhook-signature": createSignature(payload) },
+      json: payload as never,
+    });
+
+    expect(response.status).toBe(200);
+    await expect(response.json()).resolves.toStrictEqual({ code: "credential not found" });
+    expect(captureException).toHaveBeenCalledExactlyOnceWith(
+      expect.objectContaining({ message: "credential not found" }),
+      { level: "error", contexts: { details: { bridgeId: "orphan-bridge-id" } } },
+    );
+  });
+
   it("tracks RampAccount and sends notification on status_transitioned to active", async () => {
     vi.spyOn(segment, "track").mockReturnValue();
     const sendPushNotification = vi.spyOn(onesignal, "sendPushNotification");
@@ -257,7 +439,8 @@ describe("bridge hook", () => {
     expect(sendPushNotification).not.toHaveBeenCalled();
   });
 
-  it("captures sentry exception when status_transitioned credential not found", async () => {
+  it("captures sentry exception when status_transitioned credential not found and customer not in bridge", async () => {
+    vi.spyOn(bridge, "getCustomer").mockResolvedValue(undefined); // eslint-disable-line unicorn/no-useless-undefined
     const payload = {
       ...statusTransitioned,
       event_object: { ...statusTransitioned.event_object, id: "unknown-customer" },