@frak-labs/core-sdk 0.1.0 → 0.1.1-beta.4dfea079

package/src/utils/sso.ts

@@ -0,0 +1,126 @@
+import type { Hex } from "viem";
+import type { PrepareSsoParamsType, SsoMetadata } from "../types";
+import { getClientId } from "./clientId";
+import { compressJsonToB64 } from "./compression/compress";
+
+export type AppSpecificSsoMetadata = SsoMetadata & {
+    name: string;
+    css?: string;
+};
+
+/**
+ * The full SSO params that will be used for compression
+ */
+export type FullSsoParams = Omit<PrepareSsoParamsType, "metadata"> & {
+    metadata: AppSpecificSsoMetadata;
+    merchantId: string;
+    clientId: string;
+};
+
+/**
+ * Generate SSO URL with compressed parameters
+ * This mirrors the wallet's getOpenSsoLink() function
+ *
+ * @param walletUrl - Base wallet URL (e.g., "https://wallet.frak.id")
+ * @param params - SSO parameters
+ * @param productId - Product identifier
+ * @param name - Application name
+ * @param css - Optional custom CSS
+ * @returns Complete SSO URL ready to open in popup or redirect
+ *
+ * @example
+ * ```ts
+ * const ssoUrl = generateSsoUrl(
+ *   "https://wallet.frak.id",
+ *   { metadata: { logoUrl: "..." }, directExit: true },
+ *   "0x123...",
+ *   "My App"
+ * );
+ * // Returns: https://wallet.frak.id/sso?p=<compressed_base64>
+ * ```
+ */
+export function generateSsoUrl(
+    walletUrl: string,
+    params: PrepareSsoParamsType,
+    merchantId: string,
+    name: string,
+    css?: string,
+    clientId?: string
+): string {
+    // Build full params with app-specific metadata
+    const fullParams: FullSsoParams = {
+        redirectUrl: params.redirectUrl,
+        directExit: params.directExit,
+        lang: params.lang,
+        merchantId,
+        metadata: {
+            name,
+            css,
+            logoUrl: params.metadata?.logoUrl,
+            homepageLink: params.metadata?.homepageLink,
+        },
+        clientId: clientId ?? getClientId(),
+    };
+
+    // Compress params to minimal format
+    const compressedParam = ssoParamsToCompressed(fullParams);
+
+    // Encode to base64url
+    const compressedString = compressJsonToB64(compressedParam);
+
+    // Build URL matching wallet's expected format: /sso?p=<compressed>
+    const ssoUrl = new URL(walletUrl);
+    ssoUrl.pathname = "/sso";
+    ssoUrl.searchParams.set("p", compressedString);
+
+    return ssoUrl.toString();
+}
+
+/**
+ * Map full sso params to compressed sso params
+ * @param params
+ */
+function ssoParamsToCompressed(params: FullSsoParams): CompressedSsoData {
+    return {
+        r: params.redirectUrl,
+        cId: params.clientId,
+        d: params.directExit,
+        l: params.lang,
+        m: params.merchantId,
+        md: {
+            n: params.metadata?.name,
+            css: params.metadata?.css,
+            l: params.metadata?.logoUrl,
+            h: params.metadata?.homepageLink,
+        },
+    };
+}
+
+/**
+ * Type of compressed the sso data
+ */
+export type CompressedSsoData = {
+    // Potential id from backend
+    id?: Hex;
+    // Client id
+    cId: string;
+    // redirect url
+    r?: string;
+    // direct exit
+    d?: boolean;
+    // language
+    l?: "en" | "fr";
+    // merchant id
+    m: string;
+    // metadata
+    md: {
+        // merchant name
+        n: string;
+        // custom css
+        css?: string;
+        // logo
+        l?: string;
+        // home page link
+        h?: string;
+    };
+};

package/src/utils/ssoUrlListener.test.ts

