@frak-labs/core-sdk 0.1.0-beta.8d103039 → 0.1.0-beta.d9302e66

package/src/clients/transports/iframeLifecycleManager.ts

@@ -15,7 +15,9 @@ export type IframeLifecycleManager = {
  */
 export function createIFrameLifecycleManager({
     iframe,
-}: { iframe: HTMLIFrameElement }): IframeLifecycleManager {
+}: {
+    iframe: HTMLIFrameElement;
+}): IframeLifecycleManager {
     // Create the isConnected listener
     const isConnectedDeferred = new Deferred<boolean>();
 

package/src/index.ts

@@ -1,103 +1,101 @@
 // Clients
+
+export { ssoPopupFeatures, ssoPopupName } from "./actions/openSso";
 export {
     createIFrameFrakClient,
-    setupClient,
     DebugInfoGatherer,
+    setupClient,
 } from "./clients";
-
-// Utils
 export {
-    compressJsonToB64,
-    decompressJsonFromB64,
-    createIframe,
-    FrakContextManager,
-    baseIframeProps,
-    findIframeInOpener,
-    getSupportedCurrency,
-    getSupportedLocale,
-    getCurrencyAmountKey,
-    formatAmount,
-    base64urlDecode,
-    base64urlEncode,
-    trackEvent,
-    generateSsoUrl,
-    type CompressedSsoData,
-    type FullSsoParams,
-    type AppSpecificSsoMetadata,
-} from "./utils";
-
+    type FullInteractionTypesKey,
+    type InteractionTypesKey,
+    interactionTypes,
+} from "./constants/interactionTypes";
+export { type LocalesKey, locales } from "./constants/locales";
 // Constants
 export {
     type ProductTypesKey,
     productTypes,
     productTypesMask,
 } from "./constants/productTypes";
-export {
-    interactionTypes,
-    type InteractionTypesKey,
-    type FullInteractionTypesKey,
-} from "./constants/interactionTypes";
-export { locales, type LocalesKey } from "./constants/locales";
-export { ssoPopupFeatures, ssoPopupName } from "./actions/openSso";
-
 // Types
 export type {
-    // Rpc
-    WalletStatusReturnType,
-    IFrameRpcSchema,
-    PreparedInteraction,
-    SendInteractionParamsType,
-    SendInteractionReturnType,
-    SsoMetadata,
-    PrepareSsoParamsType,
-    PrepareSsoReturnType,
-    OpenSsoParamsType,
-    OpenSsoReturnType,
+    ClientLifecycleEvent,
+    CompressedData,
     Currency,
-    Language,
-    I18nConfig,
-    LocalizedI18nConfig,
-    TokenAmountType,
-    GetProductInformationReturnType,
     // RPC Embedded wallet
     DisplayEmbeddedWalletParamsType,
     DisplayEmbeddedWalletResultType,
-    LoggedOutEmbeddedView,
-    LoggedInEmbeddedView,
+    DisplayModalParamsType,
     EmbeddedViewActionReferred,
     EmbeddedViewActionSharing,
-    // RPC Modal generics
-    ModalStepTypes,
-    ModalRpcMetadata,
-    DisplayModalParamsType,
-    ModalRpcStepsInput,
-    ModalRpcStepsResultType,
-    // RPC Modal types
-    ModalStepMetadata,
-    LoginModalStepType,
-    SiweAuthenticateModalStepType,
-    SiweAuthenticationParams,
-    SiweAuthenticateReturnType,
-    SendTransactionTxType,
-    SendTransactionModalStepType,
-    SendTransactionReturnType,
-    OpenInteractionSessionReturnType,
-    OpenInteractionSessionModalStepType,
-    FinalModalStepType,
     FinalActionType,
+    FinalModalStepType,
     // Client
     FrakClient,
-    // Transport
-    IFrameTransport,
-    IFrameLifecycleEvent,
-    ClientLifecycleEvent,
+    // Utils
+    FrakContext,
     FrakLifecycleEvent,
     // Config
     FrakWalletSdkConfig,
+    GetProductInformationReturnType,
+    HashProtectedData,
+    I18nConfig,
+    IFrameLifecycleEvent,
+    IFrameRpcSchema,
+    // Transport
+    IFrameTransport,
     // Compression
     KeyProvider,
-    CompressedData,
-    HashProtectedData,
-    // Utils
-    FrakContext,
+    Language,
+    LocalizedI18nConfig,
+    LoggedInEmbeddedView,
+    LoggedOutEmbeddedView,
+    LoginModalStepType,
+    ModalRpcMetadata,
+    ModalRpcStepsInput,
+    ModalRpcStepsResultType,
+    // RPC Modal types
+    ModalStepMetadata,
+    // RPC Modal generics
+    ModalStepTypes,
+    OpenInteractionSessionModalStepType,
+    OpenInteractionSessionReturnType,
+    OpenSsoParamsType,
+    OpenSsoReturnType,
+    PreparedInteraction,
+    PrepareSsoParamsType,
+    PrepareSsoReturnType,
+    SendInteractionParamsType,
+    SendInteractionReturnType,
+    SendTransactionModalStepType,
+    SendTransactionReturnType,
+    SendTransactionTxType,
+    SiweAuthenticateModalStepType,
+    SiweAuthenticateReturnType,
+    SiweAuthenticationParams,
+    SsoMetadata,
+    TokenAmountType,
+    // Rpc
+    WalletStatusReturnType,
 } from "./types";
+// Utils
+export {
+    type AppSpecificSsoMetadata,
+    base64urlDecode,
+    base64urlEncode,
+    baseIframeProps,
+    type CompressedSsoData,
+    compressJsonToB64,
+    createIframe,
+    decompressJsonFromB64,
+    FrakContextManager,
+    type FullSsoParams,
+    findIframeInOpener,
+    formatAmount,
+    generateSsoUrl,
+    getCurrencyAmountKey,
+    getSupportedCurrency,
+    getSupportedLocale,
+    trackEvent,
+} from "./utils";

package/src/interactions/index.ts

@@ -1,5 +1,5 @@
 export { PressInteractionEncoder } from "./pressEncoder";
-export { ReferralInteractionEncoder } from "./referralEncoder";
 export { PurchaseInteractionEncoder } from "./purchaseEncoder";
-export { WebShopInteractionEncoder } from "./webshopEncoder";
+export { ReferralInteractionEncoder } from "./referralEncoder";
 export { RetailInteractionEncoder } from "./retailEncoder";
+export { WebShopInteractionEncoder } from "./webshopEncoder";

package/src/interactions/pressEncoder.test.ts

@@ -0,0 +1,215 @@
+/**
+ * Tests for PressInteractionEncoder
+ * Tests encoding of press-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 { PressInteractionEncoder } from "./pressEncoder";
+
+describe("PressInteractionEncoder", () => {
+    describe("openArticle", () => {
+        test("should encode open article interaction with correct structure", ({
+            mockArticleId,
+        }) => {
+            const interaction = PressInteractionEncoder.openArticle({
+                articleId: mockArticleId,
+            });
+
+            // Should return PreparedInteraction structure
+            expect(interaction).toHaveProperty("handlerTypeDenominator");
+            expect(interaction).toHaveProperty("interactionData");
+        });
+
+        test("should use press product type in handlerTypeDenominator", ({
+            mockArticleId,
+        }) => {
+            const interaction = PressInteractionEncoder.openArticle({
+                articleId: mockArticleId,
+            });
+
+            // Should use press product type (2)
+            const expectedDenominator = toHex(productTypes.press);
+            expect(interaction.handlerTypeDenominator).toBe(
+                expectedDenominator
+            );
+        });
+
+        test("should include openArticle interaction type in data", ({
+            mockArticleId,
+        }) => {
+            const interaction = PressInteractionEncoder.openArticle({
+                articleId: mockArticleId,
+            });
+
+            // Should start with openArticle interaction type
+            expect(interaction.interactionData).toContain(
+                interactionTypes.press.openArticle
+            );
+        });
+
+        test("should pad article ID to 32 bytes", ({ mockArticleId }) => {
+            const interaction = PressInteractionEncoder.openArticle({
+                articleId: mockArticleId,
+            });
+
+            // Article ID should be padded to 32 bytes (64 hex chars + 0x prefix = 66 chars)
+            const paddedArticleId = pad(mockArticleId, { size: 32 });
+            expect(interaction.interactionData).toContain(
+                paddedArticleId.slice(2)
+            );
+        });
+
+        it("should handle short article IDs by padding", () => {
+            const shortArticleId = "0x01" as const;
+            const interaction = PressInteractionEncoder.openArticle({
+                articleId: shortArticleId,
+            });
+
+            // Should pad short IDs to 32 bytes
+            expect(interaction.interactionData).toBeDefined();
+            // Total length: openArticle (10 chars) + padded ID (64 chars) + 0x (2 chars) = 76 chars
+            expect(interaction.interactionData.length).toBeGreaterThan(64);
+        });
+
+        test("should produce consistent output for same article ID", ({
+            mockArticleId,
+        }) => {
+            const interaction1 = PressInteractionEncoder.openArticle({
+                articleId: mockArticleId,
+            });
+            const interaction2 = PressInteractionEncoder.openArticle({
+                articleId: mockArticleId,
+            });
+
+            // Same input should produce same output
+            expect(interaction1).toEqual(interaction2);
+        });
+    });
+
+    describe("readArticle", () => {
+        test("should encode read article interaction with correct structure", ({
+            mockArticleId,
+        }) => {
+            const interaction = PressInteractionEncoder.readArticle({
+                articleId: mockArticleId,
+            });
+
+            // Should return PreparedInteraction structure
+            expect(interaction).toHaveProperty("handlerTypeDenominator");
+            expect(interaction).toHaveProperty("interactionData");
+        });
+
+        test("should use press product type in handlerTypeDenominator", ({
+            mockArticleId,
+        }) => {
+            const interaction = PressInteractionEncoder.readArticle({
+                articleId: mockArticleId,
+            });
+
+            // Should use press product type (2)
+            const expectedDenominator = toHex(productTypes.press);
+            expect(interaction.handlerTypeDenominator).toBe(
+                expectedDenominator
+            );
+        });
+
+        test("should include readArticle interaction type in data", ({
+            mockArticleId,
+        }) => {
+            const interaction = PressInteractionEncoder.readArticle({
+                articleId: mockArticleId,
+            });
+
+            // Should start with readArticle interaction type
+            expect(interaction.interactionData).toContain(
+                interactionTypes.press.readArticle
+            );
+        });
+
+        test("should pad article ID to 32 bytes", ({ mockArticleId }) => {
+            const interaction = PressInteractionEncoder.readArticle({
+                articleId: mockArticleId,
+            });
+
+            // Article ID should be padded to 32 bytes
+            const paddedArticleId = pad(mockArticleId, { size: 32 });
+            expect(interaction.interactionData).toContain(
+                paddedArticleId.slice(2)
+            );
+        });
+
+        test("should produce different output than openArticle for same ID", ({
+            mockArticleId,
+        }) => {
+            const openInteraction = PressInteractionEncoder.openArticle({
+                articleId: mockArticleId,
+            });
+            const readInteraction = PressInteractionEncoder.readArticle({
+                articleId: mockArticleId,
+            });
+
+            // Different interaction types should produce different data
+            expect(openInteraction.interactionData).not.toBe(
+                readInteraction.interactionData
+            );
+
+            // But should have same handlerTypeDenominator (both press)
+            expect(openInteraction.handlerTypeDenominator).toBe(
+                readInteraction.handlerTypeDenominator
+            );
+        });
+    });
+
+    describe("interaction data format", () => {
+        test("should concatenate interaction type and padded article ID", ({
+            mockArticleId,
+        }) => {
+            const interaction = PressInteractionEncoder.openArticle({
+                articleId: mockArticleId,
+            });
+
+            // Should start with interaction type (10 chars including 0x)
+            expect(interaction.interactionData.slice(0, 10)).toBe(
+                interactionTypes.press.openArticle
+            );
+
+            // Should be followed by padded article ID (64 hex chars)
+            expect(interaction.interactionData.length).toBe(74); // 0x + 8 (type) + 64 (padded ID)
+        });
+
+        test("should produce valid hex strings", ({ mockArticleId }) => {
+            const openInteraction = PressInteractionEncoder.openArticle({
+                articleId: mockArticleId,
+            });
+            const readInteraction = PressInteractionEncoder.readArticle({
+                articleId: mockArticleId,
+            });
+
+            // Both should be valid hex strings starting with 0x
+            expect(openInteraction.interactionData).toMatch(/^0x[0-9a-f]+$/);
+            expect(readInteraction.interactionData).toMatch(/^0x[0-9a-f]+$/);
+        });
+
+        it("should handle different article IDs correctly", () => {
+            const articleId1 =
+                "0x0000000000000000000000000000000000000000000000000000000000000001" as const;
+            const articleId2 =
+                "0x0000000000000000000000000000000000000000000000000000000000000002" as const;
+
+            const interaction1 = PressInteractionEncoder.openArticle({
+                articleId: articleId1,
+            });
+            const interaction2 = PressInteractionEncoder.openArticle({
+                articleId: articleId2,
+            });
+
+            // Different article IDs should produce different interaction data
+            expect(interaction1.interactionData).not.toBe(
+                interaction2.interactionData
+            );
+        });
+    });
+});

package/src/interactions/pressEncoder.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";