@imtbl/sdk 1.5.2 → 1.5.3-alpha

package/dist/checkout.js

@@ -1,4 +1,6 @@
 import globalAxios, { HttpStatusCode as HttpStatusCode$2 } from 'axios';
+import { memorise } from 'lru-memorise';
+import { getGlobalisedValue as getGlobalisedValue$3 } from 'global-const';
 import { ethers, ContractFactory, utils as utils$2, Contract as Contract$1, BigNumber as BigNumber$1, providers, constants as constants$1 } from 'ethers';
 import { Web3Provider, JsonRpcProvider } from '@ethersproject/providers';
 import detectEthereumProvider from '@metamask/detect-provider';
@@ -24,12 +26,6 @@ var Detail$1;
     Detail["DOMAIN"] = "domain";
     Detail["SDK_VERSION"] = "sdkVersion";
 })(Detail$1 || (Detail$1 = {}));
-var Store$1;
-(function (Store) {
-    Store["EVENTS"] = "events";
-    Store["RUNTIME"] = "runtime";
-})(Store$1 || (Store$1 = {}));
-const POLLING_FREQUENCY$1 = 5000;
 
 const IMTBL_API$1 = 'https://api.x.immutable.com';
 async function post$1(path, data) {
@@ -89,6 +85,11 @@ const setItem$1 = (key, payload) => {
     return false;
 };
 
+var Store$1;
+(function (Store) {
+    Store["EVENTS"] = "events";
+    Store["RUNTIME"] = "runtime";
+})(Store$1 || (Store$1 = {}));
 // In memory storage for events and other data
 let EVENT_STORE$1;
 let RUNTIME_DETAILS$1;
@@ -116,7 +117,7 @@ const getDetail$1 = (key) => {
 const getAllDetails$1 = () => RUNTIME_DETAILS$1;
 // Events
 const getEvents$1 = () => EVENT_STORE$1;
-const addEvent = (event) => {
+const addEvent$1 = (event) => {
     EVENT_STORE$1.push(event);
     setItem$1(Store$1.EVENTS, EVENT_STORE$1);
 };
@@ -138,9 +139,7 @@ const flattenProperties$1 = (properties) => {
 };
 
 // WARNING: DO NOT CHANGE THE STRING BELOW. IT GETS REPLACED AT BUILD TIME.
-const SDK_VERSION$1 = '1.5.2';
-let initialised$1 = false;
-const isInitialised$1 = () => initialised$1;
+const SDK_VERSION$1 = '1.5.3-alpha';
 const getReferrer$1 = () => {
     if (isNode$1()) {
         return '';
@@ -177,21 +176,28 @@ const getRuntimeDetails$1 = () => {
         screen: `${window.screen.width}x${window.screen.height}`,
     };
 };
+let initialised$1 = false;
+const isInitialised$1 = () => initialised$1;
 const initialise$2 = async () => {
-    const runtimeDetails = flattenProperties$1(getRuntimeDetails$1());
-    const existingRuntimeId = getDetail$1(Detail$1.RUNTIME_ID);
-    const body = {
-        version: 1,
-        data: {
-            runtimeDetails,
-            runtimeId: existingRuntimeId,
-        },
-    };
-    const response = await post$1('/v1/sdk/initialise', body);
-    // Get runtimeId and store it
-    const { runtimeId } = response;
-    storeDetail$1(Detail$1.RUNTIME_ID, runtimeId);
     initialised$1 = true;
+    try {
+        const runtimeDetails = flattenProperties$1(getRuntimeDetails$1());
+        const existingRuntimeId = getDetail$1(Detail$1.RUNTIME_ID);
+        const body = {
+            version: 1,
+            data: {
+                runtimeDetails,
+                runtimeId: existingRuntimeId,
+            },
+        };
+        const response = await post$1('/v1/sdk/initialise', body);
+        // Get runtimeId and store it
+        const { runtimeId } = response;
+        storeDetail$1(Detail$1.RUNTIME_ID, runtimeId);
+    }
+    catch (error) {
+        initialised$1 = false;
+    }
 };
 
 function errorBoundary$1(fn) {
@@ -223,16 +229,31 @@ function isTestEnvironment$1() {
     return process.env.JEST_WORKER_ID !== undefined;
 }
 
+const GLOBALISE_KEY$1 = 'imtbl__metrics';
+const MEMORISE_TIMEFRAME$1 = 1000;
+const MEMORISE_MAX$1 = 1000;
+const getGlobalisedValue$2 = (key, value) => getGlobalisedValue$3(GLOBALISE_KEY$1, key, value);
+const getGlobalisedCachedFunction$1 = (key, fn) => {
+    // Some applications (esp backend, or frontends using the split bundles) can sometimes
+    // initialise the same request multiple times. This will prevent multiple of the
+    // same event,value from being reported in a 1 second period.
+    const memorisedFn = memorise(fn, {
+        lruOptions: { ttl: MEMORISE_TIMEFRAME$1, max: MEMORISE_MAX$1 },
+    });
+    return getGlobalisedValue$3(GLOBALISE_KEY$1, key, memorisedFn);
+};
+
+const POLLING_FREQUENCY$1 = 5000;
 // Store the event in the event store
-const trackFn = (moduleName, eventName, properties) => {
+const trackFn$1 = (moduleName, eventName, properties) => {
     const event = {
         event: `${moduleName}.${eventName}`,
         time: new Date().toISOString(),
         ...(properties && { properties: flattenProperties$1(properties) }),
     };
-    addEvent(event);
+    addEvent$1(event);
 };
-const track = errorBoundary$1(trackFn);
+const track = errorBoundary$1(getGlobalisedCachedFunction$1('track', trackFn$1));
 // Sending events to the server
 const flushFn$1 = async () => {
     // Don't flush if not initialised
@@ -268,15 +289,31 @@ const flushPoll$1 = async () => {
     await flush$1();
     setTimeout(flushPoll$1, POLLING_FREQUENCY$1);
 };
+let flushingStarted$1 = false;
+const startFlushing$1 = () => {
+    if (flushingStarted$1) {
+        return;
+    }
+    flushingStarted$1 = true;
+    flushPoll$1();
+};
 // This will get initialised when module is imported.
 if (!isTestEnvironment$1()) {
-    errorBoundary$1(flushPoll$1)();
+    errorBoundary$1(getGlobalisedValue$2('startFlushing', startFlushing$1))();
 }
 
-const setEnvironmentFn = (env) => {
+const setEnvironmentFn$1 = (env) => {
     storeDetail$1(Detail$1.ENVIRONMENT, env);
 };
-const setEnvironment = errorBoundary$1(setEnvironmentFn);
+const setEnvironment = errorBoundary$1(getGlobalisedValue$2('setEnvironment', setEnvironmentFn$1));
+const setPassportClientIdFn$1 = (passportClientId) => {
+    storeDetail$1(Detail$1.PASSPORT_CLIENT_ID, passportClientId);
+};
+errorBoundary$1(getGlobalisedValue$2('setPassportClientId', setPassportClientIdFn$1));
+const setPublishableApiKeyFn$1 = (publishableApiKey) => {
+    storeDetail$1(Detail$1.PUBLISHABLE_API_KEY, publishableApiKey);
+};
+errorBoundary$1(getGlobalisedValue$2('setPublishableApiKey', setPublishableApiKeyFn$1));
 
 var Environment$1;
 (function (Environment) {
@@ -16965,6 +17002,356 @@ class TokenBridge {
     }
 }
 
+var lib$1 = {};
+
+var tinyLru = {};
+
+/**
+ * tiny-lru
+ *
+ * @copyright 2023 Jason Mulligan <jason.mulligan@avoidwork.com>
+ * @license BSD-3-Clause
+ * @version 11.2.5
+ */
+
+class LRU {
+	constructor (max = 0, ttl = 0, resetTtl = false) {
+		this.first = null;
+		this.items = Object.create(null);
+		this.last = null;
+		this.max = max;
+		this.resetTtl = resetTtl;
+		this.size = 0;
+		this.ttl = ttl;
+	}
+
+	clear () {
+		this.first = null;
+		this.items = Object.create(null);
+		this.last = null;
+		this.size = 0;
+
+		return this;
+	}
+
+	delete (key) {
+		if (this.has(key)) {
+			const item = this.items[key];
+
+			delete this.items[key];
+			this.size--;
+
+			if (item.prev !== null) {
+				item.prev.next = item.next;
+			}
+
+			if (item.next !== null) {
+				item.next.prev = item.prev;
+			}
+
+			if (this.first === item) {
+				this.first = item.next;
+			}
+
+			if (this.last === item) {
+				this.last = item.prev;
+			}
+		}
+
+		return this;
+	}
+
+	entries (keys = this.keys()) {
+		return keys.map(key => [key, this.get(key)]);
+	}
+
+	evict (bypass = false) {
+		if (bypass || this.size > 0) {
+			const item = this.first;
+
+			delete this.items[item.key];
+
+			if (--this.size === 0) {
+				this.first = null;
+				this.last = null;
+			} else {
+				this.first = item.next;
+				this.first.prev = null;
+			}
+		}
+
+		return this;
+	}
+
+	expiresAt (key) {
+		let result;
+
+		if (this.has(key)) {
+			result = this.items[key].expiry;
+		}
+
+		return result;
+	}
+
+	get (key) {
+		let result;
+
+		if (this.has(key)) {
+			const item = this.items[key];
+
+			if (this.ttl > 0 && item.expiry <= Date.now()) {
+				this.delete(key);
+			} else {
+				result = item.value;
+				this.set(key, result, true);
+			}
+		}
+
+		return result;
+	}
+
+	has (key) {
+		return key in this.items;
+	}
+
+	keys () {
+		const result = [];
+		let x = this.first;
+
+		while (x !== null) {
+			result.push(x.key);
+			x = x.next;
+		}
+
+		return result;
+	}
+
+	set (key, value, bypass = false, resetTtl = this.resetTtl) {
+		let item;
+
+		if (bypass || this.has(key)) {
+			item = this.items[key];
+			item.value = value;
+
+			if (bypass === false && resetTtl) {
+				item.expiry = this.ttl > 0 ? Date.now() + this.ttl : this.ttl;
+			}
+
+			if (this.last !== item) {
+				const last = this.last,
+					next = item.next,
+					prev = item.prev;
+
+				if (this.first === item) {
+					this.first = item.next;
+				}
+
+				item.next = null;
+				item.prev = this.last;
+				last.next = item;
+
+				if (prev !== null) {
+					prev.next = next;
+				}
+
+				if (next !== null) {
+					next.prev = prev;
+				}
+			}
+		} else {
+			if (this.max > 0 && this.size === this.max) {
+				this.evict(true);
+			}
+
+			item = this.items[key] = {
+				expiry: this.ttl > 0 ? Date.now() + this.ttl : this.ttl,
+				key: key,
+				prev: this.last,
+				next: null,
+				value
+			};
+
+			if (++this.size === 1) {
+				this.first = item;
+			} else {
+				this.last.next = item;
+			}
+		}
+
+		this.last = item;
+
+		return this;
+	}
+
+	values (keys = this.keys()) {
+		return keys.map(key => this.get(key));
+	}
+}
+
+function lru (max = 1000, ttl = 0, resetTtl = false) {
+	if (isNaN(max) || max < 0) {
+		throw new TypeError("Invalid max value");
+	}
+
+	if (isNaN(ttl) || ttl < 0) {
+		throw new TypeError("Invalid ttl value");
+	}
+
+	if (typeof resetTtl !== "boolean") {
+		throw new TypeError("Invalid resetTtl value");
+	}
+
+	return new LRU(max, ttl, resetTtl);
+}
+
+tinyLru.LRU = LRU;
+tinyLru.lru = lru;
+
+(function (exports) {
+	Object.defineProperty(exports, "__esModule", { value: true });
+	exports.memorise = void 0;
+	const tiny_lru_1 = tinyLru;
+	const defaultLRUOptions = {
+	    max: 1000,
+	};
+	/**
+	 * Returns a memorised version of the target function.
+	 * The cache key depends on the arguments passed to the function.
+	 *
+	 * Pass in options to customise the caching behaviour
+	 * @param cachedFn Function to cache
+	 * @param options Memorization and LRUCache Options
+	 */
+	const memorise = (cachedFn, options = {}) => {
+	    // Extract defaults
+	    const { cache, cacheKeyResolver = defaultGenCacheKey, onHit, lruOptions = {}, } = options;
+	    const cacheOptions = { ...defaultLRUOptions, ...lruOptions };
+	    const _cache = (cache ||
+	        (0, tiny_lru_1.lru)(cacheOptions.max, cacheOptions.ttl));
+	    // Cached fn
+	    const returnFn = (...args) => {
+	        const cacheKey = cacheKeyResolver(...args);
+	        const cachedValue = _cache.get(cacheKey);
+	        const keyCached = _cache.has(cacheKey);
+	        // Use cached key, even if value is void
+	        if (keyCached) {
+	            // If onHit handler is there, run it
+	            if (onHit) {
+	                onHit(cacheKey, cachedValue, _cache);
+	            }
+	            return cachedValue;
+	        }
+	        // No cache hit, run function and cache result
+	        const result = cachedFn.apply(this, args);
+	        _cache.set(cacheKey, result);
+	        return result;
+	    };
+	    // Expose the cache
+	    returnFn._cache = _cache;
+	    return returnFn;
+	};
+	exports.memorise = memorise;
+	// Default export
+	exports.default = exports.memorise;
+	/**
+	 * Generic args handler function.
+	 * @param args Argument array
+	 */
+	const defaultGenCacheKey = (...args) => {
+	    if (args.length === 0) {
+	        return "no-args";
+	    }
+	    return args
+	        .map((val) => {
+	        if (val === undefined) {
+	            return "undefined";
+	        }
+	        if (val === null) {
+	            return "null";
+	        }
+	        if (Array.isArray(val)) {
+	            return `[${defaultGenCacheKey(...val)}]`;
+	        }
+	        if (typeof val === "object") {
+	            return `{${defaultGenCacheKey(...sortedObjectEntries(val))}}`;
+	        }
+	        return JSON.stringify(val);
+	    })
+	        .join(",");
+	};
+	const sortedObjectEntries = (obj) => {
+	    return Object.entries(obj).sort((a, b) => {
+	        if (a[0] < b[0]) {
+	            return -1;
+	        }
+	        return 1;
+	    });
+	};
+	
+} (lib$1));
+
+var lib = {};
+
+Object.defineProperty(lib, "__esModule", { value: true });
+lib.clearGlobalNamespace = getGlobalisedValue_1 = lib.getGlobalisedValue = void 0;
+const GLOBALISE_KEY_PREFIX = "globalise__singleton__";
+const fallbackGlobal = {};
+const getGlobalObject = () => {
+    if (typeof window !== "undefined") {
+        return window;
+    }
+    if (typeof globalThis !== "undefined") {
+        return globalThis;
+    }
+    return fallbackGlobal;
+};
+const validateInputs = (namespace, key) => {
+    if (typeof namespace !== "string") {
+        throw "Invalid namespace key";
+    }
+    if (typeof key !== "string") {
+        throw "Invalid item key";
+    }
+};
+const createGlobalisedKey = (namespace) => {
+    return `${GLOBALISE_KEY_PREFIX}${namespace}`;
+};
+const getGlobalScopedObject = (namespace) => {
+    const globalObject = getGlobalObject();
+    const GLOBALISE_KEY = createGlobalisedKey(namespace);
+    // Initialise global object
+    if (!globalObject[GLOBALISE_KEY]) {
+        globalObject[GLOBALISE_KEY] = {};
+    }
+    return globalObject[GLOBALISE_KEY];
+};
+const getSingleton = (namespace, key) => {
+    const scopedObject = getGlobalScopedObject(namespace);
+    return scopedObject[key] || undefined;
+};
+const setSingleton = (namespace, key, value) => {
+    const scopedObject = getGlobalScopedObject(namespace);
+    scopedObject[key] = value;
+};
+const getGlobalisedValue$1 = (namespace, key, value) => {
+    validateInputs(namespace, key);
+    const existing = getSingleton(namespace, key);
+    if (existing !== undefined) {
+        return existing;
+    }
+    setSingleton(namespace, key, value);
+    return value;
+};
+var getGlobalisedValue_1 = lib.getGlobalisedValue = getGlobalisedValue$1;
+const clearGlobalNamespace = (namespace) => {
+    const globalObject = getGlobalObject();
+    const globalisedKey = createGlobalisedKey(namespace);
+    if (globalObject[globalisedKey] !== undefined) {
+        delete globalObject[globalisedKey];
+    }
+};
+lib.clearGlobalNamespace = clearGlobalNamespace;
+
 const isNode = () => typeof window === 'undefined';
 const isBrowser = () => !isNode();
 
@@ -16978,12 +17365,6 @@ var Detail;
     Detail["DOMAIN"] = "domain";
     Detail["SDK_VERSION"] = "sdkVersion";
 })(Detail || (Detail = {}));
-var Store;
-(function (Store) {
-    Store["EVENTS"] = "events";
-    Store["RUNTIME"] = "runtime";
-})(Store || (Store = {}));
-const POLLING_FREQUENCY = 5000;
 
 const IMTBL_API = 'https://api.x.immutable.com';
 async function post(path, data) {
@@ -17043,6 +17424,11 @@ const setItem = (key, payload) => {
     return false;
 };
 
+var Store;
+(function (Store) {
+    Store["EVENTS"] = "events";
+    Store["RUNTIME"] = "runtime";
+})(Store || (Store = {}));
 // In memory storage for events and other data
 let EVENT_STORE;
 let RUNTIME_DETAILS;
@@ -17070,6 +17456,10 @@ const getDetail = (key) => {
 const getAllDetails = () => RUNTIME_DETAILS;
 // Events
 const getEvents = () => EVENT_STORE;
+const addEvent = (event) => {
+    EVENT_STORE.push(event);
+    setItem(Store.EVENTS, EVENT_STORE);
+};
 const removeSentEvents = (numberOfEvents) => {
     EVENT_STORE = EVENT_STORE.slice(numberOfEvents);
     setItem(Store.EVENTS, EVENT_STORE);
@@ -17088,9 +17478,7 @@ const flattenProperties = (properties) => {
 };
 
 // WARNING: DO NOT CHANGE THE STRING BELOW. IT GETS REPLACED AT BUILD TIME.
-const SDK_VERSION = '1.5.2';
-let initialised = false;
-const isInitialised = () => initialised;
+const SDK_VERSION = '1.5.3-alpha';
 const getReferrer = () => {
     if (isNode()) {
         return '';
@@ -17127,21 +17515,28 @@ const getRuntimeDetails = () => {
         screen: `${window.screen.width}x${window.screen.height}`,
     };
 };
+let initialised = false;
+const isInitialised = () => initialised;
 const initialise = async () => {
-    const runtimeDetails = flattenProperties(getRuntimeDetails());
-    const existingRuntimeId = getDetail(Detail.RUNTIME_ID);
-    const body = {
-        version: 1,
-        data: {
-            runtimeDetails,
-            runtimeId: existingRuntimeId,
-        },
-    };
-    const response = await post('/v1/sdk/initialise', body);
-    // Get runtimeId and store it
-    const { runtimeId } = response;
-    storeDetail(Detail.RUNTIME_ID, runtimeId);
     initialised = true;
+    try {
+        const runtimeDetails = flattenProperties(getRuntimeDetails());
+        const existingRuntimeId = getDetail(Detail.RUNTIME_ID);
+        const body = {
+            version: 1,
+            data: {
+                runtimeDetails,
+                runtimeId: existingRuntimeId,
+            },
+        };
+        const response = await post('/v1/sdk/initialise', body);
+        // Get runtimeId and store it
+        const { runtimeId } = response;
+        storeDetail(Detail.RUNTIME_ID, runtimeId);
+    }
+    catch (error) {
+        initialised = false;
+    }
 };
 
 function errorBoundary(fn) {
@@ -17172,6 +17567,32 @@ function isTestEnvironment() {
     // Just use process.env.CI for now.
     return process.env.JEST_WORKER_ID !== undefined;
 }
+
+const GLOBALISE_KEY = 'imtbl__metrics';
+const MEMORISE_TIMEFRAME = 1000;
+const MEMORISE_MAX = 1000;
+const getGlobalisedValue = (key, value) => getGlobalisedValue_1(GLOBALISE_KEY, key, value);
+const getGlobalisedCachedFunction = (key, fn) => {
+    // Some applications (esp backend, or frontends using the split bundles) can sometimes
+    // initialise the same request multiple times. This will prevent multiple of the
+    // same event,value from being reported in a 1 second period.
+    const memorisedFn = lib$1.memorise(fn, {
+        lruOptions: { ttl: MEMORISE_TIMEFRAME, max: MEMORISE_MAX },
+    });
+    return getGlobalisedValue_1(GLOBALISE_KEY, key, memorisedFn);
+};
+
+const POLLING_FREQUENCY = 5000;
+// Store the event in the event store
+const trackFn = (moduleName, eventName, properties) => {
+    const event = {
+        event: `${moduleName}.${eventName}`,
+        time: new Date().toISOString(),
+        ...(properties && { properties: flattenProperties(properties) }),
+    };
+    addEvent(event);
+};
+errorBoundary(getGlobalisedCachedFunction('track', trackFn));
 // Sending events to the server
 const flushFn = async () => {
     // Don't flush if not initialised
@@ -17207,11 +17628,32 @@ const flushPoll = async () => {
     await flush();
     setTimeout(flushPoll, POLLING_FREQUENCY);
 };
+let flushingStarted = false;
+const startFlushing = () => {
+    if (flushingStarted) {
+        return;
+    }
+    flushingStarted = true;
+    flushPoll();
+};
 // This will get initialised when module is imported.
 if (!isTestEnvironment()) {
-    errorBoundary(flushPoll)();
+    errorBoundary(getGlobalisedValue('startFlushing', startFlushing))();
 }
 
+const setEnvironmentFn = (env) => {
+    storeDetail(Detail.ENVIRONMENT, env);
+};
+errorBoundary(getGlobalisedValue('setEnvironment', setEnvironmentFn));
+const setPassportClientIdFn = (passportClientId) => {
+    storeDetail(Detail.PASSPORT_CLIENT_ID, passportClientId);
+};
+errorBoundary(getGlobalisedValue('setPassportClientId', setPassportClientIdFn));
+const setPublishableApiKeyFn = (publishableApiKey) => {
+    storeDetail(Detail.PUBLISHABLE_API_KEY, publishableApiKey);
+};
+errorBoundary(getGlobalisedValue('setPublishableApiKey', setPublishableApiKeyFn));
+
 var Environment;
 (function (Environment) {
     Environment["PRODUCTION"] = "production";
@@ -27273,7 +27715,7 @@ class APIError extends Error {
 
 /* eslint-disable implicit-arrow-linebreak */
 const defaultHeaders = {
-    sdkVersion: 'ts-immutable-sdk-multi-rollup-api-client-1.5.2',
+    sdkVersion: 'ts-immutable-sdk-multi-rollup-api-client-1.5.3-alpha',
 };
 /**
  * createAPIConfiguration to create a custom Configuration
@@ -28640,7 +29082,7 @@ const IMMUTABLE_ZKVEM_GAS_OVERRIDES = {
     maxPriorityFeePerGas: BigNumber$1.from(10e9),
 };
 
-const SDK_VERSION_MARKER = '1.5.2';
+const SDK_VERSION_MARKER = '1.5.3-alpha';
 // This SDK version is replaced by the `yarn build` command ran on the root level
 const globalPackageVersion = () => SDK_VERSION_MARKER;