@@ -0,0 +1,252 @@
+import type { RpcClient } from "@frak-labs/frame-connector";
+import {
+    afterEach,
+    beforeEach,
+    describe,
+    expect,
+    it,
+    vi,
+} from "../../tests/vitest-fixtures";
+import type { FrakLifecycleEvent } from "../types";
+import type { IFrameRpcSchema } from "../types/rpc";
+import { setupSsoUrlListener } from "./ssoUrlListener";
+
+describe("setupSsoUrlListener", () => {
+    let mockRpcClient: RpcClient<IFrameRpcSchema, FrakLifecycleEvent>;
+    let mockWaitForConnection: Promise<boolean>;
+    let originalLocation: Location;
+    let originalHistory: History;
+    let consoleLogSpy: ReturnType<typeof vi.spyOn>;
+    let consoleErrorSpy: ReturnType<typeof vi.spyOn>;
+
+    beforeEach(() => {
+        // Save original values
+        originalLocation = window.location;
+        originalHistory = window.history;
+
+        // Mock RPC client
+        mockRpcClient = {
+            sendLifecycle: vi.fn(),
+        } as any;
+
+        // Mock console methods
+        consoleLogSpy = vi.spyOn(console, "log").mockImplementation(() => {});
+        consoleErrorSpy = vi
+            .spyOn(console, "error")
+            .mockImplementation(() => {});
+
+        // Mock history.replaceState
+        window.history.replaceState = vi.fn();
+    });
+
+    afterEach(() => {
+        vi.clearAllMocks();
+        consoleLogSpy.mockRestore();
+        consoleErrorSpy.mockRestore();
+
+        // Restore original values
+        Object.defineProperty(window, "location", {
+            value: originalLocation,
+            writable: true,
+        });
+        Object.defineProperty(window, "history", {
+            value: originalHistory,
+            writable: true,
+        });
+    });
+
+    it("should do nothing when window is undefined", () => {
+        const originalWindow = global.window;
+        // @ts-expect-error - intentionally removing window for test
+        delete global.window;
+
+        setupSsoUrlListener(mockRpcClient, Promise.resolve(true));
+
+        expect(mockRpcClient.sendLifecycle).not.toHaveBeenCalled();
+
+        // Restore window
+        global.window = originalWindow;
+    });
+
+    it("should do nothing when no SSO parameter in URL", () => {
+        Object.defineProperty(window, "location", {
+            value: {
+                href: "https://example.com/test",
+            },
+            writable: true,
+        });
+
+        setupSsoUrlListener(mockRpcClient, Promise.resolve(true));
+
+        expect(mockRpcClient.sendLifecycle).not.toHaveBeenCalled();
+        expect(window.history.replaceState).not.toHaveBeenCalled();
+    });
+
+    it("should forward SSO data to iframe when connection is ready", async () => {
+        const compressedSso = "compressed-sso-data";
+        Object.defineProperty(window, "location", {
+            value: {
+                href: `https://example.com/test?sso=${compressedSso}`,
+            },
+            writable: true,
+        });
+
+        mockWaitForConnection = Promise.resolve(true);
+
+        setupSsoUrlListener(mockRpcClient, mockWaitForConnection);
+
+        await mockWaitForConnection;
+
+        // Wait for promise to resolve
+        await new Promise((resolve) => setTimeout(resolve, 0));
+
+        expect(mockRpcClient.sendLifecycle).toHaveBeenCalledWith({
+            clientLifecycle: "sso-redirect-complete",
+            data: { compressed: compressedSso },
+        });
+
+        expect(consoleLogSpy).toHaveBeenCalledWith(
+            "[SSO URL Listener] Forwarded compressed SSO data to iframe"
+        );
+    });
+
+    it("should clean URL immediately after detecting SSO parameter", async () => {
+        const compressedSso = "compressed-sso-data";
+        const originalUrl = `https://example.com/test?sso=${compressedSso}`;
+        Object.defineProperty(window, "location", {
+            value: {
+                href: originalUrl,
+            },
+            writable: true,
+        });
+
+        mockWaitForConnection = Promise.resolve(true);
+
+        setupSsoUrlListener(mockRpcClient, mockWaitForConnection);
+
+        // URL should be cleaned immediately, before connection resolves
+        expect(window.history.replaceState).toHaveBeenCalledWith(
+            {},
+            "",
+            "https://example.com/test"
+        );
+
+        expect(consoleLogSpy).toHaveBeenCalledWith(
+            "[SSO URL Listener] SSO parameter detected and URL cleaned"
+        );
+    });
+
+    it("should handle connection promise rejection", async () => {
+        const compressedSso = "compressed-sso-data";
+        Object.defineProperty(window, "location", {
+            value: {
+                href: `https://example.com/test?sso=${compressedSso}`,
+            },
+            writable: true,
+        });
+
+        const connectionError = new Error("Connection failed");
+        mockWaitForConnection = Promise.reject(connectionError);
+
+        setupSsoUrlListener(mockRpcClient, mockWaitForConnection);
+
+        await mockWaitForConnection.catch(() => {});
+
+        // Wait for promise to reject
+        await new Promise((resolve) => setTimeout(resolve, 0));
+
+        expect(mockRpcClient.sendLifecycle).not.toHaveBeenCalled();
+        expect(consoleErrorSpy).toHaveBeenCalledWith(
+            "[SSO URL Listener] Failed to forward SSO data:",
+            connectionError
+        );
+    });
+
+    it("should handle URL with multiple parameters", async () => {
+        const compressedSso = "compressed-sso-data";
+        Object.defineProperty(window, "location", {
+            value: {
+                href: `https://example.com/test?param1=value1&sso=${compressedSso}&param2=value2`,
+            },
+            writable: true,
+        });
+
+        mockWaitForConnection = Promise.resolve(true);
+
+        setupSsoUrlListener(mockRpcClient, mockWaitForConnection);
+
+        await mockWaitForConnection;
+        await new Promise((resolve) => setTimeout(resolve, 0));
+
+        expect(mockRpcClient.sendLifecycle).toHaveBeenCalledWith({
+            clientLifecycle: "sso-redirect-complete",
+            data: { compressed: compressedSso },
+        });
+
+        // Should remove only the sso parameter
+        expect(window.history.replaceState).toHaveBeenCalledWith(
+            {},
+            "",
+            "https://example.com/test?param1=value1&param2=value2"
+        );
+    });
+
+    it("should not process empty SSO parameter", () => {
+        Object.defineProperty(window, "location", {
+            value: {
+                href: "https://example.com/test?sso=",
+            },
+            writable: true,
+        });
+
+        setupSsoUrlListener(mockRpcClient, Promise.resolve(true));
+
+        // Empty string is falsy, so it should not process
+        expect(window.history.replaceState).not.toHaveBeenCalled();
+        expect(mockRpcClient.sendLifecycle).not.toHaveBeenCalled();
+    });
+
+    it("should clean URL even if connection fails", async () => {
+        const compressedSso = "compressed-sso-data";
+        Object.defineProperty(window, "location", {
+            value: {
+                href: `https://example.com/test?sso=${compressedSso}`,
+            },
+            writable: true,
+        });
+
+        const connectionError = new Error("Connection failed");
+        mockWaitForConnection = Promise.reject(connectionError);
+
+        setupSsoUrlListener(mockRpcClient, mockWaitForConnection);
+
+        // URL should still be cleaned even if connection fails
+        expect(window.history.replaceState).toHaveBeenCalledWith(
+            {},
+            "",
+            "https://example.com/test"
+        );
+
+        await mockWaitForConnection.catch(() => {});
+        await new Promise((resolve) => setTimeout(resolve, 0));
+    });
+
+    it("should handle URL with hash", () => {
+        const compressedSso = "compressed-sso-data";
+        Object.defineProperty(window, "location", {
+            value: {
+                href: `https://example.com/test?sso=${compressedSso}#section`,
+            },
+            writable: true,
+        });
+
+        setupSsoUrlListener(mockRpcClient, Promise.resolve(true));
+
+        // Should preserve hash when cleaning URL
+        expect(window.history.replaceState).toHaveBeenCalledWith(
+            {},
+            "",
+            "https://example.com/test#section"
+        );
+    });
+});

