@frak-labs/core-sdk 0.1.1 → 0.2.0-beta.514ef378

package/src/actions/{getProductInformation.test.ts → getMerchantInformation.test.ts}

@@ -1,22 +1,16 @@
-/**
- * Tests for getProductInformation action
- * Tests fetching product information via RPC
- */
-
 import type { Address, Hex } from "viem";
 import { describe, expect, it, vi } from "../../tests/vitest-fixtures";
-import type { FrakClient, GetProductInformationReturnType } from "../types";
-import { getProductInformation } from "./getProductInformation";
+import type { FrakClient, GetMerchantInformationReturnType } from "../types";
+import { getMerchantInformation } from "./getMerchantInformation";
 
-describe("getProductInformation", () => {
+describe("getMerchantInformation", () => {
     describe("success cases", () => {
         it("should call client.request with correct method", async () => {
-            const mockResponse: GetProductInformationReturnType = {
+            const mockResponse: GetMerchantInformationReturnType = {
                 id: "0x1234567890123456789012345678901234567890123456789012345678901234" as Hex,
                 onChainMetadata: {
-                    name: "Test Product",
+                    name: "Test Merchant",
                     domain: "example.com",
-                    productTypes: ["press"],
                 },
                 rewards: [],
             };
@@ -25,20 +19,19 @@ describe("getProductInformation", () => {
                 request: vi.fn().mockResolvedValue(mockResponse),
             } as unknown as FrakClient;
 
-            await getProductInformation(mockClient);
+            await getMerchantInformation(mockClient);
 
             expect(mockClient.request).toHaveBeenCalledWith({
-                method: "frak_getProductInformation",
+                method: "frak_getMerchantInformation",
             });
         });
 
-        it("should return product information", async () => {
-            const mockResponse: GetProductInformationReturnType = {
+        it("should return merchant information", async () => {
+            const mockResponse: GetMerchantInformationReturnType = {
                 id: "0x1234567890123456789012345678901234567890123456789012345678901234" as Hex,
                 onChainMetadata: {
-                    name: "Test Product",
+                    name: "Test Merchant",
                     domain: "example.com",
-                    productTypes: ["press"],
                 },
                 rewards: [],
             };
@@ -47,48 +40,40 @@ describe("getProductInformation", () => {
                 request: vi.fn().mockResolvedValue(mockResponse),
             } as unknown as FrakClient;
 
-            const result = await getProductInformation(mockClient);
+            const result = await getMerchantInformation(mockClient);
 
             expect(result).toEqual(mockResponse);
         });
 
-        it("should return product information with rewards", async () => {
-            const mockResponse: GetProductInformationReturnType = {
+        it("should return merchant information with rewards", async () => {
+            const mockResponse: GetMerchantInformationReturnType = {
                 id: "0x1234567890123456789012345678901234567890123456789012345678901234" as Hex,
                 onChainMetadata: {
-                    name: "Test Product",
+                    name: "Test Merchant",
                     domain: "example.com",
-                    productTypes: ["press", "purchase"],
-                },
-                maxReferrer: {
-                    amount: 100,
-                    eurAmount: 10,
-                    usdAmount: 12,
-                    gbpAmount: 9,
-                },
-                maxReferee: {
-                    amount: 50,
-                    eurAmount: 5,
-                    usdAmount: 6,
-                    gbpAmount: 4.5,
                 },
                 rewards: [
                     {
                         token: "0x1234567890123456789012345678901234567890" as Address,
-                        campaign:
-                            "0xabcdefabcdefabcdefabcdefabcdefabcdefabcd" as Address,
-                        interactionTypeKey: "press.readArticle",
+                        campaignId: "campaign-1",
+                        interactionTypeKey: "referral",
                         referrer: {
-                            amount: 10,
-                            eurAmount: 1,
-                            usdAmount: 1.2,
-                            gbpAmount: 0.9,
+                            payoutType: "fixed",
+                            amount: {
+                                amount: 10,
+                                eurAmount: 1,
+                                usdAmount: 1.2,
+                                gbpAmount: 0.9,
+                            },
                         },
                         referee: {
-                            amount: 5,
-                            eurAmount: 0.5,
-                            usdAmount: 0.6,
-                            gbpAmount: 0.45,
+                            payoutType: "fixed",
+                            amount: {
+                                amount: 5,
+                                eurAmount: 0.5,
+                                usdAmount: 0.6,
+                                gbpAmount: 0.45,
+                            },
                         },
                     },
                 ],
@@ -98,12 +83,10 @@ describe("getProductInformation", () => {
                 request: vi.fn().mockResolvedValue(mockResponse),
             } as unknown as FrakClient;
 
-            const result = await getProductInformation(mockClient);
+            const result = await getMerchantInformation(mockClient);
 
             expect(result).toEqual(mockResponse);
             expect(result.rewards).toHaveLength(1);
-            expect(result.maxReferrer).toBeDefined();
-            expect(result.maxReferee).toBeDefined();
         });
     });
 
@@ -114,7 +97,7 @@ describe("getProductInformation", () => {
                 request: vi.fn().mockRejectedValue(error),
             } as unknown as FrakClient;
 
-            await expect(getProductInformation(mockClient)).rejects.toThrow(
+            await expect(getMerchantInformation(mockClient)).rejects.toThrow(
                 "RPC request failed"
             );
         });
@@ -125,7 +108,7 @@ describe("getProductInformation", () => {
                 request: vi.fn().mockRejectedValue(error),
             } as unknown as FrakClient;
 
-            await expect(getProductInformation(mockClient)).rejects.toThrow(
+            await expect(getMerchantInformation(mockClient)).rejects.toThrow(
                 "Request timeout"
             );
         });

package/src/actions/getMerchantInformation.ts

@@ -0,0 +1,16 @@
+import type { FrakClient, GetMerchantInformationReturnType } from "../types";
+
+/**
+ * Fetch the current merchant information (name, rewards, tiers) from the wallet iframe
+ * @param client - The current Frak Client
+ * @returns The merchant information including available reward tiers
+ *
+ * @see {@link @frak-labs/core-sdk!index.GetMerchantInformationReturnType | `GetMerchantInformationReturnType`} for the return type shape
+ */
+export async function getMerchantInformation(
+    client: FrakClient
+): Promise<GetMerchantInformationReturnType> {
+    return await client.request({
+        method: "frak_getMerchantInformation",
+    });
+}

package/src/actions/index.ts

@@ -1,6 +1,7 @@
 export { displayEmbeddedWallet } from "./displayEmbeddedWallet";
 export { displayModal } from "./displayModal";
-export { getProductInformation } from "./getProductInformation";
+export { ensureIdentity } from "./ensureIdentity";
+export { getMerchantInformation } from "./getMerchantInformation";
 export { openSso } from "./openSso";
 export { prepareSso } from "./prepareSso";
 export {
@@ -13,6 +14,7 @@ export { sendInteraction } from "./sendInteraction";
 // Helper to track the purchase status
 export { trackPurchaseStatus } from "./trackPurchaseStatus";
 export { watchWalletStatus } from "./watchWalletStatus";
+// Modal wrappers
 export {
     type ModalBuilder,
     type ModalStepBuilder,
@@ -22,7 +24,6 @@ export {
     type SendTransactionParams,
     sendTransaction,
 } from "./wrapper/sendTransaction";
-// Modal wrappers
 export {
     type SiweAuthenticateModalParams,
     siweAuthenticate,

package/src/actions/openSso.ts

@@ -3,7 +3,8 @@ import type {
     OpenSsoParamsType,
     OpenSsoReturnType,
 } from "../types";
-import { computeProductId } from "../utils/computeProductId";
+import { getClientId } from "../utils/clientId";
+import { computeLegacyProductId } from "../utils/computeLegacyProductId";
 import { generateSsoUrl } from "../utils/sso";
 
 // SSO popup configuration
@@ -91,8 +92,9 @@ export async function openSso(
         generateSsoUrl(
             walletUrl ?? "https://wallet.frak.id",
             args,
-            computeProductId(),
+            computeLegacyProductId(),
             metadata.name,
+            getClientId(),
             customizations?.css
         );
 

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

@@ -1,5 +1,5 @@
 import { FrakRpcError, RpcErrorCodes } from "@frak-labs/frame-connector";
-import type { Address, Hex } from "viem";
+import type { Address } from "viem";
 import { vi } from "vitest"; // Keep vi from vitest for vi.mock() hoisting
 import {
     afterEach,
@@ -15,18 +15,13 @@ import type {
 } from "../../types";
 import { processReferral } from "./processReferral";
 
-// Mock computeProductId first
-vi.mock("../../utils/computeProductId", () => ({
-    computeProductId: vi.fn(
-        () =>
-            "0x0000000000000000000000000000000000000000000000000000000000000001" as Hex
-    ),
-}));
-
 // Mock dependencies
-vi.mock("../../index", () => ({
+vi.mock("../displayEmbeddedWallet", () => ({
     displayEmbeddedWallet: vi.fn(),
-    sendInteraction: vi.fn(),
+}));
+
+vi.mock("../sendInteraction", () => ({
+    sendInteraction: vi.fn().mockResolvedValue(undefined),
 }));
 
 vi.mock("../../utils", () => ({
@@ -34,22 +29,13 @@ 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),
 }));
 
 describe("processReferral", () => {
     let mockClient: FrakClient;
     let mockAddress: Address;
     let mockReferrerAddress: Address;
-    let mockProductId: Hex;
     let mockWalletStatus: WalletStatusReturnType;
     let mockFrakContext: Partial<FrakContext>;
 
@@ -59,8 +45,6 @@ describe("processReferral", () => {
         mockAddress = "0x1234567890123456789012345678901234567890" as Address;
         mockReferrerAddress =
             "0xabcdefabcdefabcdefabcdefabcdefabcdefabcd" as Address;
-        mockProductId =
-            "0x0000000000000000000000000000000000000000000000000000000000000001" as Hex;
 
         mockClient = {
             openPanel: {
@@ -78,10 +62,6 @@ describe("processReferral", () => {
         mockWalletStatus = {
             key: "connected" as const,
             wallet: mockAddress,
-            interactionSession: {
-                startTimestamp: Date.now() - 3600000,
-                endTimestamp: Date.now() + 3600000,
-            },
         };
 
         mockFrakContext = {
@@ -102,16 +82,12 @@ describe("processReferral", () => {
     });
 
     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 () => {
@@ -121,7 +97,6 @@ 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 () => {
@@ -133,140 +108,99 @@ describe("processReferral", () => {
         });
 
         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",
+            "user_referred_started",
+            {
+                properties: {
+                    referrer: mockReferrerAddress,
+                    walletStatus: "connected",
+                },
+            }
+        );
+
+        expect(utils.trackEvent).toHaveBeenCalledWith(
+            mockClient,
+            "user_referred_completed",
             {
                 properties: {
+                    status: "success",
                     referrer: mockReferrerAddress,
+                    wallet: mockAddress,
                 },
             }
         );
     });
 
     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();
-    });
+        const { displayEmbeddedWallet } = await import(
+            "../displayEmbeddedWallet"
+        );
 
-    it("should handle missing interaction session", async () => {
-        const statusWithoutSession: WalletStatusReturnType = {
-            key: "connected" as const,
+        // Mock displayEmbeddedWallet to return a wallet
+        vi.mocked(displayEmbeddedWallet).mockResolvedValue({
             wallet: mockAddress,
-            interactionSession: undefined,
-        };
-
-        // Mock client.request for displayEmbeddedWallet and sendInteraction
-        vi.mocked(mockClient.request)
-            .mockResolvedValueOnce({
-                wallet: mockAddress,
-            } as any)
-            .mockResolvedValueOnce({
-                delegationId: "delegation-123",
-            } as any);
+        } as any);
 
         const result = await processReferral(mockClient, {
-            walletStatus: statusWithoutSession,
+            walletStatus: undefined,
             frakContext: mockFrakContext,
         });
 
         expect(result).toBe("success");
-        expect(mockClient.request).toHaveBeenCalled();
+        expect(displayEmbeddedWallet).toHaveBeenCalled();
     });
 
-    it("should return 'error' when wallet connection fails", async () => {
+    it("should return 'no-wallet' when wallet connection fails", async () => {
+        const { displayEmbeddedWallet } = await import(
+            "../displayEmbeddedWallet"
+        );
+
         const error = new FrakRpcError(
             RpcErrorCodes.walletNotConnected,
             "Wallet not connected"
         );
-        // Mock client.request to throw error for displayEmbeddedWallet
-        vi.mocked(mockClient.request).mockRejectedValue(error);
+        vi.mocked(displayEmbeddedWallet).mockRejectedValue(error);
 
         const result = await processReferral(mockClient, {
             walletStatus: undefined,
             frakContext: mockFrakContext,
         });
 
-        // The error gets caught and mapped
-        expect(["error", "no-wallet", "success"]).toContain(result);
+        expect(result).toBe("no-wallet");
     });
 
-    it("should return 'no-session' when interaction delegation fails", async () => {
-        const error = new FrakRpcError(
-            RpcErrorCodes.serverErrorForInteractionDelegation,
-            "Server error"
+    it("should return 'error' for unknown errors", async () => {
+        const { displayEmbeddedWallet } = await import(
+            "../displayEmbeddedWallet"
         );
-        // 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);
-    });
-
-    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);
+        vi.mocked(displayEmbeddedWallet).mockRejectedValue(error);
 
         const result = await processReferral(mockClient, {
-            walletStatus: mockWalletStatus,
+            walletStatus: undefined,
             frakContext: mockFrakContext,
         });
 
-        // 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);
+        expect(result).toBe("error");
     });
 
     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);
-
         await processReferral(mockClient, {
             walletStatus: mockWalletStatus,
             frakContext: mockFrakContext,
@@ -284,11 +218,6 @@ describe("processReferral", () => {
     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);
-
         await processReferral(mockClient, {
             walletStatus: mockWalletStatus,
             frakContext: mockFrakContext,
@@ -306,11 +235,6 @@ describe("processReferral", () => {
     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,
@@ -321,37 +245,4 @@ describe("processReferral", () => {
             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);
-    });
 });