@frak-labs/core-sdk 0.1.0-beta.afa252b0 → 0.1.0-beta.b0bd1f8a

package/src/actions/wrapper/sendTransaction.ts

@@ -0,0 +1,62 @@
+import type {
+    FrakClient,
+    ModalRpcMetadata,
+    SendTransactionModalStepType,
+    SendTransactionReturnType,
+} from "../../types";
+import { displayModal } from "../displayModal";
+
+/**
+ * Parameters to directly show a modal used to send a transaction
+ * @inline
+ */
+export type SendTransactionParams = {
+    /**
+     * The transaction to be sent (either a single tx or multiple ones)
+     */
+    tx: SendTransactionModalStepType["params"]["tx"];
+    /**
+     * Custom metadata to be passed to the modal
+     */
+    metadata?: ModalRpcMetadata;
+};
+
+/**
+ * Function used to send a user transaction, simple wrapper around the displayModal function to ease the send transaction process
+ * @param client - The current Frak Client
+ * @param args - The parameters
+ * @returns The hash of the transaction that was sent in a promise
+ *
+ * @description This function will display a modal to the user with the provided transaction and metadata.
+ *
+ * @example
+ * const { hash } = await sendTransaction(frakConfig, {
+ *     tx: {
+ *         to: "0xdeadbeef",
+ *         value: toHex(100n),
+ *     },
+ *     metadata: {
+ *         header: {
+ *             title: "Sending eth",
+ *         },
+ *         context: "Send 100wei to 0xdeadbeef",
+ *     },
+ * });
+ * console.log("Transaction hash:", hash);
+ */
+export async function sendTransaction(
+    client: FrakClient,
+    { tx, metadata }: SendTransactionParams
+): Promise<SendTransactionReturnType> {
+    // Trigger a modal with login options
+    const result = await displayModal(client, {
+        metadata,
+        steps: {
+            login: {},
+            sendTransaction: { tx },
+        },
+    });
+
+    // Return the tx result only
+    return result.sendTransaction;
+}

package/src/actions/wrapper/siweAuthenticate.ts

@@ -0,0 +1,94 @@
+import { generateSiweNonce } from "viem/siwe";
+import type {
+    FrakClient,
+    ModalRpcMetadata,
+    SiweAuthenticateReturnType,
+    SiweAuthenticationParams,
+} from "../../types";
+import { displayModal } from "../displayModal";
+
+/**
+ * Parameter used to directly show a modal used to authenticate with SIWE
+ * @inline
+ */
+export type SiweAuthenticateModalParams = {
+    /**
+     * Partial SIWE params, since we can rebuild them from the SDK if they are empty
+     *
+     * If no parameters provider, some fields will be recomputed from the current configuration and environment.
+     *  - `statement` will be set to a default value
+     *  - `nonce` will be generated
+     *  - `uri` will be set to the current domain
+     *  - `version` will be set to "1"
+     *  - `domain` will be set to the current window domain
+     *
+     * @default {}
+     */
+    siwe?: Partial<SiweAuthenticationParams>;
+    /**
+     * Custom metadata to be passed to the modal
+     */
+    metadata?: ModalRpcMetadata;
+};
+
+/**
+ * Function used to launch a siwe authentication
+ * @param client - The current Frak Client
+ * @param args - The parameters
+ * @returns The SIWE authentication result (message + signature) in a promise
+ *
+ * @description This function will display a modal to the user with the provided SIWE parameters and metadata.
+ *
+ * @example
+ * import { siweAuthenticate } from "@frak-labs/core-sdk/actions";
+ * import { parseSiweMessage } from "viem/siwe";
+ *
+ * const { signature, message } = await siweAuthenticate(frakConfig, {
+ *     siwe: {
+ *         statement: "Sign in to My App",
+ *         domain: "my-app.com",
+ *         expirationTimeTimestamp: Date.now() + 1000 * 60 * 5,
+ *     },
+ *     metadata: {
+ *         header: {
+ *             title: "Sign in",
+ *         },
+ *         context: "Sign in to My App",
+ *     },
+ * });
+ * console.log("Parsed final message:", parseSiweMessage(message));
+ * console.log("Siwe signature:", signature);
+ */
+export async function siweAuthenticate(
+    client: FrakClient,
+    { siwe, metadata }: SiweAuthenticateModalParams
+): Promise<SiweAuthenticateReturnType> {
+    const effectiveDomain = client.config?.domain ?? window.location.host;
+    const realStatement =
+        siwe?.statement ??
+        `I confirm that I want to use my Frak wallet on: ${client.config.metadata.name}`;
+
+    // Fill up the siwe request params
+    const builtSiwe: SiweAuthenticationParams = {
+        ...siwe,
+        statement: realStatement,
+        nonce: siwe?.nonce ?? generateSiweNonce(),
+        uri: siwe?.uri ?? `https://${effectiveDomain}`,
+        version: siwe?.version ?? "1",
+        domain: effectiveDomain,
+    };
+
+    // Trigger a modal with login options
+    const result = await displayModal(client, {
+        metadata,
+        steps: {
+            login: {},
+            siweAuthenticate: {
+                siwe: builtSiwe,
+            },
+        },
+    });
+
+    // Return the SIWE result only
+    return result.siweAuthenticate;
+}

