@frak-labs/core-sdk 0.1.0 → 0.1.1-beta.1e44255d

package/src/actions/watchWalletStatus.test.ts

@@ -0,0 +1,372 @@
+/**
+ * Tests for watchWalletStatus action
+ * Tests wallet status watching and side effects
+ */
+
+import { vi } from "vitest";
+
+// Mock Deferred before imports
+vi.mock("@frak-labs/frame-connector", () => ({
+    Deferred: class {
+        promise: Promise<any>;
+        resolve: (value: any) => void;
+
+        constructor() {
+            let resolveFunc: (value: any) => void;
+            this.promise = new Promise((resolve) => {
+                resolveFunc = resolve;
+            });
+            this.resolve = resolveFunc!;
+        }
+    },
+}));
+
+import type { Address } from "viem";
+import {
+    afterEach,
+    beforeEach,
+    describe,
+    expect,
+    it,
+} from "../../tests/vitest-fixtures";
+import type { FrakClient, WalletStatusReturnType } from "../types";
+import { watchWalletStatus } from "./watchWalletStatus";
+
+describe("watchWalletStatus", () => {
+    let mockSessionStorage: {
+        getItem: ReturnType<typeof vi.fn>;
+        setItem: ReturnType<typeof vi.fn>;
+        removeItem: ReturnType<typeof vi.fn>;
+    };
+
+    beforeEach(() => {
+        // Mock sessionStorage
+        mockSessionStorage = {
+            getItem: vi.fn(),
+            setItem: vi.fn(),
+            removeItem: vi.fn(),
+        };
+        Object.defineProperty(window, "sessionStorage", {
+            value: mockSessionStorage,
+            writable: true,
+            configurable: true,
+        });
+    });
+
+    afterEach(() => {
+        vi.clearAllMocks();
+    });
+
+    describe("without callback", () => {
+        it("should make one-shot request", async () => {
+            const mockStatus: WalletStatusReturnType = {
+                key: "connected",
+                wallet: "0x1234567890123456789012345678901234567890" as Address,
+                interactionToken: "token-123",
+            };
+
+            const mockClient = {
+                request: vi.fn().mockResolvedValue(mockStatus),
+                openPanel: {
+                    setGlobalProperties: vi.fn(),
+                },
+            } as unknown as FrakClient;
+
+            const result = await watchWalletStatus(mockClient);
+
+            expect(mockClient.request).toHaveBeenCalledWith({
+                method: "frak_listenToWalletStatus",
+            });
+            expect(result).toEqual(mockStatus);
+        });
+
+        it("should save interaction token to sessionStorage", async () => {
+            const mockStatus: WalletStatusReturnType = {
+                key: "connected",
+                wallet: "0x1234567890123456789012345678901234567890" as Address,
+                interactionToken: "token-abc",
+            };
+
+            const mockClient = {
+                request: vi.fn().mockResolvedValue(mockStatus),
+                openPanel: {
+                    setGlobalProperties: vi.fn(),
+                },
+            } as unknown as FrakClient;
+
+            await watchWalletStatus(mockClient);
+
+            expect(mockSessionStorage.setItem).toHaveBeenCalledWith(
+                "frak-wallet-interaction-token",
+                "token-abc"
+            );
+        });
+
+        it("should remove interaction token when not present", async () => {
+            const mockStatus: WalletStatusReturnType = {
+                key: "not-connected",
+            };
+
+            const mockClient = {
+                request: vi.fn().mockResolvedValue(mockStatus),
+                openPanel: {
+                    setGlobalProperties: vi.fn(),
+                },
+            } as unknown as FrakClient;
+
+            await watchWalletStatus(mockClient);
+
+            expect(mockSessionStorage.removeItem).toHaveBeenCalledWith(
+                "frak-wallet-interaction-token"
+            );
+        });
+
+        it("should update OpenPanel global properties", async () => {
+            const mockStatus: WalletStatusReturnType = {
+                key: "connected",
+                wallet: "0xabcdefabcdefabcdefabcdefabcdefabcdefabcd" as Address,
+            };
+
+            const mockClient = {
+                request: vi.fn().mockResolvedValue(mockStatus),
+                openPanel: {
+                    setGlobalProperties: vi.fn(),
+                },
+            } as unknown as FrakClient;
+
+            await watchWalletStatus(mockClient);
+
+            expect(
+                mockClient.openPanel?.setGlobalProperties
+            ).toHaveBeenCalledWith({
+                wallet: "0xabcdefabcdefabcdefabcdefabcdefabcdefabcd",
+            });
+        });
+
+        it("should set wallet to null when not connected", async () => {
+            const mockStatus: WalletStatusReturnType = {
+                key: "not-connected",
+            };
+
+            const mockClient = {
+                request: vi.fn().mockResolvedValue(mockStatus),
+                openPanel: {
+                    setGlobalProperties: vi.fn(),
+                },
+            } as unknown as FrakClient;
+
+            await watchWalletStatus(mockClient);
+
+            expect(
+                mockClient.openPanel?.setGlobalProperties
+            ).toHaveBeenCalledWith({
+                wallet: null,
+            });
+        });
+
+        it("should work without openPanel", async () => {
+            const mockStatus: WalletStatusReturnType = {
+                key: "connected",
+                wallet: "0x1234567890123456789012345678901234567890" as Address,
+            };
+
+            const mockClient = {
+                request: vi.fn().mockResolvedValue(mockStatus),
+            } as unknown as FrakClient;
+
+            const result = await watchWalletStatus(mockClient);
+
+            expect(result).toEqual(mockStatus);
+        });
+    });
+
+    describe("with callback", () => {
+        it("should setup listener request", async () => {
+            const mockStatus: WalletStatusReturnType = {
+                key: "connected",
+                wallet: "0x1234567890123456789012345678901234567890" as Address,
+            };
+
+            const mockCallback = vi.fn();
+            const mockClient = {
+                listenerRequest: vi.fn((_params, callback) => {
+                    // Simulate status update
+                    setTimeout(() => callback(mockStatus), 0);
+                }),
+                openPanel: {
+                    setGlobalProperties: vi.fn(),
+                },
+            } as unknown as FrakClient;
+
+            const resultPromise = watchWalletStatus(mockClient, mockCallback);
+
+            expect(mockClient.listenerRequest).toHaveBeenCalled();
+
+            await resultPromise;
+        });
+
+        it("should call callback with status updates", async () => {
+            const mockStatus: WalletStatusReturnType = {
+                key: "connected",
+                wallet: "0x1234567890123456789012345678901234567890" as Address,
+                interactionToken: "token-123",
+            };
+
+            const mockCallback = vi.fn();
+            const mockClient = {
+                listenerRequest: vi.fn((_params, callback) => {
+                    setTimeout(() => callback(mockStatus), 0);
+                }),
+                openPanel: {
+                    setGlobalProperties: vi.fn(),
+                },
+            } as unknown as FrakClient;
+
+            await watchWalletStatus(mockClient, mockCallback);
+
+            expect(mockCallback).toHaveBeenCalledWith(mockStatus);
+        });
+
+        it("should resolve promise with first status", async () => {
+            const firstStatus: WalletStatusReturnType = {
+                key: "connected",
+                wallet: "0x1234567890123456789012345678901234567890" as Address,
+            };
+
+            const secondStatus: WalletStatusReturnType = {
+                key: "connected",
+                wallet: "0xabcdefabcdefabcdefabcdefabcdefabcdefabcd" as Address,
+            };
+
+            const mockCallback = vi.fn();
+            const mockClient = {
+                listenerRequest: vi.fn((_params, callback) => {
+                    setTimeout(() => {
+                        callback(firstStatus);
+                        callback(secondStatus);
+                    }, 0);
+                }),
+                openPanel: {
+                    setGlobalProperties: vi.fn(),
+                },
+            } as unknown as FrakClient;
+
+            const result = await watchWalletStatus(mockClient, mockCallback);
+
+            expect(result).toEqual(firstStatus);
+            expect(mockCallback).toHaveBeenCalledTimes(2);
+        });
+
+        it("should handle side effects for each status update", async () => {
+            const firstStatus: WalletStatusReturnType = {
+                key: "connected",
+                wallet: "0x1234567890123456789012345678901234567890" as Address,
+                interactionToken: "token-1",
+            };
+
+            const secondStatus: WalletStatusReturnType = {
+                key: "connected",
+                wallet: "0x1234567890123456789012345678901234567890" as Address,
+                interactionToken: "token-2",
+            };
+
+            const mockCallback = vi.fn();
+            const mockClient = {
+                listenerRequest: vi.fn((_params, callback) => {
+                    setTimeout(() => {
+                        callback(firstStatus);
+                        callback(secondStatus);
+                    }, 0);
+                }),
+                openPanel: {
+                    setGlobalProperties: vi.fn(),
+                },
+            } as unknown as FrakClient;
+
+            await watchWalletStatus(mockClient, mockCallback);
+
+            // Both tokens should be saved
+            expect(mockSessionStorage.setItem).toHaveBeenCalledWith(
+                "frak-wallet-interaction-token",
+                "token-1"
+            );
+            expect(mockSessionStorage.setItem).toHaveBeenCalledWith(
+                "frak-wallet-interaction-token",
+                "token-2"
+            );
+        });
+
+        it("should save and remove interaction token based on status", async () => {
+            const connectedStatus: WalletStatusReturnType = {
+                key: "connected",
+                wallet: "0x1234567890123456789012345678901234567890" as Address,
+                interactionToken: "token-123",
+            };
+
+            const disconnectedStatus: WalletStatusReturnType = {
+                key: "not-connected",
+            };
+
+            const mockCallback = vi.fn();
+            const mockClient = {
+                listenerRequest: vi.fn((_params, callback) => {
+                    setTimeout(() => {
+                        callback(connectedStatus);
+                        callback(disconnectedStatus);
+                    }, 0);
+                }),
+                openPanel: {
+                    setGlobalProperties: vi.fn(),
+                },
+            } as unknown as FrakClient;
+
+            await watchWalletStatus(mockClient, mockCallback);
+
+            expect(mockSessionStorage.setItem).toHaveBeenCalledWith(
+                "frak-wallet-interaction-token",
+                "token-123"
+            );
+            expect(mockSessionStorage.removeItem).toHaveBeenCalledWith(
+                "frak-wallet-interaction-token"
+            );
+        });
+
+        it("should update OpenPanel properties with each status", async () => {
+            const firstStatus: WalletStatusReturnType = {
+                key: "connected",
+                wallet: "0x1111111111111111111111111111111111111111" as Address,
+            };
+
+            const secondStatus: WalletStatusReturnType = {
+                key: "connected",
+                wallet: "0x2222222222222222222222222222222222222222" as Address,
+            };
+
+            const mockCallback = vi.fn();
+            const mockClient = {
+                listenerRequest: vi.fn((_params, callback) => {
+                    setTimeout(() => {
+                        callback(firstStatus);
+                        callback(secondStatus);
+                    }, 0);
+                }),
+                openPanel: {
+                    setGlobalProperties: vi.fn(),
+                },
+            } as unknown as FrakClient;
+
+            await watchWalletStatus(mockClient, mockCallback);
+
+            expect(
+                mockClient.openPanel?.setGlobalProperties
+            ).toHaveBeenCalledWith({
+                wallet: "0x1111111111111111111111111111111111111111",
+            });
+            expect(
+                mockClient.openPanel?.setGlobalProperties
+            ).toHaveBeenCalledWith({
+                wallet: "0x2222222222222222222222222222222222222222",
+            });
+        });
+    });
+});

