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

package/src/interactions/retailEncoder.test.ts

@@ -0,0 +1,107 @@
+/**
+ * Tests for RetailInteractionEncoder
+ * Tests encoding of retail-related user interactions
+ */
+
+import { pad, toHex } from "viem";
+import { describe, expect, test } from "../../tests/vitest-fixtures";
+import { interactionTypes } from "../constants/interactionTypes";
+import { productTypes } from "../constants/productTypes";
+import { RetailInteractionEncoder } from "./retailEncoder";
+
+describe("RetailInteractionEncoder", () => {
+    describe("customerMeeting", () => {
+        test("should encode customer meeting interaction with correct structure", ({
+            mockAgencyId,
+        }) => {
+            const interaction = RetailInteractionEncoder.customerMeeting({
+                agencyId: mockAgencyId,
+            });
+
+            // Should return PreparedInteraction structure
+            expect(interaction).toHaveProperty("handlerTypeDenominator");
+            expect(interaction).toHaveProperty("interactionData");
+        });
+
+        test("should use retail product type in handlerTypeDenominator", ({
+            mockAgencyId,
+        }) => {
+            const interaction = RetailInteractionEncoder.customerMeeting({
+                agencyId: mockAgencyId,
+            });
+
+            // Should use retail product type (4)
+            const expectedDenominator = toHex(productTypes.retail);
+            expect(interaction.handlerTypeDenominator).toBe(
+                expectedDenominator
+            );
+        });
+
+        test("should include customerMeeting interaction type in data", ({
+            mockAgencyId,
+        }) => {
+            const interaction = RetailInteractionEncoder.customerMeeting({
+                agencyId: mockAgencyId,
+            });
+
+            // Should start with customerMeeting interaction type
+            expect(interaction.interactionData).toContain(
+                interactionTypes.retail.customerMeeting
+            );
+        });
+
+        test("should pad agency ID to 32 bytes", ({ mockAgencyId }) => {
+            const interaction = RetailInteractionEncoder.customerMeeting({
+                agencyId: mockAgencyId,
+            });
+
+            // Agency ID should be padded to 32 bytes
+            const paddedAgencyId = pad(mockAgencyId, { size: 32 });
+            expect(interaction.interactionData).toContain(
+                paddedAgencyId.slice(2)
+            );
+        });
+
+        test("should produce consistent output for same agency ID", ({
+            mockAgencyId,
+        }) => {
+            const interaction1 = RetailInteractionEncoder.customerMeeting({
+                agencyId: mockAgencyId,
+            });
+            const interaction2 = RetailInteractionEncoder.customerMeeting({
+                agencyId: mockAgencyId,
+            });
+
+            // Same input should produce same output
+            expect(interaction1).toEqual(interaction2);
+        });
+
+        test("should produce different output for different agency IDs", () => {
+            const agencyId1 =
+                "0x0000000000000000000000000000000000000000000000000000000000000001" as const;
+            const agencyId2 =
+                "0x0000000000000000000000000000000000000000000000000000000000000002" as const;
+
+            const interaction1 = RetailInteractionEncoder.customerMeeting({
+                agencyId: agencyId1,
+            });
+            const interaction2 = RetailInteractionEncoder.customerMeeting({
+                agencyId: agencyId2,
+            });
+
+            // Different agency IDs should produce different interaction data
+            expect(interaction1.interactionData).not.toBe(
+                interaction2.interactionData
+            );
+        });
+
+        test("should produce valid hex string", ({ mockAgencyId }) => {
+            const interaction = RetailInteractionEncoder.customerMeeting({
+                agencyId: mockAgencyId,
+            });
+
+            // Should be valid hex string starting with 0x
+            expect(interaction.interactionData).toMatch(/^0x[0-9a-f]+$/);
+        });
+    });
+});

package/src/interactions/retailEncoder.ts

