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

package/package.json

@@ -11,7 +11,7 @@
       "url": "https://twitter.com/QNivelais"
     }
   ],
-  "version": "0.0.19",
+  "version": "0.1.0-beta.278e9605",
   "description": "Core SDK of the Frak wallet, low level library to interact directly with the frak ecosystem.",
   "repository": {
     "url": "https://github.com/frak-id/wallet",
@@ -34,11 +34,13 @@
   "type": "module",
   "files": [
     "/dist",
-    "/cdn"
+    "/cdn",
+    "/src"
   ],
   "browser": "./cdn/bundle.js",
   "exports": {
     ".": {
+      "development": "./src/index.ts",
       "import": {
         "types": "./dist/index.d.ts",
         "default": "./dist/index.js"
@@ -49,6 +51,7 @@
       }
     },
     "./actions": {
+      "development": "./src/actions/index.ts",
       "import": {
         "types": "./dist/actions.d.ts",
         "default": "./dist/actions.js"
@@ -59,6 +62,7 @@
       }
     },
     "./interactions": {
+      "development": "./src/interactions/index.ts",
       "import": {
         "types": "./dist/interactions.d.ts",
         "default": "./dist/interactions.js"
@@ -83,32 +87,37 @@
     "lint": "biome lint .",
     "format:check": "biome check .",
     "format": "biome check --write .",
-    "clean": "rimraf dist",
-    "build": "rslib build",
-    "build:watch": "rslib build --watch",
+    "clean": "rimraf dist cdn",
+    "build": "tsdown",
+    "build:watch": "tsdown --watch",
     "check-exports": "attw --pack --profile node16 .",
     "typecheck": "tsc --noEmit",
+    "test": "vitest",
+    "test:ui": "vitest --ui",
+    "test:coverage": "vitest --coverage",
     "prepublish": "bun run lint && bun run build",
     "publish": "echo 'Publishing core...'"
   },
   "peerDependencies": {
-    "viem": "^2.23.14"
+    "viem": "^2.x"
   },
   "dependencies": {
-    "@jsonjoy.com/json-pack": "^1.2.0",
+    "@frak-labs/frame-connector": "0.1.0",
+    "@jsonjoy.com/json-pack": "^1.21.0",
     "@openpanel/web": "^1.0.1"
   },
   "devDependencies": {
     "@arethetypeswrong/cli": "^0.18.2",
     "@frak-labs/dev-tooling": "0.0.0",
-    "@microsoft/api-extractor": "^7.52.8",
-    "@rsbuild/plugin-node-polyfill": "^1.3.0",
-    "@rslib/core": "^0.9.2",
-    "@types/node": "^24.0.1",
-    "dotenv": "^17.0.0",
-    "typescript": "^5.8.3"
-  },
-  "browserslist": [
-    "extends @frak-labs/browserslist-config"
-  ]
+    "@rolldown/plugin-node-polyfills": "^1.0.0",
+    "@types/jsdom": "^27.0.0",
+    "@types/node": "^24.10.0",
+    "@vitest/coverage-v8": "^4.0.8",
+    "@vitest/ui": "^4.0.8",
+    "jsdom": "^27.1.0",
+    "tsdown": "^0.16.1",
+    "typescript": "^5.9.3",
+    "viem": "^2.38.6",
+    "vitest": "^4.0.8"
+  }
 }

package/src/actions/displayEmbeddedWallet.test.ts

@@ -0,0 +1,194 @@
+/**
+ * Tests for displayEmbeddedWallet action
+ * Tests displaying embedded wallet via RPC
+ */
+
+import type { Address } from "viem";
+import { describe, expect, it, vi } from "../../tests/vitest-fixtures";
+import type {
+    DisplayEmbeddedWalletParamsType,
+    DisplayEmbeddedWalletResultType,
+    FrakClient,
+} from "../types";
+import { displayEmbeddedWallet } from "./displayEmbeddedWallet";
+
+describe("displayEmbeddedWallet", () => {
+    describe("success cases", () => {
+        it("should call client.request with correct method and params", async () => {
+            const mockParams: DisplayEmbeddedWalletParamsType = {
+                loggedIn: {
+                    action: {
+                        key: "sharing",
+                    },
+                },
+            };
+
+            const mockResponse: DisplayEmbeddedWalletResultType = {
+                wallet: "0x1234567890123456789012345678901234567890" as Address,
+            };
+
+            const mockClient = {
+                config: {
+                    metadata: {
+                        name: "Test App",
+                    },
+                },
+                request: vi.fn().mockResolvedValue(mockResponse),
+            } as unknown as FrakClient;
+
+            await displayEmbeddedWallet(mockClient, mockParams);
+
+            expect(mockClient.request).toHaveBeenCalledWith({
+                method: "frak_displayEmbeddedWallet",
+                params: [mockParams, { name: "Test App" }],
+            });
+        });
+
+        it("should return wallet address", async () => {
+            const mockParams: DisplayEmbeddedWalletParamsType = {
+                loggedIn: {
+                    action: {
+                        key: "sharing",
+                    },
+                },
+            };
+
+            const mockResponse: DisplayEmbeddedWalletResultType = {
+                wallet: "0xabcdefabcdefabcdefabcdefabcdefabcdefabcd" as Address,
+            };
+
+            const mockClient = {
+                config: {
+                    metadata: {
+                        name: "Test App",
+                    },
+                },
+                request: vi.fn().mockResolvedValue(mockResponse),
+            } as unknown as FrakClient;
+
+            const result = await displayEmbeddedWallet(mockClient, mockParams);
+
+            expect(result).toEqual(mockResponse);
+            expect(result.wallet).toBe(
+                "0xabcdefabcdefabcdefabcdefabcdefabcdefabcd"
+            );
+        });
+
+        it("should handle loggedOut view params", async () => {
+            const mockParams: DisplayEmbeddedWalletParamsType = {
+                loggedOut: {
+                    metadata: {
+                        text: "Login to get rewards",
+                    },
+                },
+            };
+
+            const mockResponse: DisplayEmbeddedWalletResultType = {
+                wallet: "0x1234567890123456789012345678901234567890" as Address,
+            };
+
+            const mockClient = {
+                config: {
+                    metadata: {
+                        name: "Test App",
+                        logoUrl: "https://example.com/logo.png",
+                    },
+                },
+                request: vi.fn().mockResolvedValue(mockResponse),
+            } as unknown as FrakClient;
+
+            await displayEmbeddedWallet(mockClient, mockParams);
+
+            expect(mockClient.request).toHaveBeenCalledWith({
+                method: "frak_displayEmbeddedWallet",
+                params: [
+                    mockParams,
+                    {
+                        name: "Test App",
+                        logoUrl: "https://example.com/logo.png",
+                    },
+                ],
+            });
+        });
+
+        it("should handle referred action", async () => {
+            const mockParams: DisplayEmbeddedWalletParamsType = {
+                loggedIn: {
+                    action: {
+                        key: "referred",
+                    },
+                },
+            };
+
+            const mockResponse: DisplayEmbeddedWalletResultType = {
+                wallet: "0x1234567890123456789012345678901234567890" as Address,
+            };
+
+            const mockClient = {
+                config: {
+                    metadata: {
+                        name: "Test App",
+                    },
+                },
+                request: vi.fn().mockResolvedValue(mockResponse),
+            } as unknown as FrakClient;
+
+            const result = await displayEmbeddedWallet(mockClient, mockParams);
+
+            expect(result).toEqual(mockResponse);
+        });
+
+        it("should pass client metadata to request", async () => {
+            const mockParams: DisplayEmbeddedWalletParamsType = {};
+
+            const mockMetadata = {
+                name: "My App",
+                logoUrl: "https://example.com/logo.png",
+                css: "body { color: red; }",
+                lang: "fr" as const,
+            };
+
+            const mockClient = {
+                config: {
+                    metadata: mockMetadata,
+                },
+                request: vi.fn().mockResolvedValue({
+                    wallet: "0x1234567890123456789012345678901234567890" as Address,
+                }),
+            } as unknown as FrakClient;
+
+            await displayEmbeddedWallet(mockClient, mockParams);
+
+            expect(mockClient.request).toHaveBeenCalledWith({
+                method: "frak_displayEmbeddedWallet",
+                params: [mockParams, mockMetadata],
+            });
+        });
+    });
+
+    describe("error handling", () => {
+        it("should propagate errors from client.request", async () => {
+            const mockParams: DisplayEmbeddedWalletParamsType = {
+                loggedIn: {
+                    action: {
+                        key: "sharing",
+                    },
+                },
+            };
+
+            const error = new Error("Display failed");
+            const mockClient = {
+                config: {
+                    metadata: {
+                        name: "Test App",
+                    },
+                },
+                request: vi.fn().mockRejectedValue(error),
+            } as unknown as FrakClient;
+
+            await expect(
+                displayEmbeddedWallet(mockClient, mockParams)
+            ).rejects.toThrow("Display failed");
+        });
+    });
+});

package/src/actions/displayEmbeddedWallet.ts

@@ -0,0 +1,20 @@
+import type {
+    DisplayEmbeddedWalletParamsType,
+    DisplayEmbeddedWalletResultType,
+    FrakClient,
+} from "../types";
+
+/**
+ * Function used to display the Frak embedded wallet popup
+ * @param client - The current Frak Client
+ * @param params - The parameter used to customise the embedded wallet
+ */
+export async function displayEmbeddedWallet(
+    client: FrakClient,
+    params: DisplayEmbeddedWalletParamsType
+): Promise<DisplayEmbeddedWalletResultType> {
+    return await client.request({
+        method: "frak_displayEmbeddedWallet",
+        params: [params, client.config.metadata],
+    });
+}

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"
+            );
+        });
+    });
+});