package/src/actions/watchWalletStatus.ts

@@ -0,0 +1,93 @@
+import { Deferred } from "@frak-labs/frame-connector";
+import type { FrakClient } from "../types/client";
+import type { WalletStatusReturnType } from "../types/rpc/walletStatus";
+import { ensureIdentity } from "./ensureIdentity";
+
+/**
+ * Function used to watch the current frak wallet status
+ * @param client - The current Frak Client
+ * @param callback - The callback that will receive any wallet status change
+ * @returns A promise resolving with the initial wallet status
+ *
+ * @description This function will return the current wallet status, and will listen to any change in the wallet status.
+ *
+ * @example
+ * await watchWalletStatus(frakConfig, (status: WalletStatusReturnType) => {
+ *     if (status.key === "connected") {
+ *         console.log("Wallet connected:", status.wallet);
+ *     } else {
+ *         console.log("Wallet not connected");
+ *     }
+ * });
+ */
+export function watchWalletStatus(
+    client: FrakClient,
+    callback?: (status: WalletStatusReturnType) => void
+): Promise<WalletStatusReturnType> {
+    // If no callback is provided, just do a request with deferred result
+    if (!callback) {
+        return client
+            .request({ method: "frak_listenToWalletStatus" })
+            .then((result) => {
+                // Handle side effects of this request
+                walletStatusSideEffect(client, result);
+
+                // Return the result
+                return result;
+            });
+    }
+
+    // Otherwise, listen to the wallet status and return the first one received
+    const firstResult = new Deferred<WalletStatusReturnType>();
+    let hasResolved = false;
+
+    // Start the listening request, and return the first result
+    client.listenerRequest(
+        {
+            method: "frak_listenToWalletStatus",
+        },
+        (status) => {
+            // Handle side effects of this request
+            walletStatusSideEffect(client, status);
+
+            // Transmit the status to the callback
+            callback(status);
+
+            // If the promise hasn't resolved yet, resolve it
+            if (!hasResolved) {
+                firstResult.resolve(status);
+                hasResolved = true;
+            }
+        }
+    );
+
+    return firstResult.promise;
+}
+
+/**
+ * Helper to save a potential interaction token
+ * @param interactionToken
+ */
+function walletStatusSideEffect(
+    client: FrakClient,
+    status: WalletStatusReturnType
+) {
+    if (typeof window === "undefined") {
+        return;
+    }
+
+    // Update the global properties
+    client.openPanel?.setGlobalProperties({
+        wallet: status.wallet ?? null,
+    });
+
+    if (status.interactionToken) {
+        window.sessionStorage.setItem(
+            "frak-wallet-interaction-token",
+            status.interactionToken
+        );
+        ensureIdentity(status.interactionToken);
+    } else {
+        window.sessionStorage.removeItem("frak-wallet-interaction-token");
+    }
+}