@@ -0,0 +1,37 @@
+import { concatHex, type Hex, pad, toHex } from "viem";
+import { interactionTypes } from "../constants/interactionTypes";
+import { productTypes } from "../constants/productTypes";
+import type { PreparedInteraction } from "../types";
+
+/**
+ * Retail interactions allow you to track user activities on your retails products.
+ *
+ * :::info
+ *   To properly handle retail interactions, ensure that the "Retail" product type is enabled in your Business dashboard.
+ * :::
+ *
+ * @description Encode retail related user interactions
+ *
+ * @group Interactions Encoder
+ *
+ * @see {@link PreparedInteraction} The prepared interaction object that can be sent
+ * @see {@link !actions.sendInteraction | `sendInteraction()`} Action used to send the prepared interaction to the Frak Wallet
+ */
+export const RetailInteractionEncoder = {
+    /**
+     * Encode a customer meeting retail interaction
+     * @param args
+     * @param args.agencyId - The id of the agency that the customer is meeting with
+     *
+     */
+    customerMeeting({ agencyId }: { agencyId: Hex }): PreparedInteraction {
+        const interactionData = concatHex([
+            interactionTypes.retail.customerMeeting,
+            pad(agencyId, { size: 32 }),
+        ]);
+        return {
+            handlerTypeDenominator: toHex(productTypes.retail),
+            interactionData,
+        };
+    },
+};

package/src/interactions/webshopEncoder.test.ts

@@ -0,0 +1,56 @@
+/**
+ * Tests for WebShopInteractionEncoder
+ * Tests encoding of webshop-related user interactions
+ */
+
+import { toHex } from "viem";
+import { describe, expect, it } from "../../tests/vitest-fixtures";
+import { interactionTypes } from "../constants/interactionTypes";
+import { productTypes } from "../constants/productTypes";
+import { WebShopInteractionEncoder } from "./webshopEncoder";
+
+describe("WebShopInteractionEncoder", () => {
+    describe("open", () => {
+        it("should encode open webshop interaction with correct structure", () => {
+            const interaction = WebShopInteractionEncoder.open();
+
+            // Should return PreparedInteraction structure
+            expect(interaction).toHaveProperty("handlerTypeDenominator");
+            expect(interaction).toHaveProperty("interactionData");
+        });
+
+        it("should use webshop product type in handlerTypeDenominator", () => {
+            const interaction = WebShopInteractionEncoder.open();
+
+            // Should use webshop product type (3)
+            const expectedDenominator = toHex(productTypes.webshop);
+            expect(interaction.handlerTypeDenominator).toBe(
+                expectedDenominator
+            );
+        });
+
+        it("should use open interaction type in data", () => {
+            const interaction = WebShopInteractionEncoder.open();
+
+            // Should use open interaction type
+            expect(interaction.interactionData).toBe(
+                interactionTypes.webshop.open
+            );
+        });
+
+        it("should produce consistent output (no parameters)", () => {
+            const interaction1 = WebShopInteractionEncoder.open();
+            const interaction2 = WebShopInteractionEncoder.open();
+
+            // Should always produce the same output
+            expect(interaction1).toEqual(interaction2);
+        });
+
+        it("should produce valid hex string", () => {
+            const interaction = WebShopInteractionEncoder.open();
+
+            // Should be valid hex string starting with 0x
+            expect(interaction.interactionData).toMatch(/^0x[0-9a-f]+$/);
+        });
+    });
+});

package/src/interactions/webshopEncoder.ts

@@ -0,0 +1,30 @@
+import { toHex } from "viem";
+import { interactionTypes } from "../constants/interactionTypes";
+import { productTypes } from "../constants/productTypes";
+import type { PreparedInteraction } from "../types";
+
+/**
+ * Webshop interactions allow you to track user activities on your webshop.
+ *
+ * :::info
+ *   To properly handle webshop interactions, ensure that the "WebShop" product type is enabled in your Business dashboard.
+ * :::
+ *
+ * @description Encode webshop related user interactions
+ *
+ * @group Interactions Encoder
+ *
+ * @see {@link PreparedInteraction} The prepared interaction object that can be sent
+ * @see {@link !actions.sendInteraction | `sendInteraction()`} Action used to send the prepared interaction to the Frak Wallet
+ */
+export const WebShopInteractionEncoder = {
+    /**
+     * Encode an open webshop interaction
+     */
+    open(): PreparedInteraction {
+        return {
+            handlerTypeDenominator: toHex(productTypes.webshop),
+            interactionData: interactionTypes.webshop.open,
+        };
+    },
+};

