@frak-labs/core-sdk 0.1.1 → 0.2.0-beta.514ef378

package/src/actions/openSso.test.ts

@@ -1,407 +0,0 @@
-/**
- * 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();
-        });
-    });
-});

package/src/actions/sendInteraction.test.ts

@@ -1,219 +0,0 @@
-/**
- * Tests for sendInteraction action
- * Tests sending user interactions via RPC
- */
-
-import type { Hex } from "viem";
-import { vi } from "vitest";
-
-// Mock computeProductId - must be before imports
-vi.mock("../utils/computeProductId", () => ({
-    computeProductId: vi.fn(
-        () =>
-            "0xcomputed1234567890123456789012345678901234567890123456789012" as Hex
-    ),
-}));
-
-import { describe, expect, it } from "../../tests/vitest-fixtures";
-import type {
-    FrakClient,
-    PreparedInteraction,
-    SendInteractionParamsType,
-    SendInteractionReturnType,
-} from "../types";
-import { sendInteraction } from "./sendInteraction";
-
-describe("sendInteraction", () => {
-    const mockInteraction: PreparedInteraction = {
-        interactionData: "0xdata" as Hex,
-        handlerTypeDenominator: "0x01" as Hex,
-    };
-
-    describe("with productId provided", () => {
-        it("should use provided productId", async () => {
-            const mockResponse: SendInteractionReturnType = {
-                delegationId: "delegation-123",
-            };
-
-            const mockClient = {
-                config: {
-                    domain: "example.com",
-                },
-                request: vi.fn().mockResolvedValue(mockResponse),
-            } as unknown as FrakClient;
-
-            const params: SendInteractionParamsType = {
-                productId:
-                    "0xprovidedid567890123456789012345678901234567890123456789012" as Hex,
-                interaction: mockInteraction,
-            };
-
-            await sendInteraction(mockClient, params);
-
-            expect(mockClient.request).toHaveBeenCalledWith({
-                method: "frak_sendInteraction",
-                params: [
-                    "0xprovidedid567890123456789012345678901234567890123456789012",
-                    mockInteraction,
-                    undefined,
-                ],
-            });
-        });
-
-        it("should return delegationId", async () => {
-            const mockResponse: SendInteractionReturnType = {
-                delegationId: "delegation-456",
-            };
-
-            const mockClient = {
-                config: {
-                    domain: "example.com",
-                },
-                request: vi.fn().mockResolvedValue(mockResponse),
-            } as unknown as FrakClient;
-
-            const params: SendInteractionParamsType = {
-                productId:
-                    "0xprovidedid567890123456789012345678901234567890123456789012" as Hex,
-                interaction: mockInteraction,
-            };
-
-            const result = await sendInteraction(mockClient, params);
-
-            expect(result).toEqual(mockResponse);
-            expect(result.delegationId).toBe("delegation-456");
-        });
-
-        it("should include validation signature when provided", async () => {
-            const mockResponse: SendInteractionReturnType = {
-                delegationId: "delegation-789",
-            };
-
-            const mockClient = {
-                config: {
-                    domain: "example.com",
-                },
-                request: vi.fn().mockResolvedValue(mockResponse),
-            } as unknown as FrakClient;
-
-            const params: SendInteractionParamsType = {
-                productId:
-                    "0xprovidedid567890123456789012345678901234567890123456789012" as Hex,
-                interaction: mockInteraction,
-                validation: "0xsignature1234567890" as Hex,
-            };
-
-            await sendInteraction(mockClient, params);
-
-            expect(mockClient.request).toHaveBeenCalledWith({
-                method: "frak_sendInteraction",
-                params: [
-                    "0xprovidedid567890123456789012345678901234567890123456789012",
-                    mockInteraction,
-                    "0xsignature1234567890",
-                ],
-            });
-        });
-    });
-
-    describe("without productId provided", () => {
-        it("should compute productId from client.config", async () => {
-            const { computeProductId } = await import(
-                "../utils/computeProductId"
-            );
-
-            const mockResponse: SendInteractionReturnType = {
-                delegationId: "delegation-computed",
-            };
-
-            const mockClient = {
-                config: {
-                    domain: "example.com",
-                },
-                request: vi.fn().mockResolvedValue(mockResponse),
-            } as unknown as FrakClient;
-
-            const params: SendInteractionParamsType = {
-                interaction: mockInteraction,
-            };
-
-            await sendInteraction(mockClient, params);
-
-            expect(computeProductId).toHaveBeenCalledWith(mockClient.config);
-            expect(mockClient.request).toHaveBeenCalledWith({
-                method: "frak_sendInteraction",
-                params: [
-                    "0xcomputed1234567890123456789012345678901234567890123456789012",
-                    mockInteraction,
-                    undefined,
-                ],
-            });
-        });
-
-        it("should work with different interaction types", async () => {
-            const mockResponse: SendInteractionReturnType = {
-                delegationId: "delegation-different",
-            };
-
-            const mockClient = {
-                config: {
-                    domain: "example.com",
-                },
-                request: vi.fn().mockResolvedValue(mockResponse),
-            } as unknown as FrakClient;
-
-            const differentInteraction: PreparedInteraction = {
-                interactionData: "0xdifferentdata" as Hex,
-                handlerTypeDenominator: "0x02" as Hex,
-            };
-
-            const params: SendInteractionParamsType = {
-                interaction: differentInteraction,
-            };
-
-            const result = await sendInteraction(mockClient, params);
-
-            expect(result).toEqual(mockResponse);
-        });
-    });
-
-    describe("error handling", () => {
-        it("should propagate errors from client.request", async () => {
-            const error = new Error("Send interaction failed");
-            const mockClient = {
-                config: {
-                    domain: "example.com",
-                },
-                request: vi.fn().mockRejectedValue(error),
-            } as unknown as FrakClient;
-
-            const params: SendInteractionParamsType = {
-                productId:
-                    "0xprovidedid567890123456789012345678901234567890123456789012" as Hex,
-                interaction: mockInteraction,
-            };
-
-            await expect(sendInteraction(mockClient, params)).rejects.toThrow(
-                "Send interaction failed"
-            );
-        });
-
-        it("should handle network errors", async () => {
-            const error = new Error("Network timeout");
-            const mockClient = {
-                config: {
-                    domain: "example.com",
-                },
-                request: vi.fn().mockRejectedValue(error),
-            } as unknown as FrakClient;
-
-            const params: SendInteractionParamsType = {
-                interaction: mockInteraction,
-            };
-
-            await expect(sendInteraction(mockClient, params)).rejects.toThrow(
-                "Network timeout"
-            );
-        });
-    });
-});