@frak-labs/core-sdk 0.1.1 → 0.2.0-beta.7898df5b

package/src/actions/referral/processReferral.test.ts

@@ -1,6 +1,5 @@
-import { FrakRpcError, RpcErrorCodes } from "@frak-labs/frame-connector";
-import type { Address, Hex } from "viem";
-import { vi } from "vitest"; // Keep vi from vitest for vi.mock() hoisting
+import type { Address } from "viem";
+import { vi } from "vitest";
 import {
     afterEach,
     beforeEach,
@@ -11,22 +10,13 @@ import {
 import type {
     FrakClient,
     FrakContext,
+    FrakContextV2,
     WalletStatusReturnType,
 } from "../../types";
 import { processReferral } from "./processReferral";
 
-// Mock computeProductId first
-vi.mock("../../utils/computeProductId", () => ({
-    computeProductId: vi.fn(
-        () =>
-            "0x0000000000000000000000000000000000000000000000000000000000000001" as Hex
-    ),
-}));
-
-// Mock dependencies
-vi.mock("../../index", () => ({
-    displayEmbeddedWallet: vi.fn(),
-    sendInteraction: vi.fn(),
+vi.mock("../sendInteraction", () => ({
+    sendInteraction: vi.fn().mockResolvedValue(undefined),
 }));
 
 vi.mock("../../utils", () => ({
@@ -34,33 +24,19 @@ vi.mock("../../utils", () => ({
         replaceUrl: vi.fn(),
     },
     trackEvent: vi.fn(),
-}));
-
-vi.mock("../../interactions", () => ({
-    ReferralInteractionEncoder: {
-        referred: vi.fn(({ referrer }: { referrer: Address }) => ({
-            interactionData: `0x${referrer.slice(2)}` as Hex,
-            handlerTypeDenominator: "0x01" as Hex,
-        })),
-    },
+    resolveMerchantId: vi.fn().mockResolvedValue(undefined),
+    getClientId: vi.fn().mockReturnValue("test-client-id"),
 }));
 
 describe("processReferral", () => {
     let mockClient: FrakClient;
     let mockAddress: Address;
-    let mockReferrerAddress: Address;
-    let mockProductId: Hex;
     let mockWalletStatus: WalletStatusReturnType;
-    let mockFrakContext: Partial<FrakContext>;
 
     beforeEach(async () => {
         vi.clearAllMocks();
 
         mockAddress = "0x1234567890123456789012345678901234567890" as Address;
-        mockReferrerAddress =
-            "0xabcdefabcdefabcdefabcdefabcdefabcdefabcd" as Address;
-        mockProductId =
-            "0x0000000000000000000000000000000000000000000000000000000000000001" as Hex;
 
         mockClient = {
             openPanel: {
@@ -78,17 +54,8 @@ describe("processReferral", () => {
         mockWalletStatus = {
             key: "connected" as const,
             wallet: mockAddress,
-            interactionSession: {
-                startTimestamp: Date.now() - 3600000,
-                endTimestamp: Date.now() + 3600000,
-            },
         };
 
-        mockFrakContext = {
-            r: mockReferrerAddress,
-        };
-
-        // Mock window.location
         Object.defineProperty(window, "location", {
             value: {
                 href: "https://example.com/test",
@@ -101,19 +68,6 @@ describe("processReferral", () => {
         vi.clearAllMocks();
     });
 
-    it("should return 'no-referrer' when frakContext has no referrer", async () => {
-        const utils = await import("../../utils");
-
-        const result = await processReferral(mockClient, {
-            walletStatus: mockWalletStatus,
-            frakContext: {},
-        });
-
-        expect(result).toBe("no-referrer");
-        // sendInteraction should not be called when there's no referrer
-        expect(utils.FrakContextManager.replaceUrl).toHaveBeenCalled();
-    });
-
     it("should return 'no-referrer' when frakContext is null", async () => {
         const result = await processReferral(mockClient, {
             walletStatus: mockWalletStatus,
@@ -121,177 +75,150 @@ describe("processReferral", () => {
         });
 
         expect(result).toBe("no-referrer");
-        // sendInteraction should not be called when there's no referrer
     });
 
-    it("should return 'self-referral' when referrer equals current wallet", async () => {
-        const result = await processReferral(mockClient, {
-            walletStatus: mockWalletStatus,
-            frakContext: {
-                r: mockAddress, // Same as wallet
-            },
-        });
-
-        expect(result).toBe("self-referral");
-        // sendInteraction should not be called for self-referrals
-    });
-
-    it("should successfully process referral when all conditions are met", async () => {
-        const utils = await import("../../utils");
-
-        // Mock client.request for sendInteraction
-        vi.mocked(mockClient.request).mockResolvedValue({
-            delegationId: "delegation-123",
-        } as any);
-
-        const result = await processReferral(mockClient, {
-            walletStatus: mockWalletStatus,
-            frakContext: mockFrakContext,
-            productId: mockProductId,
-        });
-
-        expect(result).toBe("success");
-
-        // sendInteraction uses client.request internally
-        expect(mockClient.request).toHaveBeenCalled();
-        expect(utils.trackEvent).toHaveBeenCalledWith(
-            mockClient,
-            "user_referred",
-            {
-                properties: {
-                    referrer: mockReferrerAddress,
-                },
-            }
-        );
-    });
-
-    it("should handle wallet not connected scenario", async () => {
-        // Mock client.request for displayEmbeddedWallet and sendInteraction
-        vi.mocked(mockClient.request)
-            .mockResolvedValueOnce({
-                wallet: mockAddress,
-            } as any)
-            .mockResolvedValueOnce({
-                delegationId: "delegation-123",
-            } as any);
-
-        const result = await processReferral(mockClient, {
-            walletStatus: undefined,
-            frakContext: mockFrakContext,
-        });
-
-        expect(result).toBe("success");
-        expect(mockClient.request).toHaveBeenCalled();
-    });
-
-    it("should handle missing interaction session", async () => {
-        const statusWithoutSession: WalletStatusReturnType = {
-            key: "connected" as const,
-            wallet: mockAddress,
-            interactionSession: undefined,
+    describe("V2 context", () => {
+        const v2Context: FrakContextV2 = {
+            v: 2,
+            c: "referrer-client-id",
+            m: "merchant-uuid",
+            t: 1709654400,
         };
 
-        // Mock client.request for displayEmbeddedWallet and sendInteraction
-        vi.mocked(mockClient.request)
-            .mockResolvedValueOnce({
-                wallet: mockAddress,
-            } as any)
-            .mockResolvedValueOnce({
-                delegationId: "delegation-123",
-            } as any);
-
-        const result = await processReferral(mockClient, {
-            walletStatus: statusWithoutSession,
-            frakContext: mockFrakContext,
-        });
-
-        expect(result).toBe("success");
-        expect(mockClient.request).toHaveBeenCalled();
-    });
-
-    it("should return 'error' when wallet connection fails", async () => {
-        const error = new FrakRpcError(
-            RpcErrorCodes.walletNotConnected,
-            "Wallet not connected"
-        );
-        // Mock client.request to throw error for displayEmbeddedWallet
-        vi.mocked(mockClient.request).mockRejectedValue(error);
-
-        const result = await processReferral(mockClient, {
-            walletStatus: undefined,
-            frakContext: mockFrakContext,
+        it("should successfully process v2 referral", async () => {
+            const utils = await import("../../utils");
+            const { sendInteraction } = await import("../sendInteraction");
+
+            const result = await processReferral(mockClient, {
+                walletStatus: mockWalletStatus,
+                frakContext: v2Context,
+            });
+
+            expect(result).toBe("success");
+
+            expect(utils.trackEvent).toHaveBeenCalledWith(
+                mockClient,
+                "user_referred_started",
+                {
+                    properties: {
+                        referrerClientId: "referrer-client-id",
+                        walletStatus: "connected",
+                    },
+                }
+            );
+
+            expect(sendInteraction).toHaveBeenCalledWith(mockClient, {
+                type: "arrival",
+                referrerClientId: "referrer-client-id",
+                referrerMerchantId: "merchant-uuid",
+                referralTimestamp: 1709654400,
+                landingUrl: "https://example.com/test",
+            });
+        });
+
+        it("should return 'self-referral' when v2 context has same clientId as current user", async () => {
+            const utils = await import("../../utils");
+            vi.mocked(utils.getClientId).mockReturnValue("referrer-client-id");
+
+            const v2SelfReferralContext: FrakContextV2 = {
+                v: 2,
+                c: "referrer-client-id",
+                m: "merchant-uuid",
+                t: 1709654400,
+            };
+
+            const result = await processReferral(mockClient, {
+                walletStatus: mockWalletStatus,
+                frakContext: v2SelfReferralContext,
+            });
+
+            expect(result).toBe("self-referral");
+            vi.mocked(utils.getClientId).mockReturnValue("test-client-id");
         });
-
-        // The error gets caught and mapped
-        expect(["error", "no-wallet", "success"]).toContain(result);
     });
 
-    it("should return 'no-session' when interaction delegation fails", async () => {
-        const error = new FrakRpcError(
-            RpcErrorCodes.serverErrorForInteractionDelegation,
-            "Server error"
-        );
-        // Mock client.request to throw error for sendInteraction
-        vi.mocked(mockClient.request).mockRejectedValue(error);
-
-        const result = await processReferral(mockClient, {
-            walletStatus: mockWalletStatus,
-            frakContext: mockFrakContext,
-        });
-
-        // sendInteraction is in Promise.allSettled, so errors are caught
-        // The function might still succeed or return error depending on implementation
-        expect(["no-session", "error", "success"]).toContain(result);
-    });
+    describe("V1 context (backward compat)", () => {
+        const v1Context: FrakContext = {
+            r: "0xabcdefabcdefabcdefabcdefabcdefabcdefabcd" as Address,
+        };
 
-    it("should return 'error' for unknown errors", async () => {
-        const error = new Error("Unknown error");
-        // Mock client.request to throw error for sendInteraction
-        vi.mocked(mockClient.request).mockRejectedValue(error);
+        it("should successfully process v1 referral", async () => {
+            const utils = await import("../../utils");
+
+            const result = await processReferral(mockClient, {
+                walletStatus: mockWalletStatus,
+                frakContext: v1Context,
+            });
+
+            expect(result).toBe("success");
+
+            expect(utils.trackEvent).toHaveBeenCalledWith(
+                mockClient,
+                "user_referred_started",
+                {
+                    properties: {
+                        referrer: "0xabcdefabcdefabcdefabcdefabcdefabcdefabcd",
+                        walletStatus: "connected",
+                    },
+                }
+            );
+        });
+
+        it("should return 'self-referral' when v1 referrer matches current wallet", async () => {
+            const result = await processReferral(mockClient, {
+                walletStatus: mockWalletStatus,
+                frakContext: {
+                    r: mockAddress,
+                },
+            });
 
-        const result = await processReferral(mockClient, {
-            walletStatus: mockWalletStatus,
-            frakContext: mockFrakContext,
+            expect(result).toBe("self-referral");
         });
-
-        // sendInteraction is called inside pushReferralInteraction which is inside Promise.allSettled
-        // So the error might be caught and the function might still succeed
-        expect(["error", "success"]).toContain(result);
     });
 
     it("should update URL context when alwaysAppendUrl is true", async () => {
         const utils = await import("../../utils");
 
-        // Mock client.request for sendInteraction
-        vi.mocked(mockClient.request).mockResolvedValue({
-            delegationId: "delegation-123",
-        } as any);
+        const v2Context: FrakContextV2 = {
+            v: 2,
+            c: "referrer-client-id",
+            m: "merchant-uuid",
+            t: 1709654400,
+        };
 
         await processReferral(mockClient, {
             walletStatus: mockWalletStatus,
-            frakContext: mockFrakContext,
+            frakContext: v2Context,
             options: {
                 alwaysAppendUrl: true,
             },
         });
 
+        expect(utils.getClientId()).toBe("test-client-id");
+
         expect(utils.FrakContextManager.replaceUrl).toHaveBeenCalledWith({
             url: window.location.href,
-            context: { r: mockAddress },
+            context: expect.objectContaining({
+                v: 2,
+                c: "test-client-id",
+                m: "merchant-uuid",
+            }),
         });
     });
 
     it("should remove URL context when alwaysAppendUrl is false", async () => {
         const utils = await import("../../utils");
 
-        // Mock client.request for sendInteraction
-        vi.mocked(mockClient.request).mockResolvedValue({
-            delegationId: "delegation-123",
-        } as any);
+        const v2Context: FrakContextV2 = {
+            v: 2,
+            c: "referrer-client-id",
+            m: "merchant-uuid",
+            t: 1709654400,
+        };
 
         await processReferral(mockClient, {
             walletStatus: mockWalletStatus,
-            frakContext: mockFrakContext,
+            frakContext: v2Context,
             options: {
                 alwaysAppendUrl: false,
             },
@@ -302,56 +229,4 @@ describe("processReferral", () => {
             context: null,
         });
     });
-
-    it("should remove URL context by default", async () => {
-        const utils = await import("../../utils");
-
-        // Mock client.request for sendInteraction
-        vi.mocked(mockClient.request).mockResolvedValue({
-            delegationId: "delegation-123",
-        } as any);
-
-        await processReferral(mockClient, {
-            walletStatus: mockWalletStatus,
-            frakContext: mockFrakContext,
-        });
-
-        expect(utils.FrakContextManager.replaceUrl).toHaveBeenCalledWith({
-            url: window.location.href,
-            context: null,
-        });
-    });
-
-    it("should handle sendInteraction failures gracefully", async () => {
-        const utils = await import("../../utils");
-
-        // Mock client.request to throw error only for sendInteraction call
-        // Note: sendInteraction uses Promise.allSettled, so errors are caught
-        // We use mockImplementation to ensure the rejection is properly handled
-        // by returning a rejected promise that will be caught by Promise.allSettled
-        vi.mocked(mockClient.request).mockImplementation(async (request) => {
-            // Only reject for frak_sendInteraction calls (sendInteraction)
-            if (request.method === "frak_sendInteraction") {
-                // Return a rejected promise that will be caught by Promise.allSettled
-                return Promise.reject(new Error("Network error"));
-            }
-            // For any other calls (e.g., displayEmbeddedWallet), resolve successfully
-            return { delegationId: "delegation-123" } as any;
-        });
-        // trackEvent errors are also caught in Promise.allSettled
-        // Even though trackEvent is synchronous (returns void), we return a rejected promise
-        // so that Promise.allSettled can properly catch it without causing unhandled rejections
-        vi.mocked(utils.trackEvent).mockImplementation(() => {
-            return Promise.reject(new Error("Track failed")) as any;
-        });
-
-        const result = await processReferral(mockClient, {
-            walletStatus: mockWalletStatus,
-            frakContext: mockFrakContext,
-        });
-
-        // sendInteraction is in Promise.allSettled, so errors are caught
-        // The function might still succeed or return error depending on implementation
-        expect(["error", "success"]).toContain(result);
-    });
 });