package/src/types/client.ts

@@ -0,0 +1,14 @@
+import type { OpenPanel } from "@openpanel/web";
+import type { FrakWalletSdkConfig } from "./config";
+import type { IFrameTransport } from "./transport";
+
+/**
+ * Representing a Frak client, used to interact with the Frak Wallet
+ */
+export type FrakClient = {
+    config: FrakWalletSdkConfig;
+    debugInfo: {
+        formatDebugInfo: (error: Error | unknown | string) => string;
+    };
+    openPanel?: OpenPanel;
+} & IFrameTransport;

package/src/types/compression.ts

@@ -0,0 +1,22 @@
+/**
+ * The received encoded data from a client
+ *  -> The encoded should contain a HashProtectedData once decoded
+ *  @ignore
+ */
+export type CompressedData = Uint8Array;
+
+/**
+ * The encoded data to send to a client / received by a client
+ *  @ignore
+ */
+export type HashProtectedData<DataType> = Readonly<
+    DataType & {
+        validationHash: string;
+    }
+>;
+
+/**
+ * Represent a key provider used for the hashed and secure compression
+ *  @ignore
+ */
+export type KeyProvider<DataType> = (value: DataType) => string[];

package/src/types/config.ts

@@ -0,0 +1,111 @@
+/**
+ * All the currencies available
+ * @category Config
+ */
+export type Currency = "eur" | "usd" | "gbp";
+
+/**
+ * All the languages available
+ * @category Config
+ */
+export type Language = "fr" | "en";
+
+/**
+ * Configuration for the Frak Wallet SDK
+ * @category Config
+ */
+export type FrakWalletSdkConfig = {
+    /**
+     * The Frak wallet url
+     * @defaultValue "https://wallet.frak.id"
+     */
+    walletUrl?: string;
+    /**
+     * Some metadata about your implementation of the Frak SDK
+     */
+    metadata: {
+        /**
+         * Your application name (will be displayed in a few modals and in SSO)
+         */
+        name: string;
+        /**
+         * Language to display in the modal
+         * If undefined, will default to the browser language
+         */
+        lang?: Language;
+        /**
+         * The currency to display in the modal
+         * @defaultValue `"eur"`
+         */
+        currency?: Currency;
+        /**
+         * The logo URL that will be displayed in a few components
+         */
+        logoUrl?: string;
+        /**
+         * The homepage link that could be displayed in a few components
+         */
+        homepageLink?: string;
+    };
+    /**
+     * Some customization for the modal
+     */
+    customizations?: {
+        /**
+         * Custom CSS styles to apply to the modals and components
+         */
+        css?: `${string}.css`;
+        /**
+         * Custom i18n configuration for the modal
+         */
+        i18n?: I18nConfig;
+    };
+    /**
+     * The domain name of your application
+     * @defaultValue window.location.host
+     */
+    domain?: string;
+};
+
+/**
+ * Custom i18n configuration for the modal
+ *  See [i18next json format](https://www.i18next.com/misc/json-format#i18next-json-v4)
+ *
+ * Available variables
+ *  - `{{ productName }}` : The name of your website (`metadata.name`)
+ *  - `{{ productOrigin }}` : The origin url of your website
+ *  - `{{ estimatedReward }}` : The estimated reward for the user (based on the specific `targetInteraction` you can specify, or the max referrer reward if no target interaction is specified)
+ *
+ * Context of the translation [see i18n context](https://www.i18next.com/translation-function/context)
+ *  - For modal display, the key of the final action (`sharing`, `reward`, or undefined)
+ *  - For embedded wallet display, the key of the logged in action (`sharing` or undefined)
+ *
+ * @example
+ * ```ts
+ * // Multi language config
+ * const multiI18n = {
+ *  fr: {
+ *      "sdk.modal.title": "Titre de modal",
+ *      "sdk.modal.description": "Description de modal, avec {{ estimatedReward }} de gains possible",
+ *  },
+ *  en: "https://example.com/en.json"
+ * }
+ *
+ * // Single language config
+ * const singleI18n = {
+ *      "sdk.modal.title": "Modal title",
+ *      "sdk.modal.description": "Modal description, with {{ estimatedReward }} of gains possible",
+ * }
+ * ```
+ *
+ * @category Config
+ */
+export type I18nConfig =
+    | Record<Language, LocalizedI18nConfig>
+    | LocalizedI18nConfig;
+
+/**
+ * A localized i18n config
+ * @category Config
+ */
+export type LocalizedI18nConfig = `${string}.css` | { [key: string]: string };

