@imtbl/sdk 0.45.4 → 0.45.6

package/dist/index.js

@@ -24,6 +24,300 @@ import { SwapRouter, PaymentsExtended } from '@uniswap/router-sdk';
 import { parseUnits } from '@ethersproject/units';
 import { BigNumber as BigNumber$2 } from '@ethersproject/bignumber';
 
+const isNode$1 = () => typeof window === 'undefined';
+const isBrowser$1 = () => !isNode$1();
+
+var Detail$1;
+(function (Detail) {
+    Detail["RUNTIME_ID"] = "rid";
+    Detail["PASSPORT_CLIENT_ID"] = "passportClientId";
+    Detail["ENVIRONMENT"] = "env";
+    Detail["PUBLISHABLE_API_KEY"] = "pak";
+    Detail["IDENTITY"] = "uid";
+    Detail["DOMAIN"] = "domain";
+})(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) {
+    const client = globalAxios$1.create({
+        baseURL: IMTBL_API$1,
+    });
+    const payload = JSON.stringify(data);
+    const body = {
+        payload: btoa(payload),
+    };
+    const response = await client.post(path, body);
+    return response.data;
+}
+
+/**
+ * Abstraction on localstorage
+ */
+const localStoragePrefix$1 = '__IMX-';
+const hasLocalstorage$1 = () => isBrowser$1() && window.localStorage;
+const parseItem$1 = (payload) => {
+    // Try to parse, if can't be parsed assume string
+    // and return string
+    if (payload === null)
+        return undefined;
+    try {
+        return JSON.parse(payload);
+    }
+    catch (error) {
+        // Assumes it's a string.
+        return payload;
+    }
+};
+const serialiseItem$1 = (payload) => {
+    if (typeof payload === 'string') {
+        return payload;
+    }
+    return JSON.stringify(payload);
+};
+/**
+ * GenKey will take into account the namespace
+ * as well as if being run in the Link, it will tap into the link
+ * @param {string} key
+ * @returns key
+ */
+const genKey$1 = (key) => `${localStoragePrefix$1}${key}`;
+function getItem$1(key) {
+    if (hasLocalstorage$1()) {
+        return parseItem$1(window.localStorage.getItem(genKey$1(key)));
+    }
+    return undefined;
+}
+const setItem$1 = (key, payload) => {
+    if (hasLocalstorage$1()) {
+        window.localStorage.setItem(genKey$1(key), serialiseItem$1(payload));
+        return true;
+    }
+    return false;
+};
+
+// In memory storage for events and other data
+let EVENT_STORE$1;
+let RUNTIME_DETAILS$1;
+// Initialise store and runtime
+const initialise$1$1 = () => {
+    EVENT_STORE$1 = getItem$1(Store$1.EVENTS) || [];
+    RUNTIME_DETAILS$1 = getItem$1(Store$1.RUNTIME) || {};
+};
+initialise$1$1();
+// Runtime Details
+const storeDetail$1 = (key, value) => {
+    RUNTIME_DETAILS$1 = {
+        ...RUNTIME_DETAILS$1,
+        [key]: value,
+    };
+    setItem$1(Store$1.RUNTIME, RUNTIME_DETAILS$1);
+};
+const getDetail$1 = (key) => {
+    // Handle the scenario where detail is a falsy value
+    if (RUNTIME_DETAILS$1[key] === undefined) {
+        return undefined;
+    }
+    return RUNTIME_DETAILS$1[key];
+};
+const getAllDetails$1 = () => RUNTIME_DETAILS$1;
+// Events
+const getEvents$1 = () => EVENT_STORE$1;
+const addEvent$1 = (event) => {
+    EVENT_STORE$1.push(event);
+    setItem$1(Store$1.EVENTS, EVENT_STORE$1);
+};
+const removeSentEvents$1 = (numberOfEvents) => {
+    EVENT_STORE$1 = EVENT_STORE$1.slice(numberOfEvents);
+    setItem$1(Store$1.EVENTS, EVENT_STORE$1);
+};
+const flattenProperties$1 = (properties) => {
+    const propertyMap = [];
+    Object.entries(properties).forEach(([key, value]) => {
+        if (typeof key === 'string'
+            || typeof value === 'string'
+            || typeof value === 'number'
+            || typeof value === 'boolean') {
+            propertyMap.push([key, value.toString()]);
+        }
+    });
+    return propertyMap;
+};
+
+let initialised$1 = false;
+const isInitialised$1 = () => initialised$1;
+const getReferrer$1 = () => {
+    if (isNode$1()) {
+        return '';
+    }
+    if (window.location.ancestorOrigins
+        && window.location.ancestorOrigins.length > 0) {
+        return new URL(window.location.ancestorOrigins[0]).hostname;
+    }
+    return document.referrer ? new URL(window.document.referrer).hostname : '';
+};
+const runtimeHost$1 = () => {
+    if (isNode$1()) {
+        return '';
+    }
+    if (window.opener || window.parent !== window) {
+        return getReferrer$1();
+    }
+    return new URL(window.location.href).hostname;
+};
+const getRuntimeDetails$1 = () => {
+    if (isNode$1()) {
+        return { browser: 'nodejs' };
+    }
+    const domain = runtimeHost$1();
+    if (domain) {
+        storeDetail$1(Detail$1.DOMAIN, domain);
+    }
+    return {
+        browser: window.navigator.userAgent,
+        domain,
+        tz: Intl.DateTimeFormat().resolvedOptions().timeZone,
+        screen: `${window.screen.width}x${window.screen.height}`,
+    };
+};
+const initialise$2 = async () => {
+    const runtimeDetails = flattenProperties$1(getRuntimeDetails$1());
+    // Get any existing runtimeId and send it along with the initialise
+    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;
+};
+
+function errorBoundary$1(fn) {
+    const wrappedFunction = ((...args) => {
+        try {
+            // Execute the original function
+            const result = fn(...args);
+            if (result instanceof Promise) {
+                // Silent fail for now, in future
+                // we can send errors to a logging service
+                return result.catch(() => undefined);
+            }
+            return result;
+        }
+        catch (error) {
+            // As above, fail silently for now
+            return undefined;
+        }
+    });
+    return wrappedFunction;
+}
+
+function isTestEnvironment$1() {
+    if (typeof process === 'undefined') {
+        return false;
+    }
+    return process.env.JEST_WORKER_ID !== undefined;
+}
+
+// Store the event in the event store
+const trackFn$1 = (moduleName, eventName, properties) => {
+    const event = {
+        event: `${moduleName}.${eventName}`,
+        time: new Date().toISOString(),
+        ...(properties && { properties: flattenProperties$1(properties) }),
+    };
+    addEvent$1(event);
+};
+const track$1 = errorBoundary$1(trackFn$1);
+// Sending events to the server
+const flushFn$1 = async () => {
+    // Don't flush if not initialised
+    if (isInitialised$1() === false) {
+        await initialise$2();
+        return;
+    }
+    const events = getEvents$1();
+    if (events.length === 0) {
+        return;
+    }
+    // Track events length here, incase
+    const numEvents = events.length;
+    // Get details and send it with the track request
+    const details = getAllDetails$1();
+    const metricsPayload = {
+        version: 1,
+        data: {
+            events,
+            details,
+        },
+    };
+    const response = await post$1('/v1/sdk/metrics', metricsPayload);
+    if (response instanceof Error) {
+        return;
+    }
+    // Clear events if successfully posted
+    removeSentEvents$1(numEvents);
+};
+const flush$1 = errorBoundary$1(flushFn$1);
+// Flush events every 5 seconds
+const flushPoll$1 = async () => {
+    await flush$1();
+    setTimeout(flushPoll$1, POLLING_FREQUENCY$1);
+};
+// This will get initialised when module is imported.
+if (!isTestEnvironment$1()) {
+    errorBoundary$1(flushPoll$1)();
+}
+
+const parseIdentity = (params) => {
+    if (params.passportId) {
+        const key = `passport:${params.passportId.toLowerCase()}`;
+        return key;
+    }
+    if (params.ethAddress) {
+        const key = `ethAddress:${params.ethAddress.toLowerCase()}`;
+        return key;
+    }
+    throw new Error('invalid_identity');
+};
+const identifyFn = (params) => {
+    const identity = parseIdentity(params);
+    if (!identity) {
+        return;
+    }
+    storeDetail$1(Detail$1.IDENTITY, identity);
+    track$1('metrics', 'identify', params.traits);
+};
+const identify = errorBoundary$1(identifyFn);
+
+const setEnvironmentFn = (env) => {
+    storeDetail$1(Detail$1.ENVIRONMENT, env);
+};
+const setEnvironment = errorBoundary$1(setEnvironmentFn);
+const setPassportClientIdFn = (passportClientId) => {
+    storeDetail$1(Detail$1.PASSPORT_CLIENT_ID, passportClientId);
+};
+const setPassportClientId = errorBoundary$1(setPassportClientIdFn);
+const setPublishableApiKeyFn = (publishableApiKey) => {
+    storeDetail$1(Detail$1.PUBLISHABLE_API_KEY, publishableApiKey);
+};
+const setPublishableApiKey = errorBoundary$1(setPublishableApiKeyFn);
+
+track$1('metrics', 'sdk_version', {
+    version: '0.45.6',
+});
+
 var Environment$1;
 (function (Environment) {
     Environment["PRODUCTION"] = "production";
@@ -36,6 +330,8 @@ class ImmutableConfiguration {
     publishableKey;
     constructor(options) {
         this.environment = options.environment;
+        setEnvironment(options.environment);
+        track$1('config', 'created_imtbl_config');
     }
 }
 const API_KEY_PREFIX = 'sk_imapik-';
@@ -51,6 +347,7 @@ const addPublishableKeyToAxiosHeader = (publishableKey) => {
         throw new Error('Invalid Publishable key. Create your Publishable key in Immutable developer hub.'
             + ' https://hub.immutable.com');
     }
+    setPublishableApiKey(publishableKey);
     globalAxios$1.defaults.headers.common['x-immutable-publishable-key'] = publishableKey;
 };
 const addRateLimitingKeyToAxiosHeader = (rateLimitingKey) => {
@@ -10619,7 +10916,7 @@ class MultiRollupApiClients {
 }
 
 // eslint-disable-next-line @typescript-eslint/naming-convention
-const defaultHeaders$1 = { 'x-sdk-version': 'ts-immutable-sdk-0.45.4' };
+const defaultHeaders$1 = { 'x-sdk-version': 'ts-immutable-sdk-0.45.6' };
 const createConfig = ({ basePath, headers, }) => {
     if (!basePath.trim()) {
         throw Error('basePath can not be empty');
@@ -10691,7 +10988,7 @@ class APIError extends Error {
 
 /* eslint-disable implicit-arrow-linebreak */
 const defaultHeaders = {
-    sdkVersion: 'ts-immutable-sdk-multi-rollup-api-client-0.45.4',
+    sdkVersion: 'ts-immutable-sdk-multi-rollup-api-client-0.45.6',
 };
 /**
  * createAPIConfiguration to create a custom Configuration
@@ -11130,7 +11427,7 @@ const createImmutableXConfiguration = ({ basePath, chainID, coreContractAddress,
     chainID,
     coreContractAddress,
     registrationContractAddress,
-    sdkVersion: 'ts-immutable-sdk-0.45.4',
+    sdkVersion: 'ts-immutable-sdk-0.45.6',
 });
 /**
  * Sets `sdkVersion` at the time of build
@@ -17871,7 +18168,8 @@ class Passport {
         this.multiRollupApiClients = new MultiRollupApiClients(this.config.multiRollupConfig);
         this.passportEventEmitter = new TypedEventEmitter();
         const imxClientConfig = this.config.baseConfig.environment === Environment$1.PRODUCTION
-            ? imxApiConfig.getProduction() : imxApiConfig.getSandbox();
+            ? imxApiConfig.getProduction()
+            : imxApiConfig.getSandbox();
         const imxApiClients = passportModuleConfiguration.overrides?.imxApiClients
             || new ImxApiClients(imxClientConfig);
         this.passportImxProviderFactory = new PassportImxProviderFactory({
@@ -17883,6 +18181,8 @@ class Passport {
             passportEventEmitter: this.passportEventEmitter,
             imxApiClients,
         });
+        setPassportClientId(passportModuleConfiguration.clientId);
+        track$1('passport', 'initialised');
     }
     /**
      * @deprecated The method `login` with an argument of `{ useCachedSession: true }` should be used in conjunction with
@@ -17928,6 +18228,11 @@ class Passport {
         if (!user && !useCachedSession) {
             user = await this.authManager.login();
         }
+        if (user) {
+            identify({
+                passportId: user.profile.sub,
+            });
+        }
         return user ? user.profile : null;
     }
     async loginCallback() {
@@ -36284,6 +36589,266 @@ class TokenBridge {
     }
 }
 
+const isNode = () => typeof window === 'undefined';
+const isBrowser = () => !isNode();
+
+var Detail;
+(function (Detail) {
+    Detail["RUNTIME_ID"] = "rid";
+    Detail["PASSPORT_CLIENT_ID"] = "passportClientId";
+    Detail["ENVIRONMENT"] = "env";
+    Detail["PUBLISHABLE_API_KEY"] = "pak";
+    Detail["IDENTITY"] = "uid";
+    Detail["DOMAIN"] = "domain";
+})(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) {
+    const client = axios$1.create({
+        baseURL: IMTBL_API,
+    });
+    const payload = JSON.stringify(data);
+    const body = {
+        payload: btoa(payload),
+    };
+    const response = await client.post(path, body);
+    return response.data;
+}
+
+/**
+ * Abstraction on localstorage
+ */
+const localStoragePrefix = '__IMX-';
+const hasLocalstorage = () => isBrowser() && window.localStorage;
+const parseItem = (payload) => {
+    // Try to parse, if can't be parsed assume string
+    // and return string
+    if (payload === null)
+        return undefined;
+    try {
+        return JSON.parse(payload);
+    }
+    catch (error) {
+        // Assumes it's a string.
+        return payload;
+    }
+};
+const serialiseItem = (payload) => {
+    if (typeof payload === 'string') {
+        return payload;
+    }
+    return JSON.stringify(payload);
+};
+/**
+ * GenKey will take into account the namespace
+ * as well as if being run in the Link, it will tap into the link
+ * @param {string} key
+ * @returns key
+ */
+const genKey = (key) => `${localStoragePrefix}${key}`;
+function getItem(key) {
+    if (hasLocalstorage()) {
+        return parseItem(window.localStorage.getItem(genKey(key)));
+    }
+    return undefined;
+}
+const setItem = (key, payload) => {
+    if (hasLocalstorage()) {
+        window.localStorage.setItem(genKey(key), serialiseItem(payload));
+        return true;
+    }
+    return false;
+};
+
+// In memory storage for events and other data
+let EVENT_STORE;
+let RUNTIME_DETAILS;
+// Initialise store and runtime
+const initialise$1 = () => {
+    EVENT_STORE = getItem(Store.EVENTS) || [];
+    RUNTIME_DETAILS = getItem(Store.RUNTIME) || {};
+};
+initialise$1();
+// Runtime Details
+const storeDetail = (key, value) => {
+    RUNTIME_DETAILS = {
+        ...RUNTIME_DETAILS,
+        [key]: value,
+    };
+    setItem(Store.RUNTIME, RUNTIME_DETAILS);
+};
+const getDetail = (key) => {
+    // Handle the scenario where detail is a falsy value
+    if (RUNTIME_DETAILS[key] === undefined) {
+        return undefined;
+    }
+    return RUNTIME_DETAILS[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);
+};
+const flattenProperties = (properties) => {
+    const propertyMap = [];
+    Object.entries(properties).forEach(([key, value]) => {
+        if (typeof key === 'string'
+            || typeof value === 'string'
+            || typeof value === 'number'
+            || typeof value === 'boolean') {
+            propertyMap.push([key, value.toString()]);
+        }
+    });
+    return propertyMap;
+};
+
+let initialised = false;
+const isInitialised = () => initialised;
+const getReferrer = () => {
+    if (isNode()) {
+        return '';
+    }
+    if (window.location.ancestorOrigins
+        && window.location.ancestorOrigins.length > 0) {
+        return new URL(window.location.ancestorOrigins[0]).hostname;
+    }
+    return document.referrer ? new URL(window.document.referrer).hostname : '';
+};
+const runtimeHost = () => {
+    if (isNode()) {
+        return '';
+    }
+    if (window.opener || window.parent !== window) {
+        return getReferrer();
+    }
+    return new URL(window.location.href).hostname;
+};
+const getRuntimeDetails = () => {
+    if (isNode()) {
+        return { browser: 'nodejs' };
+    }
+    const domain = runtimeHost();
+    if (domain) {
+        storeDetail(Detail.DOMAIN, domain);
+    }
+    return {
+        browser: window.navigator.userAgent,
+        domain,
+        tz: Intl.DateTimeFormat().resolvedOptions().timeZone,
+        screen: `${window.screen.width}x${window.screen.height}`,
+    };
+};
+const initialise = async () => {
+    const runtimeDetails = flattenProperties(getRuntimeDetails());
+    // Get any existing runtimeId and send it along with the initialise
+    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;
+};
+
+function errorBoundary(fn) {
+    const wrappedFunction = ((...args) => {
+        try {
+            // Execute the original function
+            const result = fn(...args);
+            if (result instanceof Promise) {
+                // Silent fail for now, in future
+                // we can send errors to a logging service
+                return result.catch(() => undefined);
+            }
+            return result;
+        }
+        catch (error) {
+            // As above, fail silently for now
+            return undefined;
+        }
+    });
+    return wrappedFunction;
+}
+
+function isTestEnvironment() {
+    if (typeof process === 'undefined') {
+        return false;
+    }
+    return process.env.JEST_WORKER_ID !== undefined;
+}
+
+// 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);
+};
+const track = errorBoundary(trackFn);
+// Sending events to the server
+const flushFn = async () => {
+    // Don't flush if not initialised
+    if (isInitialised() === false) {
+        await initialise();
+        return;
+    }
+    const events = getEvents();
+    if (events.length === 0) {
+        return;
+    }
+    // Track events length here, incase
+    const numEvents = events.length;
+    // Get details and send it with the track request
+    const details = getAllDetails();
+    const metricsPayload = {
+        version: 1,
+        data: {
+            events,
+            details,
+        },
+    };
+    const response = await post('/v1/sdk/metrics', metricsPayload);
+    if (response instanceof Error) {
+        return;
+    }
+    // Clear events if successfully posted
+    removeSentEvents(numEvents);
+};
+const flush = errorBoundary(flushFn);
+// Flush events every 5 seconds
+const flushPoll = async () => {
+    await flush();
+    setTimeout(flushPoll, POLLING_FREQUENCY);
+};
+// This will get initialised when module is imported.
+if (!isTestEnvironment()) {
+    errorBoundary(flushPoll)();
+}
+
+track('metrics', 'sdk_version', {
+    version: '0.45.6',
+});
+
 var Environment;
 (function (Environment) {
     Environment["PRODUCTION"] = "production";
@@ -41263,7 +41828,7 @@ const IMMUTABLE_ZKVEM_GAS_OVERRIDES = {
     maxPriorityFeePerGas: BigNumber$1.from(10e9),
 };
 
-const SDK_VERSION_MARKER = '0.45.4';
+const SDK_VERSION_MARKER = '0.45.6';
 // This SDK version is replaced by the `yarn build` command ran on the root level
 const globalPackageVersion = () => SDK_VERSION_MARKER;
 
@@ -41468,7 +42033,7 @@ async function getERC20TokenInfo(web3Provider, tokenAddress) {
     }, { type: CheckoutErrorType.GET_ERC20_INFO_ERROR });
 }
 
-const CACHE_DATA_TTL = 60; // seconds
+const CACHE_DATA_TTL = 5; // seconds
 /**
  * Blockscout class provides a client abstraction for the Immutable 3rd party indexer.
  */

package/dist/orderbook.d.ts

@@ -21,9 +21,9 @@ type ImmutableConfigurationWithRequireableFields<T> = ImmutableConfiguration & (
 } ? Required<{
     publishableKey: string;
 }> : {});
-type ImmutableConfigurationWithOmitableFields<T> = (T extends {
+type ImmutableConfigurationWithOmitableFields<T> = T extends {
     apiKey: 'omit';
-} ? Omit<ImmutableConfigurationWithRequireableFields<T>, 'apiKey'> : ImmutableConfigurationWithRequireableFields<T>);
+} ? Omit<ImmutableConfigurationWithRequireableFields<T>, 'apiKey'> : ImmutableConfigurationWithRequireableFields<T>;
 interface ModuleConfiguration<T> {
     baseConfig: ImmutableConfigurationWithOmitableFields<T>;
     overrides?: T;