package/src/bundle.ts

@@ -0,0 +1,3 @@
+export * from "./actions";
+export * from "./index";
+export * from "./interactions";

package/src/clients/DebugInfo.ts

@@ -0,0 +1,182 @@
+import {
+    FrakRpcError,
+    type RpcMessage,
+    type RpcResponse,
+} from "@frak-labs/frame-connector";
+import type { FrakWalletSdkConfig } from "../types";
+
+type IframeStatus = {
+    loading: boolean;
+    url: string | null;
+    readyState: number;
+    contentWindow: boolean;
+    isConnected: boolean;
+};
+
+type DebugInfo = {
+    timestamp: string;
+    encodedUrl: string;
+    navigatorInfo: string;
+    encodedConfig: string;
+    iframeStatus: string;
+    lastRequest: string;
+    lastResponse: string;
+    clientStatus: string;
+    error: string;
+};
+
+type NavigatorInfo = {
+    userAgent: string;
+    language: string;
+    onLine: boolean;
+    screenWidth: number;
+    screenHeight: number;
+    pixelRatio: number;
+};
+
+/** @ignore */
+export class DebugInfoGatherer {
+    private config?: FrakWalletSdkConfig;
+    private iframe?: HTMLIFrameElement;
+    private isSetupDone = false;
+    private lastResponse: null | {
+        message: RpcMessage;
+        response: RpcResponse;
+        timestamp: number;
+    } = null;
+    private lastRequest: null | {
+        event: RpcMessage;
+        timestamp: number;
+    } = null;
+
+    constructor(config?: FrakWalletSdkConfig, iframe?: HTMLIFrameElement) {
+        this.config = config;
+        this.iframe = iframe;
+        this.lastRequest = null;
+        this.lastResponse = null;
+    }
+
+    // Update communication logs
+    public setLastResponse(message: RpcMessage, response: RpcResponse) {
+        this.lastResponse = {
+            message,
+            response,
+            timestamp: Date.now(),
+        };
+    }
+    public setLastRequest(event: RpcMessage) {
+        this.lastRequest = { event, timestamp: Date.now() };
+    }
+
+    // Update connection status
+    public updateSetupStatus(status: boolean) {
+        this.isSetupDone = status;
+    }
+
+    private base64Encode(data: object): string {
+        try {
+            return btoa(JSON.stringify(data));
+        } catch (err) {
+            console.warn("Failed to encode debug data", err);
+            return btoa("Failed to encode data");
+        }
+    }
+
+    /**
+     * Extract information from the iframe status
+     */
+    private getIframeStatus(): IframeStatus | null {
+        if (!this.iframe) {
+            return null;
+        }
+        return {
+            loading: this.iframe.hasAttribute("loading"),
+            url: this.iframe.src,
+            readyState: this.iframe.contentDocument?.readyState
+                ? this.iframe.contentDocument.readyState === "complete"
+                    ? 1
+                    : 0
+                : -1,
+            contentWindow: !!this.iframe.contentWindow,
+            isConnected: this.iframe.isConnected,
+        };
+    }
+
+    private getNavigatorInfo(): NavigatorInfo | null {
+        if (!navigator) {
+            return null;
+        }
+        return {
+            userAgent: navigator.userAgent,
+            language: navigator.language,
+            onLine: navigator.onLine,
+            screenWidth: window.screen.width,
+            screenHeight: window.screen.height,
+            pixelRatio: window.devicePixelRatio,
+        };
+    }
+
+    private gatherDebugInfo(error: Error | unknown): DebugInfo {
+        const iframeStatus = this.getIframeStatus();
+        const navigatorInfo = this.getNavigatorInfo();
+
+        // Format the error in a readable format
+        let formattedError = "Unknown";
+        if (error instanceof FrakRpcError) {
+            formattedError = `FrakRpcError: ${error.code} '${error.message}'`;
+        } else if (error instanceof Error) {
+            formattedError = error.message;
+        } else if (typeof error === "string") {
+            formattedError = error;
+        }
+
+        // Craft the debug info
+        const debugInfo: DebugInfo = {
+            timestamp: new Date().toISOString(),
+            encodedUrl: btoa(window.location.href),
+            encodedConfig: this.config
+                ? this.base64Encode(this.config)
+                : "no-config",
+            navigatorInfo: navigatorInfo
+                ? this.base64Encode(navigatorInfo)
+                : "no-navigator",
+            iframeStatus: iframeStatus
+                ? this.base64Encode(iframeStatus)
+                : "not-iframe",
+            lastRequest: this.lastRequest
+                ? this.base64Encode(this.lastRequest)
+                : "No Frak request logged",
+            lastResponse: this.lastResponse
+                ? this.base64Encode(this.lastResponse)
+                : "No Frak response logged",
+            clientStatus: this.isSetupDone ? "setup" : "not-setup",
+            error: formattedError,
+        };
+
+        return debugInfo;
+    }
+
+    public static empty(): DebugInfoGatherer {
+        return new DebugInfoGatherer();
+    }
+
+    /**
+     * Format Frak debug information
+     */
+    public formatDebugInfo(error: Error | unknown | string): string {
+        const debugInfo = this.gatherDebugInfo(error);
+        return `
+  Debug Information:
+  -----------------
+  Timestamp: ${debugInfo.timestamp}
+  URL: ${debugInfo.encodedUrl}
+  Config: ${debugInfo.encodedConfig}
+  Navigator Info: ${debugInfo.navigatorInfo}
+  IFrame Status: ${debugInfo.iframeStatus}
+  Last Request: ${debugInfo.lastRequest}
+  Last Response: ${debugInfo.lastResponse}
+  Client Status: ${debugInfo.clientStatus}
+  Error: ${debugInfo.error}
+  `.trim();
+    }
+}