package/src/actions/wrapper/modalBuilder.test.ts

@@ -0,0 +1,239 @@
+import { vi } from "vitest";
+
+vi.mock("../displayModal", () => ({
+    displayModal: vi.fn(),
+}));
+
+import type { Address } from "viem";
+import { describe, expect, it } from "../../../tests/vitest-fixtures";
+import type { FrakClient } from "../../types";
+import { modalBuilder } from "./modalBuilder";
+
+describe("modalBuilder", () => {
+    const mockClient = {
+        config: {
+            metadata: {
+                name: "Test App",
+            },
+        },
+        request: vi.fn(),
+    } as unknown as FrakClient;
+
+    describe("initialization", () => {
+        it("should create builder with base params", () => {
+            const builder = modalBuilder(mockClient, {});
+
+            expect(builder.params).toBeDefined();
+            expect(builder.params.steps.login).toEqual({});
+        });
+
+        it("should create builder with custom login params", () => {
+            const builder = modalBuilder(mockClient, {
+                login: { allowSso: true },
+            });
+
+            expect(builder.params.steps.login).toEqual({ allowSso: true });
+        });
+
+        it("should create builder with metadata", () => {
+            const builder = modalBuilder(mockClient, {
+                metadata: {
+                    header: { title: "Test Title" },
+                },
+            });
+
+            expect(builder.params.metadata).toEqual({
+                header: { title: "Test Title" },
+            });
+        });
+    });
+
+    describe("sendTx step", () => {
+        it("should add sendTransaction step", () => {
+            const builder = modalBuilder(mockClient, {});
+            const withTx = builder.sendTx({
+                tx: {
+                    to: "0x1234567890123456789012345678901234567890" as Address,
+                    data: "0xdata" as `0x${string}`,
+                },
+            });
+
+            expect(withTx.params.steps.sendTransaction).toEqual({
+                tx: {
+                    to: "0x1234567890123456789012345678901234567890",
+                    data: "0xdata",
+                },
+            });
+        });
+
+        it("should preserve previous steps when adding sendTx", () => {
+            const builder = modalBuilder(mockClient, {
+                login: { allowSso: true },
+            });
+            const withTx = builder.sendTx({
+                tx: {
+                    to: "0x1234567890123456789012345678901234567890" as Address,
+                },
+            });
+
+            expect(withTx.params.steps.login).toEqual({ allowSso: true });
+            expect(withTx.params.steps.sendTransaction).toBeDefined();
+        });
+    });
+
+    describe("reward step", () => {
+        it("should add reward final step", () => {
+            const builder = modalBuilder(mockClient, {});
+            const withReward = builder.reward();
+
+            expect(withReward.params.steps.final).toEqual({
+                action: { key: "reward" },
+            });
+        });
+
+        it("should add reward step with options", () => {
+            const builder = modalBuilder(mockClient, {});
+            const withReward = builder.reward({
+                autoSkip: true,
+            });
+
+            expect(withReward.params.steps.final).toEqual({
+                autoSkip: true,
+                action: { key: "reward" },
+            });
+        });
+    });
+
+    describe("sharing step", () => {
+        it("should add sharing final step", () => {
+            const builder = modalBuilder(mockClient, {});
+            const withSharing = builder.sharing({
+                popupTitle: "Share!",
+                text: "Check this out",
+                link: "https://example.com",
+            });
+
+            expect(withSharing.params.steps.final).toEqual({
+                action: {
+                    key: "sharing",
+                    options: {
+                        popupTitle: "Share!",
+                        text: "Check this out",
+                        link: "https://example.com",
+                    },
+                },
+            });
+        });
+
+        it("should add sharing step with additional options", () => {
+            const builder = modalBuilder(mockClient, {});
+            const withSharing = builder.sharing(
+                { text: "Share text", link: "https://example.com" },
+                { autoSkip: false }
+            );
+
+            expect(withSharing.params.steps.final).toEqual({
+                autoSkip: false,
+                action: {
+                    key: "sharing",
+                    options: {
+                        text: "Share text",
+                        link: "https://example.com",
+                    },
+                },
+            });
+        });
+    });
+
+    describe("chaining", () => {
+        it("should chain sendTx and reward", () => {
+            const builder = modalBuilder(mockClient, {});
+            const chained = builder
+                .sendTx({
+                    tx: {
+                        to: "0x1234567890123456789012345678901234567890" as Address,
+                    },
+                })
+                .reward();
+
+            expect(chained.params.steps.sendTransaction).toBeDefined();
+            expect(chained.params.steps.final).toEqual({
+                action: { key: "reward" },
+            });
+        });
+
+        it("should chain sendTx and sharing", () => {
+            const builder = modalBuilder(mockClient, {});
+            const chained = builder
+                .sendTx({
+                    tx: {
+                        to: "0x1234567890123456789012345678901234567890" as Address,
+                    },
+                })
+                .sharing({ link: "https://example.com" });
+
+            expect(chained.params.steps.sendTransaction).toBeDefined();
+            expect(chained.params.steps.final?.action).toEqual({
+                key: "sharing",
+                options: { link: "https://example.com" },
+            });
+        });
+    });
+
+    describe("display", () => {
+        it("should call displayModal when display is invoked", async () => {
+            const { displayModal } = await import("../displayModal");
+
+            const mockResponse = {
+                login: {
+                    wallet: "0x1234567890123456789012345678901234567890" as Address,
+                },
+            };
+            vi.mocked(displayModal).mockResolvedValue(mockResponse as any);
+
+            const builder = modalBuilder(mockClient, {});
+            await builder.display();
+
+            expect(displayModal).toHaveBeenCalledWith(
+                mockClient,
+                builder.params
+            );
+        });
+
+        it("should apply metadata override when provided", async () => {
+            const { displayModal } = await import("../displayModal");
+
+            vi.mocked(displayModal).mockResolvedValue({} as any);
+
+            const builder = modalBuilder(mockClient, {
+                metadata: { header: { title: "Original" } },
+            });
+            await builder.display(() => ({
+                header: { title: "Overridden" },
+            }));
+
+            expect(displayModal).toHaveBeenCalledWith(
+                mockClient,
+                expect.objectContaining({
+                    metadata: { header: { title: "Overridden" } },
+                })
+            );
+        });
+
+        it("should return displayModal result", async () => {
+            const { displayModal } = await import("../displayModal");
+
+            const mockResponse = {
+                login: {
+                    wallet: "0x1234567890123456789012345678901234567890" as Address,
+                },
+            };
+            vi.mocked(displayModal).mockResolvedValue(mockResponse as any);
+
+            const builder = modalBuilder(mockClient, {});
+            const result = await builder.display();
+
+            expect(result).toEqual(mockResponse);
+        });
+    });
+});