@imtbl/sdk 1.33.0 → 1.34.0-alpha

package/dist/webhook.js

@@ -0,0 +1,388 @@
+import MessageValidator from 'sns-validator';
+import axios from 'axios';
+import { memorise } from 'lru-memorise';
+import { getGlobalisedValue as getGlobalisedValue$1 } from 'global-const';
+
+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["SDK_VERSION"] = "sdkVersion";
+})(Detail || (Detail = {}));
+
+const IMTBL_API = 'https://api.immutable.com';
+async function post(path, data) {
+    const client = axios.create({
+        baseURL: IMTBL_API,
+    });
+    const payload = JSON.stringify(data);
+    const body = {
+        payload: Buffer.from(payload).toString('base64'),
+    };
+    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;
+};
+
+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;
+// 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$1 = (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;
+};
+
+// WARNING: DO NOT CHANGE THE STRING BELOW. IT GETS REPLACED AT BUILD TIME.
+const SDK_VERSION = '1.34.0-alpha';
+const getFrameParentDomain = () => {
+    if (isNode()) {
+        return '';
+    }
+    // If available for supported browsers (all except Firefox)
+    if (window.location.ancestorOrigins
+        && window.location.ancestorOrigins.length > 0) {
+        return new URL(window.location.ancestorOrigins[0]).hostname;
+    }
+    // Fallback to using the referrer
+    return document.referrer ? new URL(window.document.referrer).hostname : '';
+};
+const runtimeHost = () => {
+    if (isNode()) {
+        return '';
+    }
+    let domain;
+    try {
+        if (window.self !== window.top) {
+            domain = getFrameParentDomain();
+        }
+    }
+    catch (error) {
+        // Do nothing
+    }
+    // Fallback to current domain if can't detect parent domain
+    if (!domain) {
+        domain = window.location.hostname;
+    }
+    return domain;
+};
+const getRuntimeDetails = () => {
+    storeDetail(Detail.SDK_VERSION, SDK_VERSION);
+    if (isNode()) {
+        return { browser: 'nodejs', sdkVersion: SDK_VERSION };
+    }
+    const domain = runtimeHost();
+    if (domain) {
+        storeDetail(Detail.DOMAIN, domain);
+    }
+    return {
+        sdkVersion: SDK_VERSION,
+        browser: window.navigator.userAgent,
+        domain,
+        tz: Intl.DateTimeFormat().resolvedOptions().timeZone,
+        screen: `${window.screen.width}x${window.screen.height}`,
+    };
+};
+let initialised = false;
+const isInitialised = () => initialised;
+const initialise = async () => {
+    initialised = true;
+    try {
+        const runtimeDetails = flattenProperties(getRuntimeDetails());
+        const existingRuntimeId = getDetail$1(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, fallbackResult) {
+    return (...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(() => fallbackResult);
+            }
+            return result;
+        }
+        catch (error) {
+            // As above, fail silently for now
+            return fallbackResult;
+        }
+    };
+}
+
+function isTestEnvironmentFn() {
+    if (isBrowser()) {
+        return false;
+    }
+    if (typeof process === 'undefined') {
+        return false;
+    }
+    // Consider using `ci-info` package for better results, though might fail as not browser safe.
+    // Just use process.env.CI for now.
+    return process.env.JEST_WORKER_ID !== undefined;
+}
+const isTestEnvironment = errorBoundary(isTestEnvironmentFn, false);
+
+const GLOBALISE_KEY = 'imtbl__metrics';
+const MEMORISE_TIMEFRAME = 5000;
+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 = memorise(fn, {
+        lruOptions: { ttl: MEMORISE_TIMEFRAME, max: MEMORISE_MAX },
+    });
+    return getGlobalisedValue$1(GLOBALISE_KEY, key, memorisedFn);
+};
+
+const POLLING_FREQUENCY = 5000;
+const trackFn = (moduleName, eventName, properties) => {
+    const event = {
+        event: `${moduleName}.${eventName}`,
+        time: new Date().toISOString(),
+        ...(properties && { properties: flattenProperties(properties) }),
+    };
+    addEvent(event);
+};
+/**
+ * Track an event completion.
+ * @param moduleName Name of the module being tracked (for namespacing purposes), e.g. `passport`
+ * @param eventName Name of the event, use camelCase e.g. `clickItem`
+ * @param properties Other properties to be sent with the event
+ *
+ * e.g.
+ *
+ * ```ts
+ * track("passport", "performTransaction");
+ * track("passport", "performTransaction", { transationType: "transfer" });
+ * ```
+ */
+errorBoundary(getGlobalisedCachedFunction('track', 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);
+};
+let flushingStarted = false;
+const startFlushing = () => {
+    if (flushingStarted) {
+        return;
+    }
+    flushingStarted = true;
+    flushPoll();
+};
+// This will get initialised when module is imported.
+if (!isTestEnvironment()) {
+    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));
+errorBoundary(getGlobalisedValue('getDetail', getDetail$1));
+
+var Environment;
+(function (Environment) {
+    Environment["PRODUCTION"] = "production";
+    Environment["SANDBOX"] = "sandbox";
+})(Environment || (Environment = {}));
+var KeyHeaders;
+(function (KeyHeaders) {
+    KeyHeaders["API_KEY"] = "x-immutable-api-key";
+    KeyHeaders["PUBLISHABLE_KEY"] = "x-immutable-publishable-key";
+    KeyHeaders["RATE_LIMITING_KEY"] = "x-api-key";
+})(KeyHeaders || (KeyHeaders = {}));
+
+const validator = new MessageValidator();
+const allowedTopicArnPrefix = {
+    [Environment.PRODUCTION]: 'arn:aws:sns:us-east-2:362750628221:',
+    [Environment.SANDBOX]: 'arn:aws:sns:us-east-2:783421985614:'
+};
+const init = async (body, env, handlers) => {
+    const msg = await new Promise((resolve, reject) => {
+        validator.validate(body, (err, message) => {
+            if (err) {
+                return reject(err);
+            }
+            // check for topic arn prefix
+            if (!msg.TopicArn.startsWith(allowedTopicArnPrefix[env])) {
+                throw new Error('Invalid topic arn');
+            }
+            if (message?.Type === 'SubscriptionConfirmation') {
+                fetch(message.SubscribeURL).then(() => {
+                    resolve(message);
+                }).catch((e) => {
+                    reject(e);
+                });
+            }
+            return resolve(message);
+        });
+    });
+    if (msg.Type === 'Notification') {
+        const event = JSON.parse(msg.Message);
+        switch (event.event_name) {
+            case 'imtbl_zkevm_mint_request_updated':
+                await handlers.zkevmMintRequestUpdated(event);
+                break;
+            default:
+                if (handlers.others) {
+                    await handlers.others(event);
+                }
+                break;
+        }
+    }
+};
+
+export { init };