package/src/utils/ssoUrlListener.ts

@@ -0,0 +1,60 @@
+import type { RpcClient } from "@frak-labs/frame-connector";
+import type { FrakLifecycleEvent } from "../types";
+import type { IFrameRpcSchema } from "../types/rpc";
+
+/**
+ * Listen for SSO redirect with compressed data in URL
+ * Forwards compressed data to iframe via lifecycle event
+ * Cleans URL immediately after detection
+ *
+ * Performance: One-shot URL check, no polling, no re-renders
+ *
+ * @param rpcClient - RPC client instance to send lifecycle events
+ * @param waitForConnection - Promise that resolves when iframe is connected
+ */
+export function setupSsoUrlListener(
+    rpcClient: RpcClient<IFrameRpcSchema, FrakLifecycleEvent>,
+    waitForConnection: Promise<boolean>
+): void {
+    if (typeof window === "undefined") {
+        return;
+    }
+
+    // One-shot URL check - no need for MutationObserver or polling
+    const url = new URL(window.location.href);
+    const compressedSso = url.searchParams.get("sso");
+
+    // Early return if no SSO parameter
+    if (!compressedSso) {
+        return;
+    }
+
+    // Forward compressed data directly to iframe (no decompression on SDK side)
+    // Iframe will decompress and process
+    waitForConnection
+        .then(() => {
+            // Send lifecycle event with compressed string
+            // This is a one-way notification, no response expected
+            rpcClient.sendLifecycle({
+                clientLifecycle: "sso-redirect-complete",
+                data: { compressed: compressedSso },
+            });
+
+            console.log(
+                "[SSO URL Listener] Forwarded compressed SSO data to iframe"
+            );
+        })
+        .catch((error) => {
+            console.error(
+                "[SSO URL Listener] Failed to forward SSO data:",
+                error
+            );
+        });
+
+    // Clean URL immediately to prevent exposure in browser history
+    // Use replaceState to avoid navigation/re-render
+    url.searchParams.delete("sso");
+    window.history.replaceState({}, "", url.toString());
+
+    console.log("[SSO URL Listener] SSO parameter detected and URL cleaned");
+}

