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

package/src/actions/ensureIdentity.ts

@@ -0,0 +1,68 @@
+import { getBackendUrl } from "../utils/backendUrl";
+import { getClientId } from "../utils/clientId";
+import { fetchMerchantId } from "../utils/merchantId";
+
+const ENSURE_STORAGE_PREFIX = "frak-identity-ensured-";
+
+/**
+ * Ensure the current wallet ↔ clientId link exists on the backend.
+ *
+ * Called automatically by {@link watchWalletStatus} when a connected wallet
+ * status is received. Acts as a failsafe: if the primary merge (SSO, pairing,
+ * login/register) missed or silently failed, this ensures the link is
+ * eventually established.
+ *
+ * The call is:
+ * - **Idempotent** — if already linked, backend returns immediately
+ * - **Deduplicated** — only fires once per browser session per merchant
+ * - **Fire-and-forget** — errors are logged but never thrown
+ *
+ * @param interactionToken - The SDK JWT from wallet status (x-wallet-sdk-auth)
+ *
+ * @example
+ * ```ts
+ * // Usually called automatically via watchWalletStatus side effect.
+ * // Can also be called manually if needed:
+ * await ensureIdentity("eyJhbGciOi...");
+ * ```
+ */
+export async function ensureIdentity(interactionToken: string): Promise<void> {
+    if (typeof window === "undefined") {
+        return;
+    }
+
+    const clientId = getClientId();
+    if (!clientId) {
+        return;
+    }
+
+    const merchantId = await fetchMerchantId();
+    if (!merchantId) {
+        return;
+    }
+
+    const storageKey = `${ENSURE_STORAGE_PREFIX}${merchantId}`;
+    if (window.sessionStorage.getItem(storageKey)) {
+        return;
+    }
+
+    try {
+        const backendUrl = getBackendUrl();
+        const response = await fetch(`${backendUrl}/user/identity/ensure`, {
+            method: "POST",
+            headers: {
+                Accept: "application/json",
+                "Content-Type": "application/json",
+                "x-wallet-sdk-auth": interactionToken,
+                "x-frak-client-id": clientId,
+            },
+            body: JSON.stringify({ merchantId }),
+        });
+
+        if (response.ok) {
+            window.sessionStorage.setItem(storageKey, "1");
+        }
+    } catch {
+        // Fire-and-forget — retry on next session
+    }
+}

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
         );