@imtbl/sdk 1.43.8 → 1.44.0

package/dist/webhook.js

@@ -1 +1,488 @@
-export{h as handle}from"./index-cce11a83.js";import"sns-validator";import"./index-97ccc0d4.js";import"axios";import"lru-memorise";import"global-const";
+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.44.0';
+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:'
+};
+/**
+ * handle will validate webhook message origin and verify signature of the message and calls corresponding handlers passed in.
+ * @param body The request body to a webhook endpoint in json string or js object form.
+ * @param env The Immutable environment the webhook is set up for.
+ * @param handlers The optional handlers object for different events. The `all` handler will be triggered for all event types.
+ * @returns The event object from the webhook message after validation and verification.
+ */
+const handle = 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 (!message.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') {
+        // the msg.Message is only a valid JSON string when the message is of Type Notification
+        const event = JSON.parse(msg.Message);
+        switch (event.event_name) {
+            case 'imtbl_zkevm_mint_request_updated':
+                if (handlers?.zkevmMintRequestUpdated) {
+                    await handlers?.zkevmMintRequestUpdated(event);
+                }
+                break;
+            case 'imtbl_zkevm_activity_mint':
+                if (handlers?.zkEvmActivityMint) {
+                    await handlers?.zkEvmActivityMint(event);
+                }
+                break;
+            case 'imtbl_zkevm_activity_burn':
+                if (handlers?.zkEvmActivityBurn) {
+                    await handlers?.zkEvmActivityBurn(event);
+                }
+                break;
+            case 'imtbl_zkevm_activity_transfer':
+                if (handlers?.zkEvmActivityTransfer) {
+                    await handlers?.zkEvmActivityTransfer(event);
+                }
+                break;
+            case 'imtbl_zkevm_activity_sale':
+                if (handlers?.zkEvmActivitySale) {
+                    await handlers?.zkEvmActivitySale(event);
+                }
+                break;
+            case 'imtbl_zkevm_activity_deposit':
+                if (handlers?.zkEvmActivityDeposit) {
+                    await handlers?.zkEvmActivityDeposit(event);
+                }
+                break;
+            case 'imtbl_zkevm_activity_withdrawal':
+                if (handlers?.zkEvmActivityWithdrawal) {
+                    await handlers?.zkEvmActivityWithdrawal(event);
+                }
+                break;
+            case 'imtbl_zkevm_collection_updated':
+                if (handlers?.zkEvmCollectionUpdated) {
+                    await handlers?.zkEvmCollectionUpdated(event);
+                }
+                break;
+            case 'imtbl_zkevm_nft_updated':
+                if (handlers?.zkEvmNftUpdated) {
+                    await handlers?.zkEvmNftUpdated(event);
+                }
+                break;
+            case 'imtbl_zkevm_metadata_updated':
+                if (handlers?.zkEvmMetadataUpdated) {
+                    await handlers?.zkEvmMetadataUpdated(event);
+                }
+                break;
+            case 'imtbl_zkevm_token_updated':
+                if (handlers?.zkEvmTokenUpdated) {
+                    await handlers?.zkEvmTokenUpdated(event);
+                }
+                break;
+            case 'imtbl_zkevm_order_updated':
+                if (handlers?.zkEvmOrderUpdated) {
+                    await handlers?.zkEvmOrderUpdated(event);
+                }
+                break;
+            case 'imtbl_zkevm_trade_created':
+                if (handlers?.zkEvmTradeCreated) {
+                    await handlers?.zkEvmTradeCreated(event);
+                }
+                break;
+            case 'imtbl_x_nft_created':
+                if (handlers?.xNftCreated) {
+                    await handlers?.xNftCreated(event);
+                }
+                break;
+            case 'imtbl_x_nft_updated':
+                if (handlers?.xNftUpdated) {
+                    await handlers?.xNftUpdated(event);
+                }
+                break;
+            case 'imtbl_x_order_accepted':
+                if (handlers?.xOrderAccepted) {
+                    await handlers?.xOrderAccepted(event);
+                }
+                break;
+            case 'imtbl_x_order_filled':
+                if (handlers?.xOrderFilled) {
+                    await handlers?.xOrderFilled(event);
+                }
+                break;
+            case 'imtbl_x_order_cancelled':
+                if (handlers?.xOrderCancelled) {
+                    await handlers?.xOrderCancelled(event);
+                }
+                break;
+            case 'imtbl_x_transfer_created':
+                if (handlers?.xTransferCreated) {
+                    await handlers?.xTransferCreated(event);
+                }
+                break;
+        }
+        if (handlers?.all) {
+            await handlers?.all(event);
+        }
+        return event;
+    }
+    return null;
+};
+
+export { handle };