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

package/src/interactions/referralEncoder.test.ts

@@ -0,0 +1,170 @@
+/**
+ * Tests for ReferralInteractionEncoder
+ * Tests encoding of referral-related user interactions
+ */
+
+import { pad, toHex } from "viem";
+import { describe, expect, it, test } from "../../tests/vitest-fixtures";
+import { interactionTypes } from "../constants/interactionTypes";
+import { productTypes } from "../constants/productTypes";
+import { ReferralInteractionEncoder } from "./referralEncoder";
+
+describe("ReferralInteractionEncoder", () => {
+    describe("createLink", () => {
+        it("should encode create link interaction with correct structure", () => {
+            const interaction = ReferralInteractionEncoder.createLink();
+
+            // Should return PreparedInteraction structure
+            expect(interaction).toHaveProperty("handlerTypeDenominator");
+            expect(interaction).toHaveProperty("interactionData");
+        });
+
+        it("should use referral product type in handlerTypeDenominator", () => {
+            const interaction = ReferralInteractionEncoder.createLink();
+
+            // Should use referral product type (30)
+            const expectedDenominator = toHex(productTypes.referral);
+            expect(interaction.handlerTypeDenominator).toBe(
+                expectedDenominator
+            );
+        });
+
+        it("should use createLink interaction type in data", () => {
+            const interaction = ReferralInteractionEncoder.createLink();
+
+            // Should use createLink interaction type
+            expect(interaction.interactionData).toBe(
+                interactionTypes.referral.createLink
+            );
+        });
+
+        it("should produce consistent output (no parameters)", () => {
+            const interaction1 = ReferralInteractionEncoder.createLink();
+            const interaction2 = ReferralInteractionEncoder.createLink();
+
+            // Should always produce the same output
+            expect(interaction1).toEqual(interaction2);
+        });
+    });
+
+    describe("referred", () => {
+        test("should encode referred interaction with correct structure", ({
+            mockReferrerAddress,
+        }) => {
+            const interaction = ReferralInteractionEncoder.referred({
+                referrer: mockReferrerAddress,
+            });
+
+            // Should return PreparedInteraction structure
+            expect(interaction).toHaveProperty("handlerTypeDenominator");
+            expect(interaction).toHaveProperty("interactionData");
+        });
+
+        test("should use referral product type in handlerTypeDenominator", ({
+            mockReferrerAddress,
+        }) => {
+            const interaction = ReferralInteractionEncoder.referred({
+                referrer: mockReferrerAddress,
+            });
+
+            // Should use referral product type (30)
+            const expectedDenominator = toHex(productTypes.referral);
+            expect(interaction.handlerTypeDenominator).toBe(
+                expectedDenominator
+            );
+        });
+
+        test("should include referred interaction type in data", ({
+            mockReferrerAddress,
+        }) => {
+            const interaction = ReferralInteractionEncoder.referred({
+                referrer: mockReferrerAddress,
+            });
+
+            // Should start with referred interaction type
+            expect(interaction.interactionData).toContain(
+                interactionTypes.referral.referred
+            );
+        });
+
+        test("should pad referrer address to 32 bytes", ({
+            mockReferrerAddress,
+        }) => {
+            const interaction = ReferralInteractionEncoder.referred({
+                referrer: mockReferrerAddress,
+            });
+
+            // Referrer address should be padded to 32 bytes
+            const paddedAddress = pad(mockReferrerAddress, { size: 32 });
+            expect(interaction.interactionData).toContain(
+                paddedAddress.slice(2)
+            );
+        });
+
+        test("should produce different output for different referrers", () => {
+            const referrer1 =
+                "0x1234567890123456789012345678901234567890" as const;
+            const referrer2 =
+                "0xabcdefabcdefabcdefabcdefabcdefabcdefabcd" as const;
+
+            const interaction1 = ReferralInteractionEncoder.referred({
+                referrer: referrer1,
+            });
+            const interaction2 = ReferralInteractionEncoder.referred({
+                referrer: referrer2,
+            });
+
+            // Different referrers should produce different interaction data
+            expect(interaction1.interactionData).not.toBe(
+                interaction2.interactionData
+            );
+        });
+
+        test("should produce consistent output for same referrer", ({
+            mockReferrerAddress,
+        }) => {
+            const interaction1 = ReferralInteractionEncoder.referred({
+                referrer: mockReferrerAddress,
+            });
+            const interaction2 = ReferralInteractionEncoder.referred({
+                referrer: mockReferrerAddress,
+            });
+
+            // Same referrer should produce same output
+            expect(interaction1).toEqual(interaction2);
+        });
+    });
+
+    describe("interaction data format", () => {
+        test("should produce valid hex strings", ({ mockReferrerAddress }) => {
+            const createLinkInteraction =
+                ReferralInteractionEncoder.createLink();
+            const referredInteraction = ReferralInteractionEncoder.referred({
+                referrer: mockReferrerAddress,
+            });
+
+            // Both should be valid hex strings starting with 0x
+            expect(createLinkInteraction.interactionData).toMatch(
+                /^0x[0-9a-f]+$/
+            );
+            expect(referredInteraction.interactionData).toMatch(
+                /^0x[0-9a-f]+$/
+            );
+        });
+
+        test("should have different interaction types", ({
+            mockReferrerAddress,
+        }) => {
+            const createLinkInteraction =
+                ReferralInteractionEncoder.createLink();
+            const referredInteraction = ReferralInteractionEncoder.referred({
+                referrer: mockReferrerAddress,
+            });
+
+            // Different interaction types should produce different data
+            expect(createLinkInteraction.interactionData).not.toBe(
+                referredInteraction.interactionData
+            );
+        });
+    });
+});

package/src/interactions/referralEncoder.ts

@@ -0,0 +1,47 @@
+import { type Address, concatHex, pad, toHex } from "viem";
+import { interactionTypes } from "../constants/interactionTypes";
+import { productTypes } from "../constants/productTypes";
+import type { PreparedInteraction } from "../types";
+
+/**
+ * Referral interactions allow you to track user sharing activities.
+ * These interactions are essential for platforms looking to grow their user base through user-to-user referrals and reward systems.
+ *
+ * :::info
+ *   To properly handle referral interactions, ensure that the "Referral" product type is enabled in your Business dashboard.
+ * :::
+ *
+ * @description Encode referral 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 ReferralInteractionEncoder = {
+    /**
+     * Records the event of a user creating a referral link. Note that this interaction doesn't actually create the link itself; it only sends an event to track that a link was created.
+     */
+    createLink(): PreparedInteraction {
+        return {
+            handlerTypeDenominator: toHex(productTypes.referral),
+            interactionData: interactionTypes.referral.createLink,
+        };
+    },
+
+    /**
+     * Encode a referred interaction
+     * @param args
+     * @param args.referrer - The Ethereum address of the user who made the referral
+     */
+    referred({ referrer }: { referrer: Address }): PreparedInteraction {
+        const interactionData = concatHex([
+            interactionTypes.referral.referred,
+            pad(referrer, { size: 32 }),
+        ]);
+        return {
+            handlerTypeDenominator: toHex(productTypes.referral),
+            interactionData,
+        };
+    },
+};

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