@frak-labs/core-sdk 0.1.0-beta.8d103039 → 0.1.0-beta.b0bd1f8a

package/src/actions/displayModal.test.ts

@@ -0,0 +1,387 @@
+/**
+ * Tests for displayModal action
+ * Tests modal display via RPC with various step configurations
+ */
+
+import type { Address } from "viem";
+import { describe, expect, it, vi } from "../../tests/vitest-fixtures";
+import type {
+    DisplayModalParamsType,
+    FrakClient,
+    ModalStepTypes,
+} from "../types";
+import { displayModal } from "./displayModal";
+
+describe("displayModal", () => {
+    describe("basic modal display", () => {
+        it("should call client.request with correct method and params", async () => {
+            const mockResponse = {
+                login: {
+                    wallet: "0x1234567890123456789012345678901234567890" as Address,
+                },
+            };
+
+            const mockClient = {
+                config: {
+                    metadata: {
+                        name: "Test App",
+                    },
+                },
+                request: vi.fn().mockResolvedValue(mockResponse),
+            } as unknown as FrakClient;
+
+            const params: DisplayModalParamsType<ModalStepTypes[]> = {
+                steps: {
+                    login: { allowSso: true },
+                },
+            };
+
+            await displayModal(mockClient, params);
+
+            expect(mockClient.request).toHaveBeenCalledWith({
+                method: "frak_displayModal",
+                params: [params.steps, params.metadata, { name: "Test App" }],
+            });
+        });
+
+        it("should return modal results", async () => {
+            const mockResponse = {
+                login: {
+                    wallet: "0xabcdefabcdefabcdefabcdefabcdefabcdefabcd" as Address,
+                },
+            };
+
+            const mockClient = {
+                config: {
+                    metadata: {
+                        name: "Test App",
+                    },
+                },
+                request: vi.fn().mockResolvedValue(mockResponse),
+            } as unknown as FrakClient;
+
+            const params: DisplayModalParamsType<ModalStepTypes[]> = {
+                steps: {
+                    login: { allowSso: false },
+                },
+            };
+
+            const result = await displayModal(mockClient, params);
+
+            expect(result).toEqual(mockResponse);
+        });
+    });
+
+    describe("modal with multiple steps", () => {
+        it("should handle login + openSession steps", async () => {
+            const mockResponse = {
+                login: {
+                    wallet: "0x1234567890123456789012345678901234567890" as Address,
+                },
+                openSession: {
+                    startTimestamp: 1234567890,
+                    endTimestamp: 1234567900,
+                },
+            };
+
+            const mockClient = {
+                config: {
+                    metadata: {
+                        name: "Test App",
+                    },
+                },
+                request: vi.fn().mockResolvedValue(mockResponse),
+            } as unknown as FrakClient;
+
+            const params: DisplayModalParamsType<ModalStepTypes[]> = {
+                steps: {
+                    login: { allowSso: true },
+                    openSession: {},
+                },
+            };
+
+            const result = await displayModal(mockClient, params);
+
+            expect(result).toEqual(mockResponse);
+        });
+
+        it("should handle full modal flow", async () => {
+            const mockResponse = {
+                login: {
+                    wallet: "0x1234567890123456789012345678901234567890" as Address,
+                },
+                openSession: {
+                    startTimestamp: 1234567890,
+                    endTimestamp: 1234567900,
+                },
+                sendTransaction: {
+                    hash: "0xtxhash" as `0x${string}`,
+                },
+                final: {},
+            };
+
+            const mockClient = {
+                config: {
+                    metadata: {
+                        name: "Test App",
+                        logoUrl: "https://example.com/logo.png",
+                    },
+                },
+                request: vi.fn().mockResolvedValue(mockResponse),
+            } as unknown as FrakClient;
+
+            const params: DisplayModalParamsType<ModalStepTypes[]> = {
+                steps: {
+                    login: { allowSso: true },
+                    openSession: {},
+                    sendTransaction: {
+                        tx: [
+                            {
+                                to: "0xdeadbeef" as Address,
+                                data: "0xdata" as `0x${string}`,
+                            },
+                        ],
+                    },
+                    final: {
+                        action: { key: "reward" },
+                    },
+                },
+            };
+
+            const result = await displayModal(mockClient, params);
+
+            expect(result).toEqual(mockResponse);
+        });
+    });
+
+    describe("modal with metadata", () => {
+        it("should pass metadata to request", async () => {
+            const mockResponse = {
+                login: {
+                    wallet: "0x1234567890123456789012345678901234567890" as Address,
+                },
+            };
+
+            const mockClient = {
+                config: {
+                    metadata: {
+                        name: "Test App",
+                    },
+                },
+                request: vi.fn().mockResolvedValue(mockResponse),
+            } as unknown as FrakClient;
+
+            const params: DisplayModalParamsType<ModalStepTypes[]> = {
+                steps: {
+                    login: { allowSso: true },
+                },
+                metadata: {
+                    header: {
+                        title: "My Custom Title",
+                        icon: "https://example.com/icon.png",
+                    },
+                },
+            };
+
+            await displayModal(mockClient, params);
+
+            expect(mockClient.request).toHaveBeenCalledWith({
+                method: "frak_displayModal",
+                params: [
+                    params.steps,
+                    {
+                        header: {
+                            title: "My Custom Title",
+                            icon: "https://example.com/icon.png",
+                        },
+                    },
+                    { name: "Test App" },
+                ],
+            });
+        });
+
+        it("should work without metadata", async () => {
+            const mockResponse = {
+                login: {
+                    wallet: "0x1234567890123456789012345678901234567890" as Address,
+                },
+            };
+
+            const mockClient = {
+                config: {
+                    metadata: {
+                        name: "Test App",
+                    },
+                },
+                request: vi.fn().mockResolvedValue(mockResponse),
+            } as unknown as FrakClient;
+
+            const params: DisplayModalParamsType<ModalStepTypes[]> = {
+                steps: {
+                    login: { allowSso: true },
+                },
+            };
+
+            await displayModal(mockClient, params);
+
+            expect(mockClient.request).toHaveBeenCalledWith({
+                method: "frak_displayModal",
+                params: [params.steps, undefined, { name: "Test App" }],
+            });
+        });
+    });
+
+    describe("modal with SSO metadata", () => {
+        it("should handle SSO metadata in login step", async () => {
+            const mockResponse = {
+                login: {
+                    wallet: "0x1234567890123456789012345678901234567890" as Address,
+                },
+            };
+
+            const mockClient = {
+                config: {
+                    metadata: {
+                        name: "Test App",
+                    },
+                },
+                request: vi.fn().mockResolvedValue(mockResponse),
+            } as unknown as FrakClient;
+
+            const params: DisplayModalParamsType<ModalStepTypes[]> = {
+                steps: {
+                    login: {
+                        allowSso: true,
+                        ssoMetadata: {
+                            logoUrl: "https://example.com/logo.png",
+                            homepageLink: "https://example.com",
+                        },
+                    },
+                },
+            };
+
+            await displayModal(mockClient, params);
+
+            expect(mockClient.request).toHaveBeenCalledWith({
+                method: "frak_displayModal",
+                params: [params.steps, undefined, { name: "Test App" }],
+            });
+        });
+    });
+
+    describe("modal with sharing action", () => {
+        it("should handle sharing final action", async () => {
+            const mockResponse = {
+                final: {},
+            };
+
+            const mockClient = {
+                config: {
+                    metadata: {
+                        name: "Test App",
+                    },
+                },
+                request: vi.fn().mockResolvedValue(mockResponse),
+            } as unknown as FrakClient;
+
+            const params: DisplayModalParamsType<ModalStepTypes[]> = {
+                steps: {
+                    final: {
+                        action: {
+                            key: "sharing",
+                            options: {
+                                popupTitle: "Share the app",
+                                text: "Discover my app",
+                                link: "https://example.com",
+                            },
+                        },
+                    },
+                },
+            };
+
+            await displayModal(mockClient, params);
+
+            expect(mockClient.request).toHaveBeenCalledWith({
+                method: "frak_displayModal",
+                params: [params.steps, undefined, { name: "Test App" }],
+            });
+        });
+
+        it("should handle reward final action", async () => {
+            const mockResponse = {
+                final: {},
+            };
+
+            const mockClient = {
+                config: {
+                    metadata: {
+                        name: "Test App",
+                    },
+                },
+                request: vi.fn().mockResolvedValue(mockResponse),
+            } as unknown as FrakClient;
+
+            const params: DisplayModalParamsType<ModalStepTypes[]> = {
+                steps: {
+                    final: {
+                        action: { key: "reward" },
+                        autoSkip: true,
+                    },
+                },
+            };
+
+            await displayModal(mockClient, params);
+
+            expect(mockClient.request).toHaveBeenCalledWith({
+                method: "frak_displayModal",
+                params: [params.steps, undefined, { name: "Test App" }],
+            });
+        });
+    });
+
+    describe("error handling", () => {
+        it("should propagate errors from client.request", async () => {
+            const error = new Error("Modal display failed");
+            const mockClient = {
+                config: {
+                    metadata: {
+                        name: "Test App",
+                    },
+                },
+                request: vi.fn().mockRejectedValue(error),
+            } as unknown as FrakClient;
+
+            const params: DisplayModalParamsType<ModalStepTypes[]> = {
+                steps: {
+                    login: { allowSso: true },
+                },
+            };
+
+            await expect(displayModal(mockClient, params)).rejects.toThrow(
+                "Modal display failed"
+            );
+        });
+
+        it("should handle network errors", async () => {
+            const error = new Error("Network timeout");
+            const mockClient = {
+                config: {
+                    metadata: {
+                        name: "Test App",
+                    },
+                },
+                request: vi.fn().mockRejectedValue(error),
+            } as unknown as FrakClient;
+
+            const params: DisplayModalParamsType<ModalStepTypes[]> = {
+                steps: {
+                    openSession: {},
+                },
+            };
+
+            await expect(displayModal(mockClient, params)).rejects.toThrow(
+                "Network timeout"
+            );
+        });
+    });
+});

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