@frak-labs/core-sdk 0.1.0-beta.8d103039 → 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/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

@@ -1,4 +1,4 @@
-import { type Hex, concatHex, pad, toHex } from "viem";
+import { concatHex, type Hex, pad, toHex } from "viem";
 import { interactionTypes } from "../constants/interactionTypes";
 import { productTypes } from "../constants/productTypes";
 import type { PreparedInteraction } from "../types";

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/types/index.ts

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

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

package/src/types/rpc/embedded/loggedIn.ts

@@ -17,7 +17,7 @@ export type EmbeddedViewActionSharing = {
         popupTitle?: string;
         /**
          * The text that will be shared alongside the link.
-         * Can contain the variable {LINK} to specify where the link is placed, otherwise it will be added at the end
+         * Can contain the variable `{LINK}` to specify where the link is placed, otherwise it will be added at the end
          * @deprecated Use the top level `config.metadata.i18n` instead
          */
         text?: string;

package/src/types/rpc/embedded/loggedOut.ts

@@ -10,7 +10,7 @@ export type LoggedOutEmbeddedView = {
         /**
          * The main CTA for the logged out view
          *  - can include some variable, available ones are:
-         *      - {REWARD} -> The maximum reward a user can receive when interacting on your website
+         *      - `{REWARD}` -> The maximum reward a user can receive when interacting on your website
          *  - can be formatted in markdown
          *
          * If not set, it will default to a internationalized message

package/src/types/rpc/modal/index.ts

@@ -1,20 +1,20 @@
+export type {
+    FinalActionType,
+    FinalModalStepType,
+} from "./final";
+export type { ModalStepMetadata } from "./generic";
 export type { LoginModalStepType } from "./login";
+export type {
+    OpenInteractionSessionModalStepType,
+    OpenInteractionSessionReturnType,
+} from "./openSession";
 export type {
     SiweAuthenticateModalStepType,
-    SiweAuthenticationParams,
     SiweAuthenticateReturnType,
+    SiweAuthenticationParams,
 } from "./siweAuthenticate";
 export type {
     SendTransactionModalStepType,
-    SendTransactionTxType,
     SendTransactionReturnType,
+    SendTransactionTxType,
 } from "./transaction";
-export type {
-    OpenInteractionSessionReturnType,
-    OpenInteractionSessionModalStepType,
-} from "./openSession";
-export type { ModalStepMetadata } from "./generic";
-export type {
-    FinalModalStepType,
-    FinalActionType,
-} from "./final";