package/src/types/context.ts

@@ -0,0 +1,13 @@
+import type { Address } from "viem";
+
+/**
+ * The current Frak Context
+ *
+ * For now, only contain a referrer address.
+ *
+ * @ignore
+ */
+export type FrakContext = {
+    // Referrer address
+    r: Address;
+};

package/src/types/index.ts

@@ -0,0 +1,71 @@
+// Rpc related
+
+// Client related
+export type { FrakClient } from "./client";
+export type {
+    CompressedData,
+    HashProtectedData,
+    KeyProvider,
+} from "./compression";
+export type {
+    Currency,
+    FrakWalletSdkConfig,
+    I18nConfig,
+    Language,
+    LocalizedI18nConfig,
+} from "./config";
+// Utils
+export type { FrakContext } from "./context";
+export type {
+    ClientLifecycleEvent,
+    IFrameLifecycleEvent,
+} from "./lifecycle";
+export type { IFrameRpcSchema } from "./rpc";
+// Modal related
+export type {
+    DisplayModalParamsType,
+    ModalRpcMetadata,
+    ModalRpcStepsInput,
+    ModalRpcStepsResultType,
+    ModalStepTypes,
+} from "./rpc/displayModal";
+export type {
+    DisplayEmbeddedWalletParamsType,
+    DisplayEmbeddedWalletResultType,
+    EmbeddedViewActionReferred,
+    EmbeddedViewActionSharing,
+    LoggedInEmbeddedView,
+    LoggedOutEmbeddedView,
+} from "./rpc/embedded";
+export type {
+    PreparedInteraction,
+    SendInteractionParamsType,
+    SendInteractionReturnType,
+} from "./rpc/interaction";
+export type {
+    FinalActionType,
+    FinalModalStepType,
+    LoginModalStepType,
+    ModalStepMetadata,
+    OpenInteractionSessionModalStepType,
+    OpenInteractionSessionReturnType,
+    SendTransactionModalStepType,
+    SendTransactionReturnType,
+    SendTransactionTxType,
+    SiweAuthenticateModalStepType,
+    SiweAuthenticateReturnType,
+    SiweAuthenticationParams,
+} from "./rpc/modal";
+export type {
+    GetProductInformationReturnType,
+    TokenAmountType,
+} from "./rpc/productInformation";
+export type {
+    OpenSsoParamsType,
+    OpenSsoReturnType,
+    PrepareSsoParamsType,
+    PrepareSsoReturnType,
+    SsoMetadata,
+} from "./rpc/sso";
+export type { WalletStatusReturnType } from "./rpc/walletStatus";
+export type { FrakLifecycleEvent, IFrameTransport } from "./transport";

package/src/types/lifecycle/client.ts

@@ -0,0 +1,46 @@
+import type { I18nConfig } from "../config";
+
+/**
+ * Event related to the iframe lifecycle
+ * @ignore
+ */
+export type ClientLifecycleEvent =
+    | CustomCssEvent
+    | CustomI18nEvent
+    | RestoreBackupEvent
+    | HearbeatEvent
+    | HandshakeResponse
+    | SsoRedirectCompleteEvent;
+
+type CustomCssEvent = {
+    clientLifecycle: "modal-css";
+    data: { cssLink: string };
+};
+
+type CustomI18nEvent = {
+    clientLifecycle: "modal-i18n";
+    data: { i18n: I18nConfig };
+};
+
+type RestoreBackupEvent = {
+    clientLifecycle: "restore-backup";
+    data: { backup: string };
+};
+
+type HearbeatEvent = {
+    clientLifecycle: "heartbeat";
+    data?: never;
+};
+
+type HandshakeResponse = {
+    clientLifecycle: "handshake-response";
+    data: {
+        token: string;
+        currentUrl: string;
+    };
+};
+
+type SsoRedirectCompleteEvent = {
+    clientLifecycle: "sso-redirect-complete";
+    data: { compressed: string };
+};

package/src/types/lifecycle/iframe.ts

@@ -0,0 +1,35 @@
+/**
+ * Event related to the iframe lifecycle
+ * @ignore
+ */
+export type IFrameLifecycleEvent =
+    | {
+          iframeLifecycle: "connected" | "show" | "hide" | "remove-backup";
+          data?: never;
+      }
+    | DoBackupEvent
+    | HandshakeRequestEvent
+    | RedirectRequestEvent;
+
+type DoBackupEvent = {
+    iframeLifecycle: "do-backup";
+    data: { backup?: string };
+};
+
+type HandshakeRequestEvent = {
+    iframeLifecycle: "handshake";
+    data: {
+        token: string;
+    };
+};
+
+type RedirectRequestEvent = {
+    iframeLifecycle: "redirect";
+    data: {
+        /**
+         * The base url to redirect to
+         *  If it contain a query param `u`, the client need will suffix the current url to the base url
+         */
+        baseRedirectUrl: string;
+    };
+};

package/src/types/lifecycle/index.ts

@@ -0,0 +1,2 @@
+export type { ClientLifecycleEvent } from "./client";
+export type { IFrameLifecycleEvent } from "./iframe";

package/src/types/rpc/displayModal.ts

@@ -0,0 +1,84 @@
+import type { FullInteractionTypesKey } from "../../constants/interactionTypes";
+import type { I18nConfig } from "../config";
+import type {
+    FinalModalStepType,
+    LoginModalStepType,
+    OpenInteractionSessionModalStepType,
+    SendTransactionModalStepType,
+    SiweAuthenticateModalStepType,
+} from "./modal";
+
+/**
+ * Generic type of steps we will display in the modal to the end user
+ * @group Modal Display
+ */
+export type ModalStepTypes =
+    | LoginModalStepType
+    | SiweAuthenticateModalStepType
+    | SendTransactionModalStepType
+    | OpenInteractionSessionModalStepType
+    | FinalModalStepType;
+
+/**
+ * Type for the result of a modal request
+ * Just the `returns` type of each `ModalStepTypes`
+ * @typeParam T - The list of modal steps we expect to have in the modal
+ * @group Modal Display
+ * @group RPC Schema
+ */
+export type ModalRpcStepsResultType<
+    T extends ModalStepTypes[] = ModalStepTypes[],
+> = {
+    [K in T[number]["key"]]: Extract<T[number], { key: K }>["returns"];
+};
+
+/**
+ * Type for the RPC input of a modal
+ * Just the `params` type of each `ModalStepTypes`
+ * @typeParam T - The list of modal steps we expect to have in the modal
+ * @group Modal Display
+ * @group RPC Schema
+ */
+export type ModalRpcStepsInput<T extends ModalStepTypes[] = ModalStepTypes[]> =
+    {
+        [K in T[number]["key"]]?: Extract<T[number], { key: K }>["params"];
+    };
+
+/**
+ * RPC metadata for the modal, used on top level modal configuration
+ * @group Modal Display
+ * @group RPC Schema
+ */
+export type ModalRpcMetadata = {
+    header?: {
+        title?: string;
+        icon?: string;
+    };
+    targetInteraction?: FullInteractionTypesKey;
+    /**
+     * Some i18n override for the displayed modal (i.e. update the displayed text only for this modal)
+     */
+    i18n?: I18nConfig;
+} & (
+    | {
+          isDismissible: true;
+          /**
+           * @deprecated Use `config.customizations.i18n` or `metadata.i18n` instead
+           */
+          dismissActionTxt?: string;
+      }
+    | {
+          isDismissible?: false;
+          dismissActionTxt?: never;
+      }
+);
+
+/**
+ * Params used to display a modal
+ * @typeParam T - The list of modal steps we expect to have in the modal
+ * @group Modal Display
+ */
+export type DisplayModalParamsType<T extends ModalStepTypes[]> = {
+    steps: ModalRpcStepsInput<T>;
+    metadata?: ModalRpcMetadata;
+};