package/src/clients/createIFrameFrakClient.ts

@@ -0,0 +1,287 @@
+import {
+    createRpcClient,
+    FrakRpcError,
+    type RpcClient,
+    RpcErrorCodes,
+} from "@frak-labs/frame-connector";
+import { createClientCompressionMiddleware } from "@frak-labs/frame-connector/middleware";
+import { OpenPanel } from "@openpanel/web";
+import type { FrakLifecycleEvent } from "../types";
+import type { FrakClient } from "../types/client";
+import type { FrakWalletSdkConfig } from "../types/config";
+import type { IFrameRpcSchema } from "../types/rpc";
+import { BACKUP_KEY } from "../utils/constants";
+import { setupSsoUrlListener } from "../utils/ssoUrlListener";
+import { DebugInfoGatherer } from "./DebugInfo";
+import {
+    createIFrameLifecycleManager,
+    type IframeLifecycleManager,
+} from "./transports/iframeLifecycleManager";
+
+type SdkRpcClient = RpcClient<IFrameRpcSchema, FrakLifecycleEvent>;
+
+/**
+ * Create a new iframe Frak client
+ * @param args
+ * @param args.config - The configuration to use for the Frak Wallet SDK
+ * @param args.iframe - The iframe to use for the communication
+ * @returns The created Frak Client
+ *
+ * @example
+ * const frakConfig: FrakWalletSdkConfig = {
+ *     metadata: {
+ *         name: "My app title",
+ *     },
+ * }
+ * const iframe = await createIframe({ config: frakConfig });
+ * const client = createIFrameFrakClient({ config: frakConfig, iframe });
+ */
+export function createIFrameFrakClient({
+    config,
+    iframe,
+}: {
+    config: FrakWalletSdkConfig;
+    iframe: HTMLIFrameElement;
+}): FrakClient {
+    const frakWalletUrl = config?.walletUrl ?? "https://wallet.frak.id";
+
+    // Create lifecycle manager
+    const lifecycleManager = createIFrameLifecycleManager({ iframe });
+
+    // Create our debug info gatherer
+    const debugInfo = new DebugInfoGatherer(config, iframe);
+
+    // Validate iframe
+    if (!iframe.contentWindow) {
+        throw new FrakRpcError(
+            RpcErrorCodes.configError,
+            "The iframe does not have a content window"
+        );
+    }
+
+    // Create RPC client with middleware and lifecycle handlers
+    const rpcClient = createRpcClient<IFrameRpcSchema, FrakLifecycleEvent>({
+        emittingTransport: iframe.contentWindow,
+        listeningTransport: window,
+        targetOrigin: frakWalletUrl,
+        // Add compression middleware to handle request/response compression
+        middleware: [
+            // Ensure we are connected before sending request
+            {
+                async onRequest(_message, ctx) {
+                    // Ensure the iframe is connected
+                    const isConnected = await lifecycleManager.isConnected;
+                    if (!isConnected) {
+                        throw new FrakRpcError(
+                            RpcErrorCodes.clientNotConnected,
+                            "The iframe provider isn't connected yet"
+                        );
+                    }
+                    return ctx;
+                },
+            },
+            createClientCompressionMiddleware(),
+            // Save debug info
+            {
+                onRequest(message, ctx) {
+                    debugInfo.setLastRequest(message);
+                    return ctx;
+                },
+                onResponse(message, response) {
+                    debugInfo.setLastResponse(message, response);
+                    return response;
+                },
+            },
+        ],
+        // Add lifecycle handlers to process iframe lifecycle events
+        lifecycleHandlers: {
+            iframeLifecycle: async (event, _context) => {
+                // Delegate to lifecycle manager  (cast for type compatibility)
+                await lifecycleManager.handleEvent(event);
+            },
+        },
+    });
+
+    // Setup heartbeat
+    const stopHeartbeat = setupHeartbeat(rpcClient, lifecycleManager);
+
+    // Build our destroy function
+    const destroy = async () => {
+        // Stop heartbeat
+        stopHeartbeat();
+        // Cleanup the RPC client
+        rpcClient.cleanup();
+        // Remove the iframe
+        iframe.remove();
+    };
+
+    // Init open panel
+    let openPanel: OpenPanel | undefined;
+    if (
+        process.env.OPEN_PANEL_API_URL &&
+        process.env.OPEN_PANEL_SDK_CLIENT_ID
+    ) {
+        console.log("[Frak SDK] Initializing OpenPanel");
+        openPanel = new OpenPanel({
+            apiUrl: process.env.OPEN_PANEL_API_URL,
+            clientId: process.env.OPEN_PANEL_SDK_CLIENT_ID,
+            trackScreenViews: true,
+            trackOutgoingLinks: true,
+            trackAttributes: false,
+            // We use a filter to ensure we got the open panel instance initialized
+            //  A bit hacky, but this way we are sure that we got everything needed for the first event ever sent
+            filter: ({ type, payload }) => {
+                if (type !== "track") return true;
+                if (!payload?.properties) return true;
+
+                // Check if we we got the properties once initialized
+                if (!("sdkVersion" in payload.properties)) {
+                    payload.properties = {
+                        ...payload.properties,
+                        sdkVersion: process.env.SDK_VERSION,
+                    };
+                }
+
+                return true;
+            },
+        });
+        openPanel.setGlobalProperties({
+            sdkVersion: process.env.SDK_VERSION,
+        });
+        openPanel.init();
+    }
+
+    // Perform the post connection setup
+    const waitForSetup = postConnectionSetup({
+        config,
+        rpcClient,
+        lifecycleManager,
+    }).then(() => debugInfo.updateSetupStatus(true));
+
+    return {
+        config,
+        debugInfo,
+        waitForConnection: lifecycleManager.isConnected,
+        waitForSetup,
+        request: rpcClient.request,
+        listenerRequest: rpcClient.listen,
+        destroy,
+        openPanel,
+    };
+}
+
+/**
+ * Setup the heartbeat
+ * @param rpcClient - RPC client to send lifecycle events
+ * @param lifecycleManager - Lifecycle manager to track connection
+ */
+function setupHeartbeat(
+    rpcClient: SdkRpcClient,
+    lifecycleManager: IframeLifecycleManager
+) {
+    const HEARTBEAT_INTERVAL = 1_000; // Send heartbeat every 100ms until we are connected
+    const HEARTBEAT_TIMEOUT = 30_000; // 30 seconds timeout
+    let heartbeatInterval: NodeJS.Timeout;
+    let timeoutId: NodeJS.Timeout;
+
+    const sendHeartbeat = () =>
+        rpcClient.sendLifecycle({
+            clientLifecycle: "heartbeat",
+        });
+
+    // Start sending heartbeats
+    async function startHeartbeat() {
+        sendHeartbeat(); // Send initial heartbeat
+        heartbeatInterval = setInterval(sendHeartbeat, HEARTBEAT_INTERVAL);
+
+        // Set up timeout
+        timeoutId = setTimeout(() => {
+            stopHeartbeat();
+            console.log("Heartbeat timeout: connection failed");
+        }, HEARTBEAT_TIMEOUT);
+
+        // Once connected, stop it
+        await lifecycleManager.isConnected;
+
+        // We are now connected, stop the heartbeat
+        stopHeartbeat();
+    }
+
+    // Stop sending heartbeats
+    function stopHeartbeat() {
+        if (heartbeatInterval) {
+            clearInterval(heartbeatInterval);
+        }
+        if (timeoutId) {
+            clearTimeout(timeoutId);
+        }
+    }
+
+    startHeartbeat();
+
+    // Return cleanup function
+    return stopHeartbeat;
+}
+
+/**
+ * Perform the post connection setup
+ * @param config - SDK configuration
+ * @param rpcClient - RPC client to send lifecycle events
+ * @param lifecycleManager - Lifecycle manager to track connection
+ */
+async function postConnectionSetup({
+    config,
+    rpcClient,
+    lifecycleManager,
+}: {
+    config: FrakWalletSdkConfig;
+    rpcClient: SdkRpcClient;
+    lifecycleManager: IframeLifecycleManager;
+}): Promise<void> {
+    // Wait for the handler to be connected
+    await lifecycleManager.isConnected;
+
+    // Setup SSO URL listener to detect and forward SSO redirects
+    // This checks for ?sso= parameter and forwards compressed data to iframe
+    setupSsoUrlListener(rpcClient, lifecycleManager.isConnected);
+
+    // Push raw CSS if needed
+    async function pushCss() {
+        const cssLink = config.customizations?.css;
+        if (!cssLink) return;
+
+        const message = {
+            clientLifecycle: "modal-css" as const,
+            data: { cssLink },
+        };
+        rpcClient.sendLifecycle(message);
+    }
+
+    // Push i18n if needed
+    async function pushI18n() {
+        const i18n = config.customizations?.i18n;
+        if (!i18n) return;
+
+        const message = {
+            clientLifecycle: "modal-i18n" as const,
+            data: { i18n },
+        };
+        rpcClient.sendLifecycle(message);
+    }
+
+    // Push local backup if needed
+    async function pushBackup() {
+        if (typeof window === "undefined") return;
+
+        const backup = window.localStorage.getItem(BACKUP_KEY);
+        if (!backup) return;
+
+        const message = {
+            clientLifecycle: "restore-backup" as const,
+            data: { backup },
+        };
+        rpcClient.sendLifecycle(message);
+    }
+
+    await Promise.allSettled([pushCss(), pushI18n(), pushBackup()]);
+}

package/src/clients/index.ts

@@ -0,0 +1,3 @@
+export { createIFrameFrakClient } from "./createIFrameFrakClient";
+export { DebugInfoGatherer } from "./DebugInfo";
+export { setupClient } from "./setupClient";