package/dist/x.js

@@ -9003,7 +9003,7 @@ const flattenProperties = (properties) => {
 };
 
 // WARNING: DO NOT CHANGE THE STRING BELOW. IT GETS REPLACED AT BUILD TIME.
-const SDK_VERSION = '1.33.0';
+const SDK_VERSION = '1.34.0-alpha';
 const getFrameParentDomain = () => {
     if (isNode()) {
         return '';
@@ -9269,7 +9269,7 @@ const addKeysToHeadersOverride = (baseConfig, overrides) => {
 /* eslint-disable @typescript-eslint/naming-convention */
 class ApiConfiguration extends index$2.Configuration {
 }
-const defaultHeaders = { 'x-sdk-version': 'ts-immutable-sdk-1.33.0' };
+const defaultHeaders = { 'x-sdk-version': 'ts-immutable-sdk-1.34.0-alpha' };
 /**
  * @dev use createImmutableXConfiguration instead
  */
@@ -9308,7 +9308,7 @@ const createImmutableXConfiguration = ({ basePath, chainID, coreContractAddress,
     chainID,
     coreContractAddress,
     registrationContractAddress,
-    sdkVersion: 'ts-immutable-sdk-1.33.0',
+    sdkVersion: 'ts-immutable-sdk-1.34.0-alpha',
     baseConfig,
 });
 const production = ({ baseConfig }) => createImmutableXConfiguration({

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@imtbl/sdk",
   "description": "Immutable Unified SDK",
-  "version": "1.33.0",
+  "version": "1.34.0-alpha",
   "author": "Immutable",
   "browser": "./dist/index.browser.js",
   "bugs": "https://github.com/immutable/ts-immutable-sdk/issues",
@@ -48,6 +48,7 @@
     "os-browserify": "^0.3.0",
     "pako": "^2.1.0",
     "react-i18next": "^13.5.0",
+    "sns-validator": "^0.3.5",
     "stream-browserify": "^3.0.0",
     "stream-http": "^3.2.0",
     "url": "^0.11.0",
@@ -64,9 +65,11 @@
     "@imtbl/cryptofiat": "0.0.0",
     "@imtbl/generated-clients": "0.0.0",
     "@imtbl/guardian": "0.0.0",
+    "@imtbl/minting-backend": "0.0.0",
     "@imtbl/orderbook": "0.0.0",
     "@imtbl/passport": "0.0.0",
     "@imtbl/version-check": "0.0.0",
+    "@imtbl/webhook": "0.0.0",
     "@imtbl/x-client": "0.0.0",
     "@imtbl/x-provider": "0.0.0",
     "@rollup/plugin-babel": "^6.0.4",
@@ -119,6 +122,14 @@
     "./x": {
       "types": "./dist/x.d.ts",
       "import": "./dist/x.js"
+    },
+    "./webhook": {
+      "types": "./dist/webhook.d.ts",
+      "import": "./dist/webhook.js"
+    },
+    "./minting_backend": {
+      "types": "./dist/minting_backend.d.ts",
+      "import": "./dist/minting_backend.js"
     }
   },
   "files": [
@@ -128,13 +139,12 @@
   "license": "Apache-2.0",
   "main": "./dist/index.cjs",
   "module": "./dist/index.js",
+  "optionalDependencies": {
+    "pg": "^8.11.5"
+  },
   "overrides": {
     "@openzeppelin/contracts": "3.4.2-solc-0.7"
   },
-  "peerDependencies": {
-    "react": "^18.2.0",
-    "react-dom": "^18.2.0"
-  },
   "repository": "immutable/ts-immutable-sdk.git",
   "resolutions": {
     "@biom3/design-tokens": "^0.3.7",