@frak-labs/core-sdk 0.2.1-beta.d2556d47 → 0.2.1-beta.eb3cff34

package/src/types/rpc.ts

@@ -4,6 +4,10 @@ import type {
     ModalRpcStepsInput,
     ModalRpcStepsResultType,
 } from "./rpc/displayModal";
+import type {
+    DisplaySharingPageParamsType,
+    DisplaySharingPageResultType,
+} from "./rpc/displaySharingPage";
 import type {
     DisplayEmbeddedWalletParamsType,
     DisplayEmbeddedWalletResultType,
@@ -16,6 +20,7 @@ import type {
     PrepareSsoParamsType,
     PrepareSsoReturnType,
 } from "./rpc/sso";
+import type { UserReferralStatusType } from "./rpc/userReferralStatus";
 import type { WalletStatusReturnType } from "./rpc/walletStatus";
 
 /**
@@ -56,6 +61,11 @@ import type { WalletStatusReturnType } from "./rpc/walletStatus";
  * - Params: [request: {@link DisplayEmbeddedWalletParamsType}, metadata: {@link FrakWalletSdkConfig}["metadata"], placement?: string]
  * - Returns: {@link DisplayEmbeddedWalletResultType}
  * - Response Type: promise (one-shot)
+ *
+ * #### frak_displaySharingPage
+ * - Params: [request: {@link DisplaySharingPageParamsType}, configMetadata: {@link FrakWalletSdkConfig}["metadata"], placement?: string]
+ * - Returns: {@link DisplaySharingPageResultType}
+ * - Response Type: promise (one-shot)
  */
 export type IFrameRpcSchema = [
     /**
@@ -149,4 +159,41 @@ export type IFrameRpcSchema = [
         ];
         ReturnType: undefined;
     },
+    /**
+     * Method to get the current user's referral status on this merchant.
+     * Returns whether the user was referred (has a referral link as referee).
+     * Returns null when the user's identity cannot be resolved.
+     * This is a one-shot request.
+     */
+    {
+        Method: "frak_getUserReferralStatus";
+        Parameters?: undefined;
+        ReturnType: UserReferralStatusType | null;
+    },
+    /**
+     * Method to display a sharing page with product info and sharing buttons
+     * Resolves on first user action (share/copy) but the page stays visible
+     * This is a one-shot request
+     */
+    {
+        Method: "frak_displaySharingPage";
+        Parameters: [
+            request: DisplaySharingPageParamsType,
+            configMetadata: FrakWalletSdkConfig["metadata"],
+            placement?: string,
+        ];
+        ReturnType: DisplaySharingPageResultType;
+    },
+    /**
+     * Method to get a merge token for the current anonymous identity.
+     * Used by in-app browser redirect flows to preserve identity
+     * when switching from a WebView to the system browser.
+     * Returns the merge token string, or null if unavailable.
+     * This is a one-shot request.
+     */
+    {
+        Method: "frak_getMergeToken";
+        Parameters?: undefined;
+        ReturnType: string | null;
+    },
 ];

package/src/utils/cache/index.ts

@@ -0,0 +1,7 @@
+export { LruMap } from "./lruMap";
+export {
+    clearAllCache,
+    DEFAULT_CACHE_TIME,
+    getCache,
+    withCache,
+} from "./withCache";

package/src/utils/cache/lruMap.test.ts

@@ -0,0 +1,55 @@
+import { describe, expect, it } from "../../../tests/vitest-fixtures";
+import { LruMap } from "./lruMap";
+
+describe("LruMap", () => {
+    it("should store and retrieve values", () => {
+        const map = new LruMap<number>(3);
+        map.set("a", 1);
+        map.set("b", 2);
+
+        expect(map.get("a")).toBe(1);
+        expect(map.get("b")).toBe(2);
+    });
+
+    it("should evict least recently used when exceeding max size", () => {
+        const map = new LruMap<number>(2);
+        map.set("a", 1);
+        map.set("b", 2);
+        map.set("c", 3); // Should evict "a"
+
+        expect(map.get("a")).toBeUndefined();
+        expect(map.get("b")).toBe(2);
+        expect(map.get("c")).toBe(3);
+    });
+
+    it("should promote accessed keys to most recently used", () => {
+        const map = new LruMap<number>(2);
+        map.set("a", 1);
+        map.set("b", 2);
+
+        // Access "a" to promote it
+        map.get("a");
+
+        // "b" is now least recently used, should be evicted
+        map.set("c", 3);
+
+        expect(map.get("a")).toBe(1);
+        expect(map.get("b")).toBeUndefined();
+        expect(map.get("c")).toBe(3);
+    });
+
+    it("should overwrite existing keys without increasing size", () => {
+        const map = new LruMap<number>(2);
+        map.set("a", 1);
+        map.set("b", 2);
+        map.set("a", 10); // Overwrite, not a new entry
+
+        expect(map.size).toBe(2);
+        expect(map.get("a")).toBe(10);
+    });
+
+    it("should return undefined for missing keys", () => {
+        const map = new LruMap<number>(2);
+        expect(map.get("missing")).toBeUndefined();
+    });
+});

package/src/utils/cache/lruMap.ts

@@ -0,0 +1,38 @@
+/**
+ * Map with a LRU (Least Recently Used) eviction policy.
+ *
+ * When the map exceeds `maxSize`, the least recently accessed entry is removed.
+ * Accessing a key via `get()` promotes it to "most recently used".
+ *
+ * Adapted from viem's LruMap utility.
+ * @link https://en.wikipedia.org/wiki/Cache_replacement_policies#LRU
+ */
+export class LruMap<TValue = unknown> extends Map<string, TValue> {
+    maxSize: number;
+
+    constructor(size: number) {
+        super();
+        this.maxSize = size;
+    }
+
+    override get(key: string) {
+        const value = super.get(key);
+        if (super.has(key)) {
+            // Move to end (most recently used)
+            super.delete(key);
+            super.set(key, value as TValue);
+        }
+        return value;
+    }
+
+    override set(key: string, value: TValue) {
+        if (super.has(key)) super.delete(key);
+        super.set(key, value);
+        // Evict least recently used if over capacity
+        if (this.maxSize && this.size > this.maxSize) {
+            const firstKey = super.keys().next().value;
+            if (firstKey !== undefined) super.delete(firstKey);
+        }
+        return this;
+    }
+}

package/src/utils/cache/withCache.test.ts

@@ -0,0 +1,168 @@
+import {
+    afterEach,
+    beforeEach,
+    describe,
+    expect,
+    it,
+    vi,
+} from "../../../tests/vitest-fixtures";
+import { clearAllCache, withCache } from "./withCache";
+
+describe("withCache", () => {
+    beforeEach(() => {
+        clearAllCache();
+    });
+
+    afterEach(() => {
+        vi.restoreAllMocks();
+    });
+
+    describe("caching behavior", () => {
+        it("should call fn on first invocation", async () => {
+            const fn = vi.fn().mockResolvedValue("result");
+
+            const result = await withCache(fn, {
+                cacheKey: "test-key",
+            });
+
+            expect(fn).toHaveBeenCalledOnce();
+            expect(result).toBe("result");
+        });
+
+        it("should return cached result on subsequent calls within TTL", async () => {
+            const fn = vi.fn().mockResolvedValue("result");
+
+            await withCache(fn, {
+                cacheKey: "test-key",
+                cacheTime: 10_000,
+            });
+            const result = await withCache(fn, {
+                cacheKey: "test-key",
+                cacheTime: 10_000,
+            });
+
+            expect(fn).toHaveBeenCalledOnce();
+            expect(result).toBe("result");
+        });
+
+        it("should re-fetch after cache expires", async () => {
+            vi.useFakeTimers();
+
+            const fn = vi
+                .fn()
+                .mockResolvedValueOnce("first")
+                .mockResolvedValueOnce("second");
+
+            const first = await withCache(fn, {
+                cacheKey: "test-key",
+                cacheTime: 100,
+            });
+            expect(first).toBe("first");
+
+            // Advance past TTL
+            vi.advanceTimersByTime(200);
+
+            const second = await withCache(fn, {
+                cacheKey: "test-key",
+                cacheTime: 100,
+            });
+            expect(second).toBe("second");
+            expect(fn).toHaveBeenCalledTimes(2);
+
+            vi.useRealTimers();
+        });
+
+        it("should not cache when cacheTime is 0", async () => {
+            const fn = vi.fn().mockResolvedValue("result");
+
+            await withCache(fn, { cacheKey: "test-key", cacheTime: 0 });
+            await withCache(fn, { cacheKey: "test-key", cacheTime: 0 });
+
+            expect(fn).toHaveBeenCalledTimes(2);
+        });
+
+        it("should use different caches for different keys", async () => {
+            const fnA = vi.fn().mockResolvedValue("a");
+            const fnB = vi.fn().mockResolvedValue("b");
+
+            const a = await withCache(fnA, { cacheKey: "key-a" });
+            const b = await withCache(fnB, { cacheKey: "key-b" });
+
+            expect(a).toBe("a");
+            expect(b).toBe("b");
+            expect(fnA).toHaveBeenCalledOnce();
+            expect(fnB).toHaveBeenCalledOnce();
+        });
+    });
+
+    describe("deduplication", () => {
+        it("should deduplicate concurrent calls with the same key", async () => {
+            let resolvePromise: (value: string) => void;
+            const fn = vi.fn().mockImplementation(
+                () =>
+                    new Promise<string>((resolve) => {
+                        resolvePromise = resolve;
+                    })
+            );
+
+            const promise1 = withCache(fn, { cacheKey: "dedup-key" });
+            const promise2 = withCache(fn, { cacheKey: "dedup-key" });
+
+            // fn should only be called once
+            expect(fn).toHaveBeenCalledOnce();
+
+            // Both should resolve to the same value
+            resolvePromise!("shared");
+            const [result1, result2] = await Promise.all([promise1, promise2]);
+            expect(result1).toBe("shared");
+            expect(result2).toBe("shared");
+        });
+    });
+
+    describe("error handling", () => {
+        it("should propagate errors from fn", async () => {
+            const fn = vi.fn().mockRejectedValue(new Error("fetch failed"));
+
+            await expect(
+                withCache(fn, { cacheKey: "error-key" })
+            ).rejects.toThrow("fetch failed");
+        });
+
+        it("should not cache errors — subsequent call retries", async () => {
+            vi.useFakeTimers();
+            const fn = vi
+                .fn()
+                .mockRejectedValueOnce(new Error("fail"))
+                .mockResolvedValueOnce("recovered");
+
+            await expect(
+                withCache(fn, { cacheKey: "retry-key" })
+            ).rejects.toThrow("fail");
+
+            // Advance past the negative cache backoff (1s)
+            vi.advanceTimersByTime(1_001);
+
+            const result = await withCache(fn, { cacheKey: "retry-key" });
+            expect(result).toBe("recovered");
+            expect(fn).toHaveBeenCalledTimes(2);
+
+            vi.useRealTimers();
+        });
+    });
+
+    describe("clearAllCache", () => {
+        it("should clear all cached data", async () => {
+            const fn = vi
+                .fn()
+                .mockResolvedValueOnce("first")
+                .mockResolvedValueOnce("second");
+
+            await withCache(fn, { cacheKey: "clear-key" });
+            clearAllCache();
+            const result = await withCache(fn, { cacheKey: "clear-key" });
+
+            expect(result).toBe("second");
+            expect(fn).toHaveBeenCalledTimes(2);
+        });
+    });
+});

package/src/utils/cache/withCache.ts

@@ -0,0 +1,124 @@
+import { LruMap } from "./lruMap";
+
+type CacheEntry<TData> = {
+    data: TData;
+    created: number;
+};
+
+/** Global cache for in-flight promises (dedup concurrent calls) */
+const promiseCache = new LruMap<Promise<unknown>>(1024);
+
+/** Global cache for resolved responses (TTL-based) */
+const responseCache = new LruMap<CacheEntry<unknown>>(1024);
+
+/** Default cache time: 30 seconds */
+export const DEFAULT_CACHE_TIME = 30_000;
+
+/** Short negative cache to avoid flooding on transient failures */
+const NEGATIVE_CACHE_TIME = 1_000;
+
+/** Tracks recently failed keys to avoid request floods */
+const failureCache = new LruMap<number>(1024);
+
+type WithCacheOptions = {
+    /** The key to cache the data against */
+    cacheKey: string;
+    /** Time in ms that cached data will remain valid. Default: 30_000 (30s). Set to 0 to disable caching. */
+    cacheTime?: number;
+};
+
+/**
+ * Returns the result of a given promise, and caches the result for
+ * subsequent invocations against a provided cache key.
+ *
+ * Also deduplicates concurrent calls — if multiple callers request the same
+ * cache key while the promise is pending, they share the same promise.
+ *
+ * @example
+ * ```ts
+ * // First call fetches, subsequent calls return cached data for 30s
+ * const data = await withCache(
+ *     () => client.request({ method: "frak_getMerchantInformation" }),
+ *     { cacheKey: "merchantInfo", cacheTime: 30_000 }
+ * );
+ * ```
+ */
+export async function withCache<TData>(
+    fn: () => Promise<TData>,
+    { cacheKey, cacheTime = DEFAULT_CACHE_TIME }: WithCacheOptions
+): Promise<TData> {
+    // Check response cache — return immediately if fresh
+    if (cacheTime > 0) {
+        const cached = responseCache.get(cacheKey) as
+            | CacheEntry<TData>
+            | undefined;
+        if (cached) {
+            const age = Date.now() - cached.created;
+            if (age < cacheTime) return cached.data;
+        }
+    }
+
+    // Check if this key recently failed — back off briefly
+    const lastFailure = failureCache.get(cacheKey);
+    if (lastFailure && Date.now() - lastFailure < NEGATIVE_CACHE_TIME) {
+        throw new Error(`Cache: ${cacheKey} recently failed, backing off`);
+    }
+
+    // Check if there's already a pending promise (dedup concurrent calls)
+    let promise = promiseCache.get(cacheKey) as Promise<TData> | undefined;
+    if (!promise) {
+        promise = fn();
+        promiseCache.set(cacheKey, promise);
+    }
+
+    try {
+        const data = await promise;
+        // Store the response with a timestamp
+        responseCache.set(cacheKey, { data, created: Date.now() });
+        // Clear any previous failure
+        failureCache.delete(cacheKey);
+        return data;
+    } catch (error) {
+        // Record the failure timestamp
+        failureCache.set(cacheKey, Date.now());
+        throw error;
+    } finally {
+        // Clear the promise cache so subsequent calls can re-fetch after TTL
+        promiseCache.delete(cacheKey);
+    }
+}
+
+/**
+ * Get a cache handle for a specific key, useful for manual invalidation.
+ *
+ * @example
+ * ```ts
+ * // Invalidate merchant info cache after a mutation
+ * getCache("frak_getMerchantInformation").clear();
+ * ```
+ */
+export function getCache(cacheKey: string) {
+    return {
+        /** Clear both the pending promise and the cached response */
+        clear: () => {
+            promiseCache.delete(cacheKey);
+            responseCache.delete(cacheKey);
+        },
+        /** Check if a non-expired response exists */
+        has: (cacheTime: number = DEFAULT_CACHE_TIME) => {
+            const cached = responseCache.get(cacheKey);
+            if (!cached) return false;
+            return Date.now() - cached.created < cacheTime;
+        },
+    };
+}
+
+/**
+ * Clear all cached data (both pending promises and resolved responses).
+ * Called automatically when the client is destroyed.
+ */
+export function clearAllCache() {
+    promiseCache.clear();
+    responseCache.clear();
+    failureCache.clear();
+}

package/src/utils/inAppBrowser.ts

@@ -0,0 +1,60 @@
+/**
+ * Check if the current device runs iOS (including iPadOS 13+).
+ */
+function checkIsIOS(): boolean {
+    if (typeof navigator === "undefined") return false;
+    const ua = navigator.userAgent;
+    // Standard iOS devices
+    if (/iPhone|iPad|iPod/i.test(ua)) return true;
+    // iPadOS 13+ reports as Macintosh — detect via touch support
+    if (/Macintosh/i.test(ua) && navigator.maxTouchPoints > 1) return true;
+    return false;
+}
+
+/**
+ * Whether the current device runs iOS (including iPadOS 13+).
+ */
+export const isIOS: boolean = checkIsIOS();
+
+/**
+ * Check if the current browser is a social media in-app browser
+ * (Instagram, Facebook WebView).
+ */
+function checkInAppBrowser(): boolean {
+    if (typeof navigator === "undefined") return false;
+    const ua = navigator.userAgent.toLowerCase();
+    return (
+        ua.includes("instagram") ||
+        ua.includes("fban") ||
+        ua.includes("fbav") ||
+        ua.includes("facebook")
+    );
+}
+
+/**
+ * Whether the current browser is a social media in-app browser
+ * (Instagram, Facebook).
+ */
+export const isInAppBrowser: boolean = checkInAppBrowser();
+
+/**
+ * Redirect to external browser from in-app WebView.
+ *
+ * - **iOS**: Uses `x-safari-https://` scheme — server-side 302 redirects
+ *   to custom URL schemes are silently swallowed by WKWebView.
+ *   Direct `window.location.href` assignment works (confirmed iOS 17+).
+ *
+ * - **Android**: Uses backend `/common/social` endpoint which returns a PDF
+ *   Content-Type response, forcing the WebView to hand off to the default browser.
+ *
+ * @param targetUrl - The URL to open in the external browser
+ */
+export function redirectToExternalBrowser(targetUrl: string): void {
+    if (isIOS && targetUrl.startsWith("https://")) {
+        window.location.href = `x-safari-https://${targetUrl.slice(8)}`;
+    } else if (isIOS && targetUrl.startsWith("http://")) {
+        window.location.href = `x-safari-http://${targetUrl.slice(7)}`;
+    } else {
+        window.location.href = `${process.env.BACKEND_URL}/common/social?u=${encodeURIComponent(targetUrl)}`;
+    }
+}

package/src/utils/index.ts

@@ -1,5 +1,6 @@
 export { Deferred } from "@frak-labs/frame-connector";
 export { getBackendUrl } from "./backendUrl";
+export { clearAllCache, getCache, withCache } from "./cache";
 export { getClientId } from "./clientId";
 export { base64urlDecode, base64urlEncode } from "./compression/b64";
 export { compressJsonToB64 } from "./compression/compress";
@@ -22,6 +23,11 @@ export {
     createIframe,
     findIframeInOpener,
 } from "./iframeHelper";
+export {
+    isInAppBrowser,
+    isIOS,
+    redirectToExternalBrowser,
+} from "./inAppBrowser";
 export { sdkConfigStore } from "./sdkConfigStore";
 export {
     type AppSpecificSsoMetadata,

package/src/utils/sdkConfigStore.ts

@@ -5,8 +5,8 @@
  * Reactivity is handled via the `frak:config` CustomEvent on `window`.
  * Resolved configs are cached in localStorage (30 s TTL, stale-while-revalidate).
  *
- * Also owns merchant config fetching (resolve), promise deduplication,
- * and the `frak-merchant-id` sessionStorage compatibility key.
+ * Backend fetch responses are cached and deduplicated via `withCache`.
+ * Also owns the `frak-merchant-id` sessionStorage compatibility key.
  */
 
 import type { Language } from "../types/config";
@@ -15,6 +15,7 @@ import type {
     SdkResolvedConfig,
 } from "../types/resolvedConfig";
 import { getBackendUrl } from "./backendUrl";
+import { clearAllCache, withCache } from "./cache";
 
 const GLOBAL_KEY = "__frakSdkConfig";
 const CACHE_TTL = 30_000; // 30 seconds
@@ -118,19 +119,9 @@ function getTargetDomain(domain?: string): string {
 }
 
 // ---------------------------------------------------------------------------
-// Merchant config fetching (resolve) + dedup
+// Merchant config fetching (resolve)
 // ---------------------------------------------------------------------------
 
-const responseCache = new Map<string, MerchantConfigResponse>();
-const promiseCache = new Map<
-    string,
-    Promise<MerchantConfigResponse | undefined>
->();
-
-function resolveCacheKey(domain: string, lang?: string): string {
-    return `${domain}:${lang ?? ""}`;
-}
-
 async function fetchFromBackend(
     targetDomain: string,
     walletUrl?: string,
@@ -151,8 +142,6 @@ async function fetchFromBackend(
         }
 
         const data = (await response.json()) as MerchantConfigResponse;
-        const key = resolveCacheKey(targetDomain, lang);
-        responseCache.set(key, data);
 
         // Write compatibility sessionStorage key
         if (isBrowser) {
@@ -210,8 +199,7 @@ export const sdkConfigStore = {
 
     clearCache(): void {
         removeCache();
-        responseCache.clear();
-        promiseCache.clear();
+        clearAllCache();
         if (isBrowser) {
             try {
                 sessionStorage.removeItem(MERCHANT_ID_KEY);
@@ -229,25 +217,23 @@ export const sdkConfigStore = {
             return Promise.resolve(undefined);
         }
 
-        const key = resolveCacheKey(targetDomain, lang);
-
-        if (responseCache.has(key)) {
-            return Promise.resolve(responseCache.get(key));
-        }
-
-        const pending = promiseCache.get(key);
-        if (pending) {
-            return pending;
-        }
-
-        const promise = fetchFromBackend(targetDomain, walletUrl, lang).then(
-            (result) => {
-                promiseCache.delete(key);
+        const cacheKey = `sdkConfig:${targetDomain}:${lang ?? ""}`;
+
+        return withCache(
+            async () => {
+                const result = await fetchFromBackend(
+                    targetDomain,
+                    walletUrl,
+                    lang
+                );
+                // Throw on failure so withCache doesn't cache undefined
+                if (!result) {
+                    throw new Error("Config resolution returned empty");
+                }
                 return result;
-            }
-        );
-        promiseCache.set(key, promise);
-        return promise;
+            },
+            { cacheKey, cacheTime: Number.POSITIVE_INFINITY }
+        ).catch(() => undefined);
     },
 
     getMerchantId(): string | undefined {

package/dist/setupClient-Dr_UYfTD.cjs

@@ -1,13 +0,0 @@
-const e=require(`./trackEvent-B2uom25e.cjs`);let t=require(`@frak-labs/frame-connector`),n=require(`@openpanel/web`);const r=`nexus-wallet-backup`,i=`frakwallet://`;function a(){let e=navigator.userAgent;return/Android/i.test(e)&&/Chrome\/\d+/i.test(e)}function o(e){return`intent://${e.slice(13)}#Intent;scheme=frakwallet;end`}function s(e,t){let n=t?.timeout??2500,r=!1,i=()=>{document.hidden&&(r=!0)};document.addEventListener(`visibilitychange`,i);let s=a()&&c(e)?o(e):e;window.location.href=s,setTimeout(()=>{document.removeEventListener(`visibilitychange`,i),r||t?.onFallback?.()},n)}function c(e){return e.startsWith(i)}const l={eur:`fr-FR`,usd:`en-US`,gbp:`en-GB`};function u(e){return e&&e in l?e:`eur`}function d(e){return e?l[e]??l.eur:l.eur}function f(e,t){let n=d(t),r=u(t);return e.toLocaleString(n,{style:`currency`,currency:r,minimumFractionDigits:0,maximumFractionDigits:2})}function p(e){return e?`${e}Amount`:`eurAmount`}const m={id:`frak-wallet`,name:`frak-wallet`,title:`Frak Wallet`,allow:`publickey-credentials-get *; clipboard-write; web-share *`,style:{width:`0`,height:`0`,border:`0`,position:`absolute`,zIndex:2000001,top:`-1000px`,left:`-1000px`,colorScheme:`auto`}};function h({walletBaseUrl:t,config:n}){let r=document.querySelector(`#frak-wallet`);r&&r.remove();let i=document.createElement(`iframe`);i.id=m.id,i.name=m.name,i.allow=m.allow,i.style.zIndex=m.style.zIndex.toString(),g({iframe:i,isVisible:!1});let a=n?.walletUrl??t??`https://wallet.frak.id`,o=e.g();return i.src=`${a}/listener?clientId=${encodeURIComponent(o)}`,new Promise(e=>{i.addEventListener(`load`,()=>e(i)),document.body.appendChild(i)})}function g({iframe:e,isVisible:t}){if(!t){e.style.width=`0`,e.style.height=`0`,e.style.border=`0`,e.style.position=`fixed`,e.style.top=`-1000px`,e.style.left=`-1000px`;return}e.style.position=`fixed`,e.style.top=`0`,e.style.left=`0`,e.style.width=`100%`,e.style.height=`100%`,e.style.pointerEvents=`auto`}function _(e=`/listener`){if(!window.opener)return null;let t=t=>{try{return t.location.origin===window.location.origin&&t.location.pathname===e}catch{return!1}};if(t(window.opener))return window.opener;try{let e=window.opener.frames;for(let n=0;n<e.length;n++)if(t(e[n]))return e[n];return null}catch(t){return console.error(`[findIframeInOpener] Error finding iframe with pathname ${e}:`,t),null}}function v(e,t){if(typeof window>`u`)return;let n=new URL(window.location.href),r=n.searchParams.get(`sso`);r&&(t.then(()=>{e.sendLifecycle({clientLifecycle:`sso-redirect-complete`,data:{compressed:r}}),console.log(`[SSO URL Listener] Forwarded compressed SSO data to iframe`)}).catch(e=>{console.error(`[SSO URL Listener] Failed to forward SSO data:`,e)}),n.searchParams.delete(`sso`),window.history.replaceState({},``,n.toString()),console.log(`[SSO URL Listener] SSO parameter detected and URL cleaned`))}var y=class e{config;iframe;isSetupDone=!1;lastResponse=null;lastRequest=null;constructor(e,t){this.config=e,this.iframe=t,this.lastRequest=null,this.lastResponse=null}setLastResponse(e,t){this.lastResponse={message:e,response:t,timestamp:Date.now()}}setLastRequest(e){this.lastRequest={event:e,timestamp:Date.now()}}updateSetupStatus(e){this.isSetupDone=e}base64Encode(e){try{return btoa(JSON.stringify(e))}catch(e){return console.warn(`Failed to encode debug data`,e),btoa(`Failed to encode data`)}}getIframeStatus(){return this.iframe?{loading:this.iframe.hasAttribute(`loading`),url:this.iframe.src,readyState:this.iframe.contentDocument?.readyState?this.iframe.contentDocument.readyState===`complete`?1:0:-1,contentWindow:!!this.iframe.contentWindow,isConnected:this.iframe.isConnected}:null}getNavigatorInfo(){return navigator?{userAgent:navigator.userAgent,language:navigator.language,onLine:navigator.onLine,screenWidth:window.screen.width,screenHeight:window.screen.height,pixelRatio:window.devicePixelRatio}:null}gatherDebugInfo(e){let n=this.getIframeStatus(),r=this.getNavigatorInfo(),i=`Unknown`;return e instanceof t.FrakRpcError?i=`FrakRpcError: ${e.code} '${e.message}'`:e instanceof Error?i=e.message:typeof e==`string`&&(i=e),{timestamp:new Date().toISOString(),encodedUrl:btoa(window.location.href),encodedConfig:this.config?this.base64Encode(this.config):`no-config`,navigatorInfo:r?this.base64Encode(r):`no-navigator`,iframeStatus:n?this.base64Encode(n):`not-iframe`,lastRequest:this.lastRequest?this.base64Encode(this.lastRequest):`No Frak request logged`,lastResponse:this.lastResponse?this.base64Encode(this.lastResponse):`No Frak response logged`,clientStatus:this.isSetupDone?`setup`:`not-setup`,error:i}}static empty(){return new e}formatDebugInfo(e){let t=this.gatherDebugInfo(e);return`
-  Debug Information:
-  -----------------
-  Timestamp: ${t.timestamp}
-  URL: ${t.encodedUrl}
-  Config: ${t.encodedConfig}
-  Navigator Info: ${t.navigatorInfo}
-  IFrame Status: ${t.iframeStatus}
-  Last Request: ${t.lastRequest}
-  Last Response: ${t.lastResponse}
-  Client Status: ${t.clientStatus}
-  Error: ${t.error}
-  `.trim()}};const b=(()=>{if(typeof navigator>`u`)return!1;let e=navigator.userAgent;if(!(/iPhone|iPad|iPod/i.test(e)||/Macintosh/i.test(e)&&navigator.maxTouchPoints>1))return!1;let t=e.toLowerCase();return t.includes(`instagram`)||t.includes(`fban`)||t.includes(`fbav`)||t.includes(`facebook`)})();function x(e){e?localStorage.setItem(r,e):localStorage.removeItem(r)}function S(e,t){try{let n=new URL(e);return n.searchParams.has(`u`)?(n.searchParams.delete(`u`),n.searchParams.append(`u`,window.location.href),t&&n.searchParams.append(`fmt`,t),n.toString()):e}catch{return e}}function C(e){let t=new URL(window.location.href);e&&t.searchParams.set(`fmt`,e);let n=t.protocol===`http:`?`x-safari-http`:`x-safari-https`;window.location.href=`${n}://${t.host}${t.pathname}${t.search}${t.hash}`}function w(e){return e.includes(`/common/social`)}function T(e,t,n,r){if(c(t)){let i=S(t,r);s(i,{onFallback:()=>{e.contentWindow?.postMessage({clientLifecycle:`deep-link-failed`,data:{originalUrl:i}},n)}})}else if(b&&w(t))C(r);else{let e=S(t,r);window.location.href=e}}function E({iframe:e,targetOrigin:n}){let i=new t.Deferred;return{handleEvent:async t=>{if(!(`iframeLifecycle`in t))return;let{iframeLifecycle:a,data:o}=t;switch(a){case`connected`:i.resolve(!0);break;case`do-backup`:x(o.backup);break;case`remove-backup`:localStorage.removeItem(r);break;case`show`:case`hide`:g({iframe:e,isVisible:a===`show`});break;case`redirect`:T(e,o.baseRedirectUrl,n,o.mergeToken);break}},isConnected:i.promise}}function D({config:r,iframe:i}){let a=r?.walletUrl??`https://wallet.frak.id`,o=typeof navigator<`u`?navigator.language?.split(`-`)[0]:void 0,s=r.metadata.lang??(o===`en`||o===`fr`?o:void 0),c=r.domain??(typeof window<`u`?window.location.hostname:``);e.n.setCacheScope(c,s),e.n.reset();let l=e.n.isCacheFresh?void 0:e.n.resolve(r.domain,r.walletUrl,s),u=E({iframe:i,targetOrigin:a}),d=new t.Deferred,f=new y(r,i);if(!i.contentWindow)throw new t.FrakRpcError(t.RpcErrorCodes.configError,`The iframe does not have a content window`);let p=(0,t.createRpcClient)({emittingTransport:i.contentWindow,listeningTransport:window,targetOrigin:a,middleware:[{async onRequest(e,n){if(!await u.isConnected)throw new t.FrakRpcError(t.RpcErrorCodes.clientNotConnected,`The iframe provider isn't connected yet`);return await d.promise,n}},{onRequest(e,t){return f.setLastRequest(e),t},onResponse(e,t){return f.setLastResponse(e,t),t}}],lifecycleHandlers:{iframeLifecycle:async(e,t)=>{await u.handleEvent(e)}}}),m=O(p,u),h=async()=>{m(),p.cleanup(),i.remove(),e.n.clearCache(),e.n.reset()},g;console.log(`[Frak SDK] Initializing OpenPanel`),g=new n.OpenPanel({apiUrl:`https://op-api.gcp.frak.id`,clientId:`6eacc8d7-49ac-4936-95e9-81ef29449570`,trackScreenViews:!0,trackOutgoingLinks:!0,trackAttributes:!1,filter:({type:t,payload:n})=>(t!==`track`||!n?.properties||`sdkVersion`in n.properties||(n.properties={...n.properties,sdkVersion:`0.2.1`,userAnonymousClientId:e.g()}),!0)}),g.setGlobalProperties({sdkVersion:`0.2.1`,userAnonymousClientId:e.g()}),g.init();let _=k({config:r,rpcClient:p,lifecycleManager:u,configPromise:l,contextSent:d}).then(()=>f.updateSetupStatus(!0)).catch(e=>{throw d.reject(e),e});return{config:r,debugInfo:f,waitForConnection:u.isConnected,waitForSetup:_,request:p.request,listenerRequest:p.listen,destroy:h,openPanel:g}}function O(e,t){let n,r,i=()=>e.sendLifecycle({clientLifecycle:`heartbeat`});async function a(){i(),n=setInterval(i,1e3),r=setTimeout(()=>{o(),console.log(`Heartbeat timeout: connection failed`)},3e4),await t.isConnected,o()}function o(){n&&clearInterval(n),r&&clearTimeout(r)}return a(),o}async function k({config:t,rpcClient:n,lifecycleManager:i,configPromise:a,contextSent:o}){await i.isConnected,v(n,i.isConnected);let s=new URL(window.location.href),c=s.searchParams.get(`fmt`)??void 0;c&&(s.searchParams.delete(`fmt`),window.history.replaceState({},``,s.toString()));let l=n=>{let r=n?.merchantId??t.metadata.merchantId??``,i=n?.domain??``,a=n?.allowedDomains??[],o=n?.sdkConfig;e.n.setConfig(o?{isResolved:!0,merchantId:r,domain:i,allowedDomains:a,hasRawSdkConfig:!0,name:o.name??t.metadata.name,logoUrl:o.logoUrl??t.metadata.logoUrl,homepageLink:o.homepageLink??t.metadata.homepageLink,lang:o.lang??t.metadata.lang,currency:o.currency??t.metadata.currency,hidden:o.hidden,css:o.css,translations:o.translations,placements:o.placements}:{isResolved:!0,merchantId:r,domain:i,allowedDomains:a,name:t.metadata.name,logoUrl:t.metadata.logoUrl,homepageLink:t.metadata.homepageLink,lang:t.metadata.lang,currency:t.metadata.currency})},u=!1,d=e=>{let t=u?void 0:c;u=!0;let r=e.hasRawSdkConfig?{name:e.name,logoUrl:e.logoUrl,homepageLink:e.homepageLink,lang:e.lang,currency:e.currency,hidden:e.hidden,css:e.css,translations:e.translations,placements:e.placements}:void 0;n.sendLifecycle({clientLifecycle:`resolved-config`,data:{merchantId:e.merchantId,domain:e.domain??``,allowedDomains:e.allowedDomains??[],sourceUrl:window.location.href,...t&&{pendingMergeToken:t},...r&&{sdkConfig:r}}})};e.n.isResolved&&(d(e.n.getConfig()),o.resolve()),a&&(l(await a),d(e.n.getConfig()),o.resolve());async function f(){let e=t.customizations?.css;e&&n.sendLifecycle({clientLifecycle:`modal-css`,data:{cssLink:e}})}async function p(){let e=t.customizations?.i18n;e&&n.sendLifecycle({clientLifecycle:`modal-i18n`,data:{i18n:e}})}async function m(){if(typeof window>`u`)return;let e=window.localStorage.getItem(r);e&&n.sendLifecycle({clientLifecycle:`restore-backup`,data:{backup:e}})}await Promise.allSettled([f(),p(),m()])}async function A({config:e}){let t=j(e),n=await h({config:t});if(!n){console.error(`Failed to create iframe`);return}let r=D({config:t,iframe:n});if(await r.waitForSetup,!await r.waitForConnection){console.error(`Failed to connect to client`);return}return r}function j(e){let t=u(e.metadata?.currency);return{...e,metadata:{...e.metadata,currency:t}}}Object.defineProperty(exports,`a`,{enumerable:!0,get:function(){return h}}),Object.defineProperty(exports,`c`,{enumerable:!0,get:function(){return f}}),Object.defineProperty(exports,`d`,{enumerable:!0,get:function(){return l}}),Object.defineProperty(exports,`f`,{enumerable:!0,get:function(){return a}}),Object.defineProperty(exports,`g`,{enumerable:!0,get:function(){return i}}),Object.defineProperty(exports,`h`,{enumerable:!0,get:function(){return s}}),Object.defineProperty(exports,`i`,{enumerable:!0,get:function(){return m}}),Object.defineProperty(exports,`l`,{enumerable:!0,get:function(){return d}}),Object.defineProperty(exports,`m`,{enumerable:!0,get:function(){return o}}),Object.defineProperty(exports,`n`,{enumerable:!0,get:function(){return D}}),Object.defineProperty(exports,`o`,{enumerable:!0,get:function(){return _}}),Object.defineProperty(exports,`p`,{enumerable:!0,get:function(){return c}}),Object.defineProperty(exports,`r`,{enumerable:!0,get:function(){return y}}),Object.defineProperty(exports,`s`,{enumerable:!0,get:function(){return p}}),Object.defineProperty(exports,`t`,{enumerable:!0,get:function(){return A}}),Object.defineProperty(exports,`u`,{enumerable:!0,get:function(){return u}});