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

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

@@ -0,0 +1,164 @@
+import { vi } from "vitest";
+
+vi.mock("../displayModal", () => ({
+    displayModal: vi.fn(),
+}));
+
+import type { Address, Hex } from "viem";
+import { describe, expect, it } from "../../../tests/vitest-fixtures";
+import type { FrakClient } from "../../types";
+import { sendTransaction } from "./sendTransaction";
+
+describe("sendTransaction", () => {
+    const mockClient = {
+        config: {
+            metadata: {
+                name: "Test App",
+            },
+        },
+        request: vi.fn(),
+    } as unknown as FrakClient;
+
+    describe("basic usage", () => {
+        it("should call displayModal with correct params for single tx", async () => {
+            const { displayModal } = await import("../displayModal");
+
+            const mockTxHash =
+                "0xabcdef1234567890abcdef1234567890abcdef1234567890abcdef1234567890" as Hex;
+            vi.mocked(displayModal).mockResolvedValue({
+                login: {
+                    wallet: "0x1234567890123456789012345678901234567890" as Address,
+                },
+                sendTransaction: { hash: mockTxHash },
+            } as any);
+
+            const txParams = {
+                to: "0x1234567890123456789012345678901234567890" as Address,
+                data: "0xdeadbeef" as Hex,
+            };
+
+            await sendTransaction(mockClient, { tx: txParams });
+
+            expect(displayModal).toHaveBeenCalledWith(mockClient, {
+                metadata: undefined,
+                steps: {
+                    login: {},
+                    sendTransaction: { tx: txParams },
+                },
+            });
+        });
+
+        it("should return transaction hash", async () => {
+            const { displayModal } = await import("../displayModal");
+
+            const mockTxHash =
+                "0xabcdef1234567890abcdef1234567890abcdef1234567890abcdef1234567890" as Hex;
+            vi.mocked(displayModal).mockResolvedValue({
+                login: {
+                    wallet: "0x1234567890123456789012345678901234567890" as Address,
+                },
+                sendTransaction: { hash: mockTxHash },
+            } as any);
+
+            const result = await sendTransaction(mockClient, {
+                tx: {
+                    to: "0x1234567890123456789012345678901234567890" as Address,
+                },
+            });
+
+            expect(result).toEqual({ hash: mockTxHash });
+        });
+    });
+
+    describe("batched transactions", () => {
+        it("should handle multiple transactions", async () => {
+            const { displayModal } = await import("../displayModal");
+
+            const mockTxHash =
+                "0xabcdef1234567890abcdef1234567890abcdef1234567890abcdef1234567890" as Hex;
+            vi.mocked(displayModal).mockResolvedValue({
+                login: {},
+                sendTransaction: { hash: mockTxHash },
+            } as any);
+
+            const txParams = [
+                {
+                    to: "0x1234567890123456789012345678901234567890" as Address,
+                    data: "0xdata1" as Hex,
+                },
+                {
+                    to: "0xabcdefabcdefabcdefabcdefabcdefabcdefabcd" as Address,
+                    data: "0xdata2" as Hex,
+                },
+            ];
+
+            await sendTransaction(mockClient, { tx: txParams });
+
+            expect(displayModal).toHaveBeenCalledWith(mockClient, {
+                metadata: undefined,
+                steps: {
+                    login: {},
+                    sendTransaction: { tx: txParams },
+                },
+            });
+        });
+    });
+
+    describe("with metadata", () => {
+        it("should pass metadata to displayModal", async () => {
+            const { displayModal } = await import("../displayModal");
+
+            vi.mocked(displayModal).mockResolvedValue({
+                login: {},
+                sendTransaction: { hash: "0x123" as Hex },
+            } as any);
+
+            const metadata = {
+                header: {
+                    title: "Send ETH",
+                    icon: "https://example.com/icon.png",
+                },
+                context: "Send 100 wei to recipient",
+            };
+
+            await sendTransaction(mockClient, {
+                tx: {
+                    to: "0x1234567890123456789012345678901234567890" as Address,
+                    value: "0x64" as Hex,
+                },
+                metadata,
+            });
+
+            expect(displayModal).toHaveBeenCalledWith(mockClient, {
+                metadata,
+                steps: {
+                    login: {},
+                    sendTransaction: {
+                        tx: {
+                            to: "0x1234567890123456789012345678901234567890",
+                            value: "0x64",
+                        },
+                    },
+                },
+            });
+        });
+    });
+
+    describe("error handling", () => {
+        it("should propagate errors from displayModal", async () => {
+            const { displayModal } = await import("../displayModal");
+
+            vi.mocked(displayModal).mockRejectedValue(
+                new Error("Transaction rejected")
+            );
+
+            await expect(
+                sendTransaction(mockClient, {
+                    tx: {
+                        to: "0x1234567890123456789012345678901234567890" as Address,
+                    },
+                })
+            ).rejects.toThrow("Transaction rejected");
+        });
+    });
+});

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.test.ts

