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

package/src/actions/prepareSso.test.ts

@@ -0,0 +1,223 @@
+/**
+ * Tests for prepareSso action
+ * Tests SSO URL generation via RPC
+ */
+
+import { describe, expect, it, vi } from "../../tests/vitest-fixtures";
+import type {
+    FrakClient,
+    PrepareSsoParamsType,
+    PrepareSsoReturnType,
+} from "../types";
+import { prepareSso } from "./prepareSso";
+
+describe("prepareSso", () => {
+    describe("success cases", () => {
+        it("should call client.request with correct method and params", async () => {
+            const mockResponse: PrepareSsoReturnType = {
+                ssoUrl: "https://wallet.frak.id/sso?params=xyz",
+            };
+
+            const mockClient = {
+                config: {
+                    metadata: {
+                        name: "Test App",
+                    },
+                },
+                request: vi.fn().mockResolvedValue(mockResponse),
+            } as unknown as FrakClient;
+
+            const params: PrepareSsoParamsType = {
+                directExit: true,
+            };
+
+            await prepareSso(mockClient, params);
+
+            expect(mockClient.request).toHaveBeenCalledWith({
+                method: "frak_prepareSso",
+                params: [params, "Test App", undefined],
+            });
+        });
+
+        it("should return SSO URL", async () => {
+            const mockResponse: PrepareSsoReturnType = {
+                ssoUrl: "https://wallet.frak.id/sso?params=abc123",
+            };
+
+            const mockClient = {
+                config: {
+                    metadata: {
+                        name: "Test App",
+                    },
+                },
+                request: vi.fn().mockResolvedValue(mockResponse),
+            } as unknown as FrakClient;
+
+            const params: PrepareSsoParamsType = {
+                directExit: false,
+            };
+
+            const result = await prepareSso(mockClient, params);
+
+            expect(result).toEqual(mockResponse);
+            expect(result.ssoUrl).toBe(
+                "https://wallet.frak.id/sso?params=abc123"
+            );
+        });
+
+        it("should include custom CSS when provided", async () => {
+            const mockResponse: PrepareSsoReturnType = {
+                ssoUrl: "https://wallet.frak.id/sso?params=custom",
+            };
+
+            const mockClient = {
+                config: {
+                    metadata: {
+                        name: "Styled App",
+                    },
+                    customizations: {
+                        css: "body { background: red; }",
+                    },
+                },
+                request: vi.fn().mockResolvedValue(mockResponse),
+            } as unknown as FrakClient;
+
+            const params: PrepareSsoParamsType = {
+                directExit: true,
+            };
+
+            await prepareSso(mockClient, params);
+
+            expect(mockClient.request).toHaveBeenCalledWith({
+                method: "frak_prepareSso",
+                params: [params, "Styled App", "body { background: red; }"],
+            });
+        });
+
+        it("should handle params with redirectUrl", async () => {
+            const mockResponse: PrepareSsoReturnType = {
+                ssoUrl: "https://wallet.frak.id/sso?redirect=https://example.com",
+            };
+
+            const mockClient = {
+                config: {
+                    metadata: {
+                        name: "Test App",
+                    },
+                },
+                request: vi.fn().mockResolvedValue(mockResponse),
+            } as unknown as FrakClient;
+
+            const params: PrepareSsoParamsType = {
+                redirectUrl: "https://example.com/callback",
+                directExit: false,
+            };
+
+            await prepareSso(mockClient, params);
+
+            expect(mockClient.request).toHaveBeenCalledWith({
+                method: "frak_prepareSso",
+                params: [params, "Test App", undefined],
+            });
+        });
+
+        it("should handle params with metadata", async () => {
+            const mockResponse: PrepareSsoReturnType = {
+                ssoUrl: "https://wallet.frak.id/sso?metadata=xyz",
+            };
+
+            const mockClient = {
+                config: {
+                    metadata: {
+                        name: "App with Metadata",
+                        logoUrl: "https://example.com/logo.png",
+                    },
+                },
+                request: vi.fn().mockResolvedValue(mockResponse),
+            } as unknown as FrakClient;
+
+            const params: PrepareSsoParamsType = {
+                metadata: {
+                    logoUrl: "https://custom.com/logo.png",
+                    homepageLink: "https://custom.com",
+                },
+                directExit: true,
+            };
+
+            await prepareSso(mockClient, params);
+
+            expect(mockClient.request).toHaveBeenCalledWith({
+                method: "frak_prepareSso",
+                params: [params, "App with Metadata", undefined],
+            });
+        });
+
+        it("should pass client metadata name to request", async () => {
+            const mockResponse: PrepareSsoReturnType = {
+                ssoUrl: "https://wallet.frak.id/sso?name=MyApp",
+            };
+
+            const mockClient = {
+                config: {
+                    metadata: {
+                        name: "MyApp",
+                        logoUrl: "https://example.com/logo.png",
+                    },
+                    customizations: {
+                        css: "body { color: blue; }",
+                    },
+                },
+                request: vi.fn().mockResolvedValue(mockResponse),
+            } as unknown as FrakClient;
+
+            const params: PrepareSsoParamsType = {};
+
+            await prepareSso(mockClient, params);
+
+            expect(mockClient.request).toHaveBeenCalledWith({
+                method: "frak_prepareSso",
+                params: [params, "MyApp", "body { color: blue; }"],
+            });
+        });
+    });
+
+    describe("error handling", () => {
+        it("should propagate errors from client.request", async () => {
+            const error = new Error("SSO preparation failed");
+            const mockClient = {
+                config: {
+                    metadata: {
+                        name: "Test App",
+                    },
+                },
+                request: vi.fn().mockRejectedValue(error),
+            } as unknown as FrakClient;
+
+            const params: PrepareSsoParamsType = {
+                directExit: true,
+            };
+
+            await expect(prepareSso(mockClient, params)).rejects.toThrow(
+                "SSO preparation 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: PrepareSsoParamsType = {};
+
+            await expect(prepareSso(mockClient, params)).rejects.toThrow(
+                "Network timeout"
+            );
+        });
+    });
+});

package/src/actions/referral/processReferral.ts

@@ -61,7 +61,7 @@ export type ProcessReferralOptions = {
  * @see {@link displayModal} for more details about the displayed modal
  * @see {@link sendInteraction} for more details on the interaction submission part
  * @see {@link ReferralInteractionEncoder} for more details about the referred interaction
- * @see {@link ModalStepTypes} for more details on each modal steps types
+ * @see {@link @frak-labs/core-sdk!ModalStepTypes} for more details on each modal steps types
  */
 export async function processReferral(
     client: FrakClient,

package/src/actions/referral/referralInteraction.ts

@@ -20,7 +20,7 @@ import {
  * @description This function will automatically handle the referral interaction process
  *
  * @see {@link processReferral} for more details on the automatic referral handling process
- * @see {@link ModalStepTypes} for more details on each modal steps types
+ * @see {@link @frak-labs/core-sdk!ModalStepTypes} for more details on each modal steps types
  */
 export async function referralInteraction(
     client: FrakClient,

package/src/actions/sendInteraction.test.ts

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