@frak-labs/core-sdk 0.0.19-beta.f259d7fc → 0.1.0-beta.00226d62

package/src/actions/referral/processReferral.ts

@@ -0,0 +1,230 @@
+import { FrakRpcError, RpcErrorCodes } from "@frak-labs/frame-connector";
+import { type Address, type Hex, isAddressEqual } from "viem";
+import { ReferralInteractionEncoder } from "../../interactions";
+import type {
+    DisplayEmbeddedWalletParamsType,
+    FrakClient,
+    FrakContext,
+    WalletStatusReturnType,
+} from "../../types";
+import { FrakContextManager, trackEvent } from "../../utils";
+import { displayEmbeddedWallet, sendInteraction } from "../index";
+
+/**
+ * The different states of the referral process
+ * @inline
+ */
+type ReferralState =
+    | "idle"
+    | "processing"
+    | "success"
+    | "no-wallet"
+    | "no-session"
+    | "error"
+    | "no-referrer"
+    | "self-referral";
+
+/**
+ * Options for the referral auto-interaction process
+ */
+export type ProcessReferralOptions = {
+    /**
+     * If we want to always append the url with the frak context or not
+     * @defaultValue false
+     */
+    alwaysAppendUrl?: boolean;
+};
+
+/**
+ * This function handle all the heavy lifting of the referral interaction process
+ *  1. Check if the user has been referred or not (if not, early exit)
+ *  2. Then check if the user is logged in or not
+ *  2.1 If not logged in, try a soft login, if it fail, display a modal for the user to login
+ *  3. Check if that's not a self-referral (if yes, early exit)
+ *  4. Check if the user has an interaction session or not
+ *  4.1 If not, display a modal for the user to open a session
+ *  5. Push the referred interaction
+ *  6. Update the current url with the right data
+ *  7. Return the resulting referral state
+ *
+ *  If any error occurs during the process, the function will catch it and return an error state
+ *
+ * @param client - The current Frak Client
+ * @param args
+ * @param args.walletStatus - The current user wallet status
+ * @param args.frakContext - The current frak context
+ * @param args.modalConfig - The modal configuration to display if the user is not logged in
+ * @param args.productId - The product id to interact with (if not specified will be recomputed from the current domain)
+ * @param args.options - Some options for the referral interaction
+ * @returns  A promise with the resulting referral state
+ *
+ * @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 @frak-labs/core-sdk!ModalStepTypes} for more details on each modal steps types
+ */
+export async function processReferral(
+    client: FrakClient,
+    {
+        walletStatus,
+        frakContext,
+        modalConfig,
+        productId,
+        options,
+    }: {
+        walletStatus?: WalletStatusReturnType;
+        frakContext?: Partial<FrakContext> | null;
+        modalConfig?: DisplayEmbeddedWalletParamsType;
+        productId?: Hex;
+        options?: ProcessReferralOptions;
+    }
+) {
+    // Helper to fetch a fresh wallet status
+    let walletRequest = false;
+    async function getFreshWalletStatus() {
+        if (walletRequest) {
+            return;
+        }
+        walletRequest = true;
+        return ensureWalletConnected(client, {
+            modalConfig: {
+                ...modalConfig,
+                loggedIn: {
+                    action: {
+                        key: "referred",
+                    },
+                },
+            },
+            walletStatus,
+        });
+    }
+
+    // Helper function to push the interaction
+    async function pushReferralInteraction(referrer: Address) {
+        const interaction = ReferralInteractionEncoder.referred({
+            referrer,
+        });
+        await Promise.allSettled([
+            // Send the interaction
+            sendInteraction(client, { productId, interaction }),
+            // Track the event
+            trackEvent(client, "user_referred", {
+                properties: {
+                    referrer: referrer,
+                },
+            }),
+        ]);
+    }
+
+    try {
+        // Do the core processing logic
+        const { status, currentWallet } = await processReferralLogic({
+            initialWalletStatus: walletStatus,
+            getFreshWalletStatus,
+            pushReferralInteraction,
+            frakContext,
+        });
+
+        // Update the current url with the right data
+        FrakContextManager.replaceUrl({
+            url: window.location?.href,
+            context: options?.alwaysAppendUrl ? { r: currentWallet } : null,
+        });
+
+        return status;
+    } catch (error) {
+        console.log("Error processing referral", { error });
+        // Update the current url with the right data
+        FrakContextManager.replaceUrl({
+            url: window.location?.href,
+            context: options?.alwaysAppendUrl
+                ? { r: walletStatus?.wallet }
+                : null,
+        });
+
+        // And map the error a state
+        return mapErrorToState(error);
+    }
+}
+
+/**
+ * Automatically submit a referral interaction when detected
+ *   -> And automatically set the referral context in the url
+ * @param walletStatus
+ * @param frakContext
+ */
+async function processReferralLogic({
+    initialWalletStatus,
+    getFreshWalletStatus,
+    pushReferralInteraction,
+    frakContext,
+}: {
+    initialWalletStatus?: WalletStatusReturnType;
+    getFreshWalletStatus: () => Promise<Address | undefined>;
+    pushReferralInteraction: (referrer: Address) => Promise<void>;
+    frakContext?: Partial<FrakContext> | null;
+}) {
+    // Get the current wallet, without auto displaying the modal
+    let currentWallet = initialWalletStatus?.wallet;
+    if (!frakContext?.r) {
+        return { status: "no-referrer", currentWallet } as const;
+    }
+
+    // We have a referral, so if we don't have a current wallet, display the modal
+    if (!currentWallet) {
+        currentWallet = await getFreshWalletStatus();
+    }
+
+    if (currentWallet && isAddressEqual(frakContext.r, currentWallet)) {
+        return { status: "self-referral", currentWallet } as const;
+    }
+
+    // If the current wallet doesn't have an interaction session, display the modal
+    if (!initialWalletStatus?.interactionSession) {
+        currentWallet = await getFreshWalletStatus();
+    }
+
+    // Push the referred interaction
+    await pushReferralInteraction(frakContext.r);
+    return { status: "success", currentWallet } as const;
+}
+
+/**
+ * Helper to ensure a wallet is connected, and display a modal if we got everything needed
+ */
+async function ensureWalletConnected(
+    client: FrakClient,
+    {
+        modalConfig,
+        walletStatus,
+    }: {
+        modalConfig?: DisplayEmbeddedWalletParamsType;
+        walletStatus?: WalletStatusReturnType;
+    }
+) {
+    // If wallet not connected, or no interaction session
+    if (!walletStatus?.interactionSession) {
+        const result = await displayEmbeddedWallet(client, modalConfig ?? {});
+        return result?.wallet ?? undefined;
+    }
+
+    return walletStatus.wallet ?? undefined;
+}
+
+/**
+ * Helper to map an error to a state
+ * @param error
+ */
+function mapErrorToState(error: unknown): ReferralState {
+    if (error instanceof FrakRpcError) {
+        switch (error.code) {
+            case RpcErrorCodes.walletNotConnected:
+                return "no-wallet";
+            case RpcErrorCodes.serverErrorForInteractionDelegation:
+                return "no-session";
+            default:
+                return "error";
+        }
+    }
+    return "error";
+}

package/src/actions/referral/referralInteraction.test.ts

@@ -0,0 +1,153 @@
+import type { Hex } from "viem";
+import { beforeEach, describe, expect, test, vi } from "vitest";
+import { referralInteraction } from "./referralInteraction";
+
+vi.mock("../../utils", () => ({
+    FrakContextManager: {
+        parse: vi.fn(),
+    },
+}));
+
+vi.mock("../index", () => ({
+    watchWalletStatus: vi.fn(),
+}));
+
+vi.mock("./processReferral", () => ({
+    processReferral: vi.fn(),
+}));
+
+describe("referralInteraction", () => {
+    const mockClient = {
+        request: vi.fn(),
+    } as any;
+
+    const mockProductId =
+        "0x0000000000000000000000000000000000000000000000000000000000000002" as Hex;
+
+    beforeEach(() => {
+        vi.clearAllMocks();
+        Object.defineProperty(global, "window", {
+            value: { location: { href: "https://example.com?frak=test" } },
+            writable: true,
+        });
+    });
+
+    test("should parse context from window location", async () => {
+        const { FrakContextManager } = await import("../../utils");
+        const { watchWalletStatus } = await import("../index");
+        const { processReferral } = await import("./processReferral");
+
+        vi.mocked(FrakContextManager.parse).mockReturnValue({} as any);
+        vi.mocked(watchWalletStatus).mockResolvedValue(null as any);
+        vi.mocked(processReferral).mockResolvedValue("success");
+
+        await referralInteraction(mockClient);
+
+        expect(FrakContextManager.parse).toHaveBeenCalledWith({
+            url: "https://example.com?frak=test",
+        });
+    });
+
+    test("should get current wallet status", async () => {
+        const { FrakContextManager } = await import("../../utils");
+        const { watchWalletStatus } = await import("../index");
+        const { processReferral } = await import("./processReferral");
+
+        vi.mocked(FrakContextManager.parse).mockReturnValue({} as any);
+        vi.mocked(watchWalletStatus).mockResolvedValue({
+            wallet: "0x123" as Hex,
+            interactionSession: true,
+        } as any);
+        vi.mocked(processReferral).mockResolvedValue("success");
+
+        await referralInteraction(mockClient);
+
+        expect(watchWalletStatus).toHaveBeenCalledWith(mockClient);
+    });
+
+    test("should call processReferral with all parameters", async () => {
+        const { FrakContextManager } = await import("../../utils");
+        const { watchWalletStatus } = await import("../index");
+        const { processReferral } = await import("./processReferral");
+
+        const mockContext = { r: "0xreferrer" as Hex };
+        const mockWalletStatus = { wallet: "0x123" as Hex };
+        const mockModalConfig = { type: "login" };
+        const mockOptions = { alwaysAppendUrl: true };
+
+        vi.mocked(FrakContextManager.parse).mockReturnValue(mockContext as any);
+        vi.mocked(watchWalletStatus).mockResolvedValue(mockWalletStatus as any);
+        vi.mocked(processReferral).mockResolvedValue("success");
+
+        await referralInteraction(mockClient, {
+            productId: mockProductId,
+            modalConfig: mockModalConfig as any,
+            options: mockOptions,
+        });
+
+        expect(processReferral).toHaveBeenCalledWith(mockClient, {
+            walletStatus: mockWalletStatus,
+            frakContext: mockContext,
+            modalConfig: mockModalConfig,
+            productId: mockProductId,
+            options: mockOptions,
+        });
+    });
+
+    test("should return result from processReferral", async () => {
+        const { FrakContextManager } = await import("../../utils");
+        const { watchWalletStatus } = await import("../index");
+        const { processReferral } = await import("./processReferral");
+
+        vi.mocked(FrakContextManager.parse).mockReturnValue({} as any);
+        vi.mocked(watchWalletStatus).mockResolvedValue(null as any);
+        vi.mocked(processReferral).mockResolvedValue("success");
+
+        const result = await referralInteraction(mockClient);
+
+        expect(result).toBe("success");
+    });
+
+    test("should return undefined on error", async () => {
+        const { FrakContextManager } = await import("../../utils");
+        const { watchWalletStatus } = await import("../index");
+        const { processReferral } = await import("./processReferral");
+
+        vi.mocked(FrakContextManager.parse).mockReturnValue({} as any);
+        vi.mocked(watchWalletStatus).mockResolvedValue(null as any);
+        vi.mocked(processReferral).mockRejectedValue(new Error("Test error"));
+
+        const consoleSpy = vi
+            .spyOn(console, "warn")
+            .mockImplementation(() => {});
+
+        const result = await referralInteraction(mockClient);
+
+        expect(result).toBeUndefined();
+        expect(consoleSpy).toHaveBeenCalled();
+
+        consoleSpy.mockRestore();
+    });
+
+    test("should work with empty options", async () => {
+        const { FrakContextManager } = await import("../../utils");
+        const { watchWalletStatus } = await import("../index");
+        const { processReferral } = await import("./processReferral");
+
+        vi.mocked(FrakContextManager.parse).mockReturnValue({} as any);
+        vi.mocked(watchWalletStatus).mockResolvedValue(null as any);
+        vi.mocked(processReferral).mockResolvedValue("no-referrer");
+
+        const result = await referralInteraction(mockClient, {});
+
+        expect(result).toBe("no-referrer");
+        expect(processReferral).toHaveBeenCalledWith(
+            mockClient,
+            expect.objectContaining({
+                modalConfig: undefined,
+                productId: undefined,
+                options: undefined,
+            })
+        );
+    });
+});

package/src/actions/referral/referralInteraction.ts

@@ -0,0 +1,57 @@
+import type { Hex } from "viem";
+import type { DisplayEmbeddedWalletParamsType, FrakClient } from "../../types";
+import { FrakContextManager } from "../../utils";
+import { watchWalletStatus } from "../index";
+import {
+    type ProcessReferralOptions,
+    processReferral,
+} from "./processReferral";
+
+/**
+ * Function used to display a modal
+ * @param client - The current Frak Client
+ * @param args
+ * @param args.productId - The product id to interact with (if not specified will be recomputed from the current domain)
+ * @param args.modalConfig - The modal configuration to display if the user is not logged in
+ * @param args.options - Some options for the referral interaction
+ *
+ * @returns  A promise with the resulting referral state, or undefined in case of an error
+ *
+ * @description This function will automatically handle the referral interaction process
+ *
+ * @see {@link processReferral} for more details on the automatic referral handling process
+ * @see {@link @frak-labs/core-sdk!ModalStepTypes} for more details on each modal steps types
+ */
+export async function referralInteraction(
+    client: FrakClient,
+    {
+        productId,
+        modalConfig,
+        options,
+    }: {
+        productId?: Hex;
+        modalConfig?: DisplayEmbeddedWalletParamsType;
+        options?: ProcessReferralOptions;
+    } = {}
+) {
+    // Get the current frak context
+    const frakContext = FrakContextManager.parse({
+        url: window.location.href,
+    });
+
+    // Get the current wallet status
+    const currentWalletStatus = await watchWalletStatus(client);
+
+    try {
+        return await processReferral(client, {
+            walletStatus: currentWalletStatus,
+            frakContext,
+            modalConfig,
+            productId,
+            options,
+        });
+    } catch (error) {
+        console.warn("Error processing referral", { error });
+    }
+    return;
+}

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

package/src/actions/sendInteraction.ts

@@ -0,0 +1,32 @@
+import type {
+    FrakClient,
+    SendInteractionParamsType,
+    SendInteractionReturnType,
+} from "../types";
+import { computeProductId } from "../utils/computeProductId";
+
+/**
+ * Function used to send an interaction
+ * @param client - The current Frak Client
+ * @param args
+ *
+ * @example
+ * const interaction = PressInteractionEncoder.openArticle({
+ *     articleId: keccak256(toHex("article-slug")),
+ * });
+ * const { delegationId } = await sendInteraction(frakConfig, {
+ *     interaction,
+ * });
+ * console.log("Delegated interaction id", delegationId);
+ */
+export async function sendInteraction(
+    client: FrakClient,
+    { productId, interaction, validation }: SendInteractionParamsType
+): Promise<SendInteractionReturnType> {
+    const pId = productId ?? computeProductId(client.config);
+
+    return await client.request({
+        method: "frak_sendInteraction",
+        params: [pId, interaction, validation],
+    });
+}