@@ -0,0 +1,290 @@
+import { beforeEach, vi } from "vitest";
+
+vi.mock("../displayModal", () => ({
+    displayModal: vi.fn(),
+}));
+
+vi.mock("viem/siwe", () => ({
+    generateSiweNonce: vi.fn(() => "mock-nonce-123456"),
+}));
+
+import type { Address, Hex } from "viem";
+import { describe, expect, it } from "../../../tests/vitest-fixtures";
+import type { FrakClient } from "../../types";
+import { siweAuthenticate } from "./siweAuthenticate";
+
+describe("siweAuthenticate", () => {
+    const mockClient = {
+        config: {
+            domain: "example.com",
+            metadata: {
+                name: "Test App",
+            },
+        },
+        request: vi.fn(),
+    } as unknown as FrakClient;
+
+    const mockClientWithoutDomain = {
+        config: {
+            metadata: {
+                name: "Test App",
+            },
+        },
+        request: vi.fn(),
+    } as unknown as FrakClient;
+
+    beforeEach(() => {
+        vi.stubGlobal("window", {
+            location: {
+                host: "window.example.com",
+            },
+        });
+    });
+
+    describe("basic usage", () => {
+        it("should call displayModal with SIWE params", async () => {
+            const { displayModal } = await import("../displayModal");
+
+            const mockResponse = {
+                login: {
+                    wallet: "0x1234567890123456789012345678901234567890" as Address,
+                },
+                siweAuthenticate: {
+                    message: "Sign in to Test App",
+                    signature: "0xsignature" as Hex,
+                },
+            };
+            vi.mocked(displayModal).mockResolvedValue(mockResponse as any);
+
+            await siweAuthenticate(mockClient, {});
+
+            expect(displayModal).toHaveBeenCalledWith(mockClient, {
+                metadata: undefined,
+                steps: {
+                    login: {},
+                    siweAuthenticate: {
+                        siwe: expect.objectContaining({
+                            domain: "example.com",
+                            nonce: "mock-nonce-123456",
+                            uri: "https://example.com",
+                            version: "1",
+                        }),
+                    },
+                },
+            });
+        });
+
+        it("should return SIWE authentication result", async () => {
+            const { displayModal } = await import("../displayModal");
+
+            const mockSiweResult = {
+                message: "I confirm that I want to use my Frak wallet",
+                signature:
+                    "0xsig1234567890123456789012345678901234567890123456789012345678901234" as Hex,
+            };
+            vi.mocked(displayModal).mockResolvedValue({
+                login: {},
+                siweAuthenticate: mockSiweResult,
+            } as any);
+
+            const result = await siweAuthenticate(mockClient, {});
+
+            expect(result).toEqual(mockSiweResult);
+        });
+    });
+
+    describe("SIWE parameter handling", () => {
+        it("should use default statement when not provided", async () => {
+            const { displayModal } = await import("../displayModal");
+
+            vi.mocked(displayModal).mockResolvedValue({
+                login: {},
+                siweAuthenticate: { message: "", signature: "0x" as Hex },
+            } as any);
+
+            await siweAuthenticate(mockClient, {});
+
+            expect(displayModal).toHaveBeenCalledWith(
+                mockClient,
+                expect.objectContaining({
+                    steps: expect.objectContaining({
+                        siweAuthenticate: expect.objectContaining({
+                            siwe: expect.objectContaining({
+                                statement:
+                                    "I confirm that I want to use my Frak wallet on: Test App",
+                            }),
+                        }),
+                    }),
+                })
+            );
+        });
+
+        it("should use custom statement when provided", async () => {
+            const { displayModal } = await import("../displayModal");
+
+            vi.mocked(displayModal).mockResolvedValue({
+                login: {},
+                siweAuthenticate: { message: "", signature: "0x" as Hex },
+            } as any);
+
+            await siweAuthenticate(mockClient, {
+                siwe: { statement: "Custom sign in message" },
+            });
+
+            expect(displayModal).toHaveBeenCalledWith(
+                mockClient,
+                expect.objectContaining({
+                    steps: expect.objectContaining({
+                        siweAuthenticate: expect.objectContaining({
+                            siwe: expect.objectContaining({
+                                statement: "Custom sign in message",
+                            }),
+                        }),
+                    }),
+                })
+            );
+        });
+
+        it("should use custom nonce when provided", async () => {
+            const { displayModal } = await import("../displayModal");
+
+            vi.mocked(displayModal).mockResolvedValue({
+                login: {},
+                siweAuthenticate: { message: "", signature: "0x" as Hex },
+            } as any);
+
+            await siweAuthenticate(mockClient, {
+                siwe: { nonce: "custom-nonce" },
+            });
+
+            expect(displayModal).toHaveBeenCalledWith(
+                mockClient,
+                expect.objectContaining({
+                    steps: expect.objectContaining({
+                        siweAuthenticate: expect.objectContaining({
+                            siwe: expect.objectContaining({
+                                nonce: "custom-nonce",
+                            }),
+                        }),
+                    }),
+                })
+            );
+        });
+
+        it("should use window.location.host when domain not in config", async () => {
+            const { displayModal } = await import("../displayModal");
+
+            vi.mocked(displayModal).mockResolvedValue({
+                login: {},
+                siweAuthenticate: { message: "", signature: "0x" as Hex },
+            } as any);
+
+            await siweAuthenticate(mockClientWithoutDomain, {});
+
+            expect(displayModal).toHaveBeenCalledWith(
+                mockClientWithoutDomain,
+                expect.objectContaining({
+                    steps: expect.objectContaining({
+                        siweAuthenticate: expect.objectContaining({
+                            siwe: expect.objectContaining({
+                                domain: "window.example.com",
+                                uri: "https://window.example.com",
+                            }),
+                        }),
+                    }),
+                })
+            );
+        });
+
+        it("should use custom uri when provided", async () => {
+            const { displayModal } = await import("../displayModal");
+
+            vi.mocked(displayModal).mockResolvedValue({
+                login: {},
+                siweAuthenticate: { message: "", signature: "0x" as Hex },
+            } as any);
+
+            await siweAuthenticate(mockClient, {
+                siwe: { uri: "https://custom-uri.com" },
+            });
+
+            expect(displayModal).toHaveBeenCalledWith(
+                mockClient,
+                expect.objectContaining({
+                    steps: expect.objectContaining({
+                        siweAuthenticate: expect.objectContaining({
+                            siwe: expect.objectContaining({
+                                uri: "https://custom-uri.com",
+                            }),
+                        }),
+                    }),
+                })
+            );
+        });
+
+        it("should use custom version when provided", async () => {
+            const { displayModal } = await import("../displayModal");
+
+            vi.mocked(displayModal).mockResolvedValue({
+                login: {},
+                siweAuthenticate: { message: "", signature: "0x" as Hex },
+            } as any);
+
+            await siweAuthenticate(mockClient, {
+                siwe: { version: "2" as any },
+            });
+
+            expect(displayModal).toHaveBeenCalledWith(
+                mockClient,
+                expect.objectContaining({
+                    steps: expect.objectContaining({
+                        siweAuthenticate: expect.objectContaining({
+                            siwe: expect.objectContaining({
+                                version: "2",
+                            }),
+                        }),
+                    }),
+                })
+            );
+        });
+    });
+
+    describe("with metadata", () => {
+        it("should pass metadata to displayModal", async () => {
+            const { displayModal } = await import("../displayModal");
+
+            vi.mocked(displayModal).mockResolvedValue({
+                login: {},
+                siweAuthenticate: { message: "", signature: "0x" as Hex },
+            } as any);
+
+            const metadata = {
+                header: {
+                    title: "Sign In",
+                },
+                context: "Sign in to access your account",
+            };
+
+            await siweAuthenticate(mockClient, { metadata });
+
+            expect(displayModal).toHaveBeenCalledWith(mockClient, {
+                metadata,
+                steps: expect.any(Object),
+            });
+        });
+    });
+
+    describe("error handling", () => {
+        it("should propagate errors from displayModal", async () => {
+            const { displayModal } = await import("../displayModal");
+
+            vi.mocked(displayModal).mockRejectedValue(
+                new Error("SIWE authentication rejected")
+            );
+
+            await expect(siweAuthenticate(mockClient, {})).rejects.toThrow(
+                "SIWE authentication rejected"
+            );
+        });
+    });
+});

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";