package/src/utils/trackEvent.test.ts

@@ -0,0 +1,180 @@
+/**
+ * Tests for trackEvent utility function
+ * Tests OpenPanel event tracking wrapper
+ */
+
+import {
+    afterEach,
+    beforeEach,
+    describe,
+    expect,
+    it,
+    vi,
+} from "../../tests/vitest-fixtures";
+import type { FrakClient } from "../types";
+import { trackEvent } from "./trackEvent";
+
+describe("trackEvent", () => {
+    let mockClient: FrakClient;
+    let consoleDebugSpy: any;
+
+    beforeEach(() => {
+        // Create mock client
+        mockClient = {
+            openPanel: {
+                track: vi.fn(),
+            },
+        } as unknown as FrakClient;
+
+        // Spy on console.debug
+        consoleDebugSpy = vi
+            .spyOn(console, "debug")
+            .mockImplementation(() => {});
+    });
+
+    afterEach(() => {
+        consoleDebugSpy.mockRestore();
+    });
+
+    describe("success cases", () => {
+        it("should track event with client", () => {
+            trackEvent(mockClient, "share_button_clicked");
+
+            expect(mockClient.openPanel?.track).toHaveBeenCalledWith(
+                "share_button_clicked",
+                {}
+            );
+        });
+
+        it("should track event with props", () => {
+            const props = { userId: "123", page: "home" };
+            trackEvent(mockClient, "wallet_button_clicked", props);
+
+            expect(mockClient.openPanel?.track).toHaveBeenCalledWith(
+                "wallet_button_clicked",
+                props
+            );
+        });
+
+        it("should track share_modal_error event", () => {
+            const props = { error: "Network error" };
+            trackEvent(mockClient, "share_modal_error", props);
+
+            expect(mockClient.openPanel?.track).toHaveBeenCalledWith(
+                "share_modal_error",
+                props
+            );
+        });
+
+        it("should track user_referred_started event", () => {
+            trackEvent(mockClient, "user_referred_started");
+
+            expect(mockClient.openPanel?.track).toHaveBeenCalledWith(
+                "user_referred_started",
+                {}
+            );
+        });
+
+        it("should track user_referred_completed event", () => {
+            trackEvent(mockClient, "user_referred_completed");
+
+            expect(mockClient.openPanel?.track).toHaveBeenCalledWith(
+                "user_referred_completed",
+                {}
+            );
+        });
+
+        it("should track user_referred_error event", () => {
+            trackEvent(mockClient, "user_referred_error");
+
+            expect(mockClient.openPanel?.track).toHaveBeenCalledWith(
+                "user_referred_error",
+                {}
+            );
+        });
+    });
+
+    describe("without client", () => {
+        it("should not throw when client is undefined", () => {
+            expect(() => {
+                trackEvent(undefined, "share_button_clicked");
+            }).not.toThrow();
+        });
+
+        it("should log debug message when client is undefined", () => {
+            trackEvent(undefined, "wallet_button_clicked");
+
+            expect(consoleDebugSpy).toHaveBeenCalledWith(
+                "[Frak] No client provided, skipping event tracking"
+            );
+        });
+
+        it("should not call track when client is undefined", () => {
+            const trackMock = vi.fn();
+            const undefinedClient = undefined;
+
+            trackEvent(undefinedClient, "share_button_clicked");
+
+            expect(trackMock).not.toHaveBeenCalled();
+        });
+    });
+
+    describe("error handling", () => {
+        it("should catch and log errors from track()", () => {
+            const error = new Error("Track failed");
+            mockClient.openPanel = {
+                track: vi.fn().mockImplementation(() => {
+                    throw error;
+                }),
+            } as any;
+
+            expect(() => {
+                trackEvent(mockClient, "share_button_clicked");
+            }).not.toThrow();
+
+            expect(consoleDebugSpy).toHaveBeenCalledWith(
+                "[Frak] Failed to track event:",
+                "share_button_clicked",
+                error
+            );
+        });
+
+        it("should not throw when openPanel is undefined", () => {
+            const clientWithoutPanel = {} as FrakClient;
+
+            expect(() => {
+                trackEvent(clientWithoutPanel, "wallet_button_clicked");
+            }).not.toThrow();
+        });
+    });
+
+    describe("edge cases", () => {
+        it("should handle empty props object", () => {
+            trackEvent(mockClient, "share_button_clicked", {});
+
+            expect(mockClient.openPanel?.track).toHaveBeenCalledWith(
+                "share_button_clicked",
+                {}
+            );
+        });
+
+        it("should handle complex props object", () => {
+            const complexProps = {
+                userId: "123",
+                metadata: {
+                    page: "home",
+                    section: "header",
+                },
+                tags: ["tag1", "tag2"],
+                timestamp: Date.now(),
+            };
+
+            trackEvent(mockClient, "user_referred_completed", complexProps);
+
+            expect(mockClient.openPanel?.track).toHaveBeenCalledWith(
+                "user_referred_completed",
+                complexProps
+            );
+        });
+    });
+});

package/src/utils/trackEvent.ts

@@ -0,0 +1,31 @@
+import type { FrakClient } from "../types";
+
+export type FrakEvent =
+    | "share_button_clicked"
+    | "wallet_button_clicked"
+    | "open_in_app_clicked"
+    | "open_in_app_login_clicked"
+    | "app_not_installed"
+    | "share_modal_error"
+    | "user_referred_started"
+    | "user_referred_completed"
+    | "user_referred_error";
+
+type EventProps = Record<string, unknown>;
+
+export function trackEvent(
+    client: FrakClient | undefined,
+    event: FrakEvent,
+    props: EventProps = {}
+): void {
+    if (!client) {
+        console.debug("[Frak] No client provided, skipping event tracking");
+        return;
+    }
+
+    try {
+        client.openPanel?.track(event, props);
+    } catch (e) {
+        console.debug("[Frak] Failed to track event:", event, e);
+    }
+}

package/cdn/bundle.js.LICENSE.txt

@@ -1,10 +0,0 @@
-/*!
- * The buffer module from node.js, for the browser.
- *
- * @author   Feross Aboukhadijeh <https://feross.org>
- * @license  MIT
- */
-
-/*! ieee754. BSD-3-Clause License. Feross Aboukhadijeh <https://feross.org/opensource> */
-
-/*! noble-hashes - MIT License (c) 2022 Paul Miller (paulmillr.com) */

package/dist/interactions.cjs

@@ -1 +0,0 @@
-"use strict";let __rslib_import_meta_url__="undefined"==typeof document?new(require("url".replace("",""))).URL("file:"+__filename).href:document.currentScript&&document.currentScript.src||new URL("main.js",document.baseURI).href;var __webpack_require__={};__webpack_require__.d=(e,r)=>{for(var t in r)__webpack_require__.o(r,t)&&!__webpack_require__.o(e,t)&&Object.defineProperty(e,t,{enumerable:!0,get:r[t]})},__webpack_require__.o=(e,r)=>Object.prototype.hasOwnProperty.call(e,r),__webpack_require__.r=e=>{"undefined"!=typeof Symbol&&Symbol.toStringTag&&Object.defineProperty(e,Symbol.toStringTag,{value:"Module"}),Object.defineProperty(e,"__esModule",{value:!0})};var __webpack_exports__={};__webpack_require__.r(__webpack_exports__),__webpack_require__.d(__webpack_exports__,{PressInteractionEncoder:()=>PressInteractionEncoder,ReferralInteractionEncoder:()=>ReferralInteractionEncoder,RetailInteractionEncoder:()=>RetailInteractionEncoder,PurchaseInteractionEncoder:()=>PurchaseInteractionEncoder,WebShopInteractionEncoder:()=>WebShopInteractionEncoder});let external_viem_namespaceObject=require("viem"),interactionTypes={press:{openArticle:"0xc0a24ffb",readArticle:"0xd5bd0fbe"},dapp:{proofVerifiableStorageUpdate:"0x2ab2aeef",callableVerifiableStorageUpdate:"0xa07da986"},webshop:{open:"0xb311798f"},referral:{referred:"0x010cc3b9",createLink:"0xb2c0f17c"},purchase:{started:"0xd87e90c3",completed:"0x8403aeb4",unsafeCompleted:"0x4d5b14e0"},retail:{customerMeeting:"0x74489004"}},productTypes={dapp:1,press:2,webshop:3,retail:4,referral:30,purchase:31},productTypesMask=Object.entries(productTypes).reduce((e,[r,t])=>(e[r]=BigInt(1)<<BigInt(t),e),{}),PressInteractionEncoder={openArticle({articleId:e}){let r=(0,external_viem_namespaceObject.concatHex)([interactionTypes.press.openArticle,(0,external_viem_namespaceObject.pad)(e,{size:32})]);return{handlerTypeDenominator:(0,external_viem_namespaceObject.toHex)(productTypes.press),interactionData:r}},readArticle({articleId:e}){let r=(0,external_viem_namespaceObject.concatHex)([interactionTypes.press.readArticle,(0,external_viem_namespaceObject.pad)(e,{size:32})]);return{handlerTypeDenominator:(0,external_viem_namespaceObject.toHex)(productTypes.press),interactionData:r}}},ReferralInteractionEncoder={createLink:()=>({handlerTypeDenominator:(0,external_viem_namespaceObject.toHex)(productTypes.referral),interactionData:interactionTypes.referral.createLink}),referred({referrer:e}){let r=(0,external_viem_namespaceObject.concatHex)([interactionTypes.referral.referred,(0,external_viem_namespaceObject.pad)(e,{size:32})]);return{handlerTypeDenominator:(0,external_viem_namespaceObject.toHex)(productTypes.referral),interactionData:r}}},PurchaseInteractionEncoder={startPurchase({purchaseId:e}){let r=(0,external_viem_namespaceObject.concatHex)([interactionTypes.purchase.started,(0,external_viem_namespaceObject.pad)(e,{size:32})]);return{handlerTypeDenominator:(0,external_viem_namespaceObject.toHex)(productTypes.purchase),interactionData:r}},completedPurchase({purchaseId:e,proof:r}){let t=(0,external_viem_namespaceObject.encodeAbiParameters)([{type:"uint256"},{type:"bytes32[]"}],[BigInt(e),r]),a=(0,external_viem_namespaceObject.concatHex)([interactionTypes.purchase.completed,t]);return{handlerTypeDenominator:(0,external_viem_namespaceObject.toHex)(productTypes.purchase),interactionData:a}},unsafeCompletedPurchase({purchaseId:e}){let r=(0,external_viem_namespaceObject.concatHex)([interactionTypes.purchase.unsafeCompleted,(0,external_viem_namespaceObject.pad)(e,{size:32})]);return{handlerTypeDenominator:(0,external_viem_namespaceObject.toHex)(productTypes.purchase),interactionData:r}}},WebShopInteractionEncoder={open:()=>({handlerTypeDenominator:(0,external_viem_namespaceObject.toHex)(productTypes.webshop),interactionData:interactionTypes.webshop.open})},RetailInteractionEncoder={customerMeeting({agencyId:e}){let r=(0,external_viem_namespaceObject.concatHex)([interactionTypes.retail.customerMeeting,(0,external_viem_namespaceObject.pad)(e,{size:32})]);return{handlerTypeDenominator:(0,external_viem_namespaceObject.toHex)(productTypes.retail),interactionData:r}}};for(var __webpack_i__ in exports.PressInteractionEncoder=__webpack_exports__.PressInteractionEncoder,exports.PurchaseInteractionEncoder=__webpack_exports__.PurchaseInteractionEncoder,exports.ReferralInteractionEncoder=__webpack_exports__.ReferralInteractionEncoder,exports.RetailInteractionEncoder=__webpack_exports__.RetailInteractionEncoder,exports.WebShopInteractionEncoder=__webpack_exports__.WebShopInteractionEncoder,__webpack_exports__)-1===["PressInteractionEncoder","PurchaseInteractionEncoder","ReferralInteractionEncoder","RetailInteractionEncoder","WebShopInteractionEncoder"].indexOf(__webpack_i__)&&(exports[__webpack_i__]=__webpack_exports__[__webpack_i__]);Object.defineProperty(exports,"__esModule",{value:!0});