@frak-labs/core-sdk 0.1.0-beta.267778ad → 0.1.0-beta.278e9605

package/src/actions/getProductInformation.test.ts

@@ -0,0 +1,133 @@
+/**
+ * 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";
+
+describe("getProductInformation", () => {
+    describe("success cases", () => {
+        it("should call client.request with correct method", async () => {
+            const mockResponse: GetProductInformationReturnType = {
+                id: "0x1234567890123456789012345678901234567890123456789012345678901234" as Hex,
+                onChainMetadata: {
+                    name: "Test Product",
+                    domain: "example.com",
+                    productTypes: ["press"],
+                },
+                rewards: [],
+            };
+
+            const mockClient = {
+                request: vi.fn().mockResolvedValue(mockResponse),
+            } as unknown as FrakClient;
+
+            await getProductInformation(mockClient);
+
+            expect(mockClient.request).toHaveBeenCalledWith({
+                method: "frak_getProductInformation",
+            });
+        });
+
+        it("should return product information", async () => {
+            const mockResponse: GetProductInformationReturnType = {
+                id: "0x1234567890123456789012345678901234567890123456789012345678901234" as Hex,
+                onChainMetadata: {
+                    name: "Test Product",
+                    domain: "example.com",
+                    productTypes: ["press"],
+                },
+                rewards: [],
+            };
+
+            const mockClient = {
+                request: vi.fn().mockResolvedValue(mockResponse),
+            } as unknown as FrakClient;
+
+            const result = await getProductInformation(mockClient);
+
+            expect(result).toEqual(mockResponse);
+        });
+
+        it("should return product information with rewards", async () => {
+            const mockResponse: GetProductInformationReturnType = {
+                id: "0x1234567890123456789012345678901234567890123456789012345678901234" as Hex,
+                onChainMetadata: {
+                    name: "Test Product",
+                    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",
+                        referrer: {
+                            amount: 10,
+                            eurAmount: 1,
+                            usdAmount: 1.2,
+                            gbpAmount: 0.9,
+                        },
+                        referee: {
+                            amount: 5,
+                            eurAmount: 0.5,
+                            usdAmount: 0.6,
+                            gbpAmount: 0.45,
+                        },
+                    },
+                ],
+            };
+
+            const mockClient = {
+                request: vi.fn().mockResolvedValue(mockResponse),
+            } as unknown as FrakClient;
+
+            const result = await getProductInformation(mockClient);
+
+            expect(result).toEqual(mockResponse);
+            expect(result.rewards).toHaveLength(1);
+            expect(result.maxReferrer).toBeDefined();
+            expect(result.maxReferee).toBeDefined();
+        });
+    });
+
+    describe("error handling", () => {
+        it("should propagate errors from client.request", async () => {
+            const error = new Error("RPC request failed");
+            const mockClient = {
+                request: vi.fn().mockRejectedValue(error),
+            } as unknown as FrakClient;
+
+            await expect(getProductInformation(mockClient)).rejects.toThrow(
+                "RPC request failed"
+            );
+        });
+
+        it("should handle network timeout errors", async () => {
+            const error = new Error("Request timeout");
+            const mockClient = {
+                request: vi.fn().mockRejectedValue(error),
+            } as unknown as FrakClient;
+
+            await expect(getProductInformation(mockClient)).rejects.toThrow(
+                "Request timeout"
+            );
+        });
+    });
+});

package/src/actions/index.ts

@@ -1,29 +1,29 @@
-export { watchWalletStatus } from "./watchWalletStatus";
-export { sendInteraction } from "./sendInteraction";
-export { displayModal } from "./displayModal";
 export { displayEmbeddedWallet } from "./displayEmbeddedWallet";
+export { displayModal } from "./displayModal";
+export { getProductInformation } from "./getProductInformation";
 export { openSso } from "./openSso";
 export { prepareSso } from "./prepareSso";
-export { getProductInformation } from "./getProductInformation";
+export {
+    type ProcessReferralOptions,
+    processReferral,
+} from "./referral/processReferral";
+// Referral interaction
+export { referralInteraction } from "./referral/referralInteraction";
+export { sendInteraction } from "./sendInteraction";
 // Helper to track the purchase status
 export { trackPurchaseStatus } from "./trackPurchaseStatus";
-// Modal wrappers
+export { watchWalletStatus } from "./watchWalletStatus";
 export {
-    siweAuthenticate,
-    type SiweAuthenticateModalParams,
-} from "./wrapper/siweAuthenticate";
+    type ModalBuilder,
+    type ModalStepBuilder,
+    modalBuilder,
+} from "./wrapper/modalBuilder";
 export {
-    sendTransaction,
     type SendTransactionParams,
+    sendTransaction,
 } from "./wrapper/sendTransaction";
+// Modal wrappers
 export {
-    modalBuilder,
-    type ModalStepBuilder,
-    type ModalBuilder,
-} from "./wrapper/modalBuilder";
-// Referral interaction
-export { referralInteraction } from "./referral/referralInteraction";
-export {
-    processReferral,
-    type ProcessReferralOptions,
-} from "./referral/processReferral";
+    type SiweAuthenticateModalParams,
+    siweAuthenticate,
+} from "./wrapper/siweAuthenticate";

package/src/actions/openSso.test.ts

@@ -0,0 +1,407 @@
+/**
+ * Tests for openSso action
+ * Tests SSO flows in both redirect and popup modes
+ */
+
+import { vi } from "vitest";
+
+// Mock utilities before imports
+vi.mock("../utils/sso", () => ({
+    generateSsoUrl: vi.fn((walletUrl, _args, productId, name, _css) => {
+        return `${walletUrl}/sso?name=${name}&productId=${productId}`;
+    }),
+}));
+
+vi.mock("../utils/computeProductId", () => ({
+    computeProductId: vi.fn(
+        () =>
+            "0x1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef"
+    ),
+}));
+
+import {
+    afterEach,
+    beforeEach,
+    describe,
+    expect,
+    it,
+} from "../../tests/vitest-fixtures";
+import type {
+    FrakClient,
+    OpenSsoParamsType,
+    OpenSsoReturnType,
+} from "../types";
+import { openSso, ssoPopupFeatures, ssoPopupName } from "./openSso";
+
+describe("openSso", () => {
+    describe("constants", () => {
+        it("should have correct popup features", () => {
+            expect(ssoPopupFeatures).toBe(
+                "menubar=no,status=no,scrollbars=no,fullscreen=no,width=500, height=800"
+            );
+        });
+
+        it("should have correct popup name", () => {
+            expect(ssoPopupName).toBe("frak-sso");
+        });
+    });
+
+    describe("redirect mode", () => {
+        it("should use redirect mode when openInSameWindow is true", async () => {
+            const mockResponse: OpenSsoReturnType = {
+                wallet: "0x1234567890123456789012345678901234567890",
+            };
+
+            const mockClient = {
+                config: {
+                    metadata: { name: "Test App" },
+                },
+                request: vi.fn().mockResolvedValue(mockResponse),
+            } as unknown as FrakClient;
+
+            const params: OpenSsoParamsType = {
+                openInSameWindow: true,
+                metadata: {
+                    logoUrl: "https://example.com/logo.png",
+                },
+            };
+
+            const result = await openSso(mockClient, params);
+
+            expect(mockClient.request).toHaveBeenCalledWith({
+                method: "frak_openSso",
+                params: [params, "Test App", undefined],
+            });
+            expect(result).toEqual(mockResponse);
+        });
+
+        it("should use redirect mode when redirectUrl is provided", async () => {
+            const mockResponse: OpenSsoReturnType = {
+                wallet: "0xabcdefabcdefabcdefabcdefabcdefabcdefabcd",
+            };
+
+            const mockClient = {
+                config: {
+                    metadata: { name: "Test App" },
+                },
+                request: vi.fn().mockResolvedValue(mockResponse),
+            } as unknown as FrakClient;
+
+            const params: OpenSsoParamsType = {
+                redirectUrl: "https://example.com/callback",
+                metadata: {
+                    logoUrl: "https://example.com/logo.png",
+                },
+            };
+
+            const result = await openSso(mockClient, params);
+
+            expect(mockClient.request).toHaveBeenCalledWith({
+                method: "frak_openSso",
+                params: [params, "Test App", undefined],
+            });
+            expect(result).toEqual(mockResponse);
+        });
+
+        it("should pass custom CSS in redirect mode", async () => {
+            const mockResponse: OpenSsoReturnType = {};
+
+            const mockClient = {
+                config: {
+                    metadata: { name: "Test App" },
+                    customizations: {
+                        css: ":root { --primary: blue; }",
+                    },
+                },
+                request: vi.fn().mockResolvedValue(mockResponse),
+            } as unknown as FrakClient;
+
+            const params: OpenSsoParamsType = {
+                openInSameWindow: true,
+                metadata: {
+                    logoUrl: "https://example.com/logo.png",
+                },
+            };
+
+            await openSso(mockClient, params);
+
+            expect(mockClient.request).toHaveBeenCalledWith({
+                method: "frak_openSso",
+                params: [params, "Test App", ":root { --primary: blue; }"],
+            });
+        });
+    });
+
+    describe("popup mode", () => {
+        let windowOpenSpy: any;
+        let mockPopup: {
+            focus: ReturnType<typeof vi.fn>;
+        };
+
+        beforeEach(() => {
+            mockPopup = {
+                focus: vi.fn(),
+            };
+            windowOpenSpy = vi
+                .spyOn(window, "open")
+                .mockReturnValue(mockPopup as unknown as Window);
+        });
+
+        afterEach(() => {
+            windowOpenSpy.mockRestore();
+        });
+
+        it("should open popup with generated URL", async () => {
+            const mockResponse: OpenSsoReturnType = {
+                wallet: "0x1234567890123456789012345678901234567890",
+            };
+
+            const mockClient = {
+                config: {
+                    metadata: { name: "Test App" },
+                    walletUrl: "https://wallet.frak.id",
+                },
+                request: vi.fn().mockResolvedValue(mockResponse),
+            } as unknown as FrakClient;
+
+            const params: OpenSsoParamsType = {
+                metadata: {
+                    logoUrl: "https://example.com/logo.png",
+                },
+            };
+
+            await openSso(mockClient, params);
+
+            expect(window.open).toHaveBeenCalledWith(
+                expect.stringContaining("https://wallet.frak.id/sso"),
+                "frak-sso",
+                "menubar=no,status=no,scrollbars=no,fullscreen=no,width=500, height=800"
+            );
+        });
+
+        it("should use custom ssoPopupUrl when provided", async () => {
+            const mockResponse: OpenSsoReturnType = {};
+
+            const mockClient = {
+                config: {
+                    metadata: { name: "Test App" },
+                },
+                request: vi.fn().mockResolvedValue(mockResponse),
+            } as unknown as FrakClient;
+
+            const params: OpenSsoParamsType = {
+                ssoPopupUrl: "https://custom-wallet.com/sso?custom=param",
+                metadata: {
+                    logoUrl: "https://example.com/logo.png",
+                },
+            };
+
+            await openSso(mockClient, params);
+
+            expect(window.open).toHaveBeenCalledWith(
+                "https://custom-wallet.com/sso?custom=param",
+                "frak-sso",
+                "menubar=no,status=no,scrollbars=no,fullscreen=no,width=500, height=800"
+            );
+        });
+
+        it("should focus popup after opening", async () => {
+            const mockResponse: OpenSsoReturnType = {};
+
+            const mockClient = {
+                config: {
+                    metadata: { name: "Test App" },
+                },
+                request: vi.fn().mockResolvedValue(mockResponse),
+            } as unknown as FrakClient;
+
+            const params: OpenSsoParamsType = {
+                metadata: {
+                    logoUrl: "https://example.com/logo.png",
+                },
+            };
+
+            await openSso(mockClient, params);
+
+            expect(mockPopup.focus).toHaveBeenCalled();
+        });
+
+        it("should wait for SSO completion via client.request", async () => {
+            const mockResponse: OpenSsoReturnType = {
+                wallet: "0x1234567890123456789012345678901234567890",
+            };
+
+            const mockClient = {
+                config: {
+                    metadata: { name: "Test App" },
+                },
+                request: vi.fn().mockResolvedValue(mockResponse),
+            } as unknown as FrakClient;
+
+            const params: OpenSsoParamsType = {
+                metadata: {
+                    logoUrl: "https://example.com/logo.png",
+                },
+            };
+
+            const result = await openSso(mockClient, params);
+
+            expect(mockClient.request).toHaveBeenCalledWith({
+                method: "frak_openSso",
+                params: [params, "Test App", undefined],
+            });
+            expect(result).toEqual(mockResponse);
+        });
+
+        it("should return empty object when result is null", async () => {
+            const mockClient = {
+                config: {
+                    metadata: { name: "Test App" },
+                },
+                request: vi.fn().mockResolvedValue(null),
+            } as unknown as FrakClient;
+
+            const params: OpenSsoParamsType = {
+                metadata: {
+                    logoUrl: "https://example.com/logo.png",
+                },
+            };
+
+            const result = await openSso(mockClient, params);
+
+            expect(result).toEqual({});
+        });
+
+        it("should use default wallet URL when not configured", async () => {
+            const mockResponse: OpenSsoReturnType = {};
+
+            const mockClient = {
+                config: {
+                    metadata: { name: "Test App" },
+                },
+                request: vi.fn().mockResolvedValue(mockResponse),
+            } as unknown as FrakClient;
+
+            const params: OpenSsoParamsType = {
+                metadata: {
+                    logoUrl: "https://example.com/logo.png",
+                },
+            };
+
+            await openSso(mockClient, params);
+
+            expect(window.open).toHaveBeenCalledWith(
+                expect.stringContaining("https://wallet.frak.id/sso"),
+                expect.any(String),
+                expect.any(String)
+            );
+        });
+    });
+
+    describe("popup blocker", () => {
+        it("should throw error when popup is blocked", async () => {
+            vi.spyOn(window, "open").mockReturnValue(null);
+
+            const mockClient = {
+                config: {
+                    metadata: { name: "Test App" },
+                },
+                request: vi.fn(),
+            } as unknown as FrakClient;
+
+            const params: OpenSsoParamsType = {
+                metadata: {
+                    logoUrl: "https://example.com/logo.png",
+                },
+            };
+
+            await expect(openSso(mockClient, params)).rejects.toThrow(
+                "Popup was blocked. Please allow popups for this site."
+            );
+        });
+
+        it("should not call client.request when popup is blocked", async () => {
+            vi.spyOn(window, "open").mockReturnValue(null);
+
+            const mockClient = {
+                config: {
+                    metadata: { name: "Test App" },
+                },
+                request: vi.fn(),
+            } as unknown as FrakClient;
+
+            const params: OpenSsoParamsType = {
+                metadata: {
+                    logoUrl: "https://example.com/logo.png",
+                },
+            };
+
+            try {
+                await openSso(mockClient, params);
+            } catch {
+                // Expected error
+            }
+
+            expect(mockClient.request).not.toHaveBeenCalled();
+        });
+    });
+
+    describe("mode detection", () => {
+        it("should prefer openInSameWindow over redirectUrl", async () => {
+            const mockResponse: OpenSsoReturnType = {};
+
+            const mockClient = {
+                config: {
+                    metadata: { name: "Test App" },
+                },
+                request: vi.fn().mockResolvedValue(mockResponse),
+            } as unknown as FrakClient;
+
+            const params: OpenSsoParamsType = {
+                openInSameWindow: false,
+                redirectUrl: "https://example.com/callback",
+                metadata: {
+                    logoUrl: "https://example.com/logo.png",
+                },
+            };
+
+            const windowOpenSpy = vi.spyOn(window, "open").mockReturnValue({
+                focus: vi.fn(),
+            } as unknown as Window);
+
+            await openSso(mockClient, params);
+
+            // Should use popup mode because openInSameWindow=false
+            expect(window.open).toHaveBeenCalled();
+
+            windowOpenSpy.mockRestore();
+        });
+
+        it("should use popup mode when neither flag is set", async () => {
+            const mockResponse: OpenSsoReturnType = {};
+
+            const mockClient = {
+                config: {
+                    metadata: { name: "Test App" },
+                },
+                request: vi.fn().mockResolvedValue(mockResponse),
+            } as unknown as FrakClient;
+
+            const params: OpenSsoParamsType = {
+                metadata: {
+                    logoUrl: "https://example.com/logo.png",
+                },
+            };
+
+            const windowOpenSpy = vi.spyOn(window, "open").mockReturnValue({
+                focus: vi.fn(),
+            } as unknown as Window);
+
+            await openSso(mockClient, params);
+
+            expect(window.open).toHaveBeenCalled();
+
+            windowOpenSpy.mockRestore();
+        });
+    });
+});