@ultrade/shared 1.0.0

package/dist/common/index.js

@@ -0,0 +1,2541 @@
+(function webpackUniversalModuleDefinition(root, factory) {
+	if(typeof exports === 'object' && typeof module === 'object')
+		module.exports = factory(require("buffer"), require("@aws-sdk/client-secrets-manager"), require("bignumber.js"), require("ioredis"), require("@aws-sdk/client-kms"), require("algosdk"));
+	else if(typeof define === 'function' && define.amd)
+		define(["buffer", "@aws-sdk/client-secrets-manager", "bignumber.js", "ioredis", "@aws-sdk/client-kms", "algosdk"], factory);
+	else {
+		var a = typeof exports === 'object' ? factory(require("buffer"), require("@aws-sdk/client-secrets-manager"), require("bignumber.js"), require("ioredis"), require("@aws-sdk/client-kms"), require("algosdk")) : factory(root["buffer"], root["@aws-sdk/client-secrets-manager"], root["bignumber.js"], root["ioredis"], root["@aws-sdk/client-kms"], root["algosdk"]);
+		for(var i in a) (typeof exports === 'object' ? exports : root)[i] = a[i];
+	}
+})(global, (__WEBPACK_EXTERNAL_MODULE__18__, __WEBPACK_EXTERNAL_MODULE__2216__, __WEBPACK_EXTERNAL_MODULE__6168__, __WEBPACK_EXTERNAL_MODULE__6615__, __WEBPACK_EXTERNAL_MODULE__7818__, __WEBPACK_EXTERNAL_MODULE__9709__) => {
+return /******/ (() => { // webpackBootstrap
+/******/ 	"use strict";
+/******/ 	var __webpack_modules__ = ({
+
+/***/ 18:
+/***/ ((module) => {
+
+module.exports = __WEBPACK_EXTERNAL_MODULE__18__;
+
+/***/ }),
+
+/***/ 180:
+/***/ ((__unused_webpack_module, exports) => {
+
+
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports.timestamp = timestamp;
+const startTime = BigInt(Date.now());
+const startHrTime = process.hrtime.bigint();
+function timestamp(accuracy = 'micro') {
+    const elapsedNano = process.hrtime.bigint() - startHrTime;
+    const baseTimestampNano = startTime * 10n ** 6n + elapsedNano;
+    const baseString = baseTimestampNano.toString();
+    let result;
+    if (accuracy === "micro") {
+        result = `${baseString.slice(0, -6)}.${baseString.slice(-6, -3)}`;
+    }
+    else {
+        result = `${baseString.slice(0, -6)}.${baseString.slice(-6)}`;
+    }
+    return result;
+}
+
+
+/***/ }),
+
+/***/ 221:
+/***/ ((__unused_webpack_module, exports) => {
+
+
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports.mapToCodexAssetDto = mapToCodexAssetDto;
+function mapToCodexAssetDto(o, isArchived) {
+    return {
+        id: o.id,
+        address: o.address,
+        chainId: o.chainId,
+        name: o.name,
+        unitName: o.unitName,
+        decimals: o.decimals,
+        isGas: o.isGas,
+        img: o.img,
+        cmcLink: o.cmcLink,
+        isArchived: isArchived ? isArchived(o) : false,
+    };
+}
+
+
+/***/ }),
+
+/***/ 298:
+/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
+
+
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports.Logger = void 0;
+const node_process_1 = __webpack_require__(1708);
+class Logger {
+    constructor(prefix, disabled) {
+        this._timeLabels = new Map();
+        this._prefix = prefix;
+        this.disabled = disabled;
+    }
+    log(...args) {
+        if (this.disabled) {
+            return;
+        }
+        try {
+            this._prefix
+                ? console.log(this.prefixLabel(this._prefix), ...this.formatArgs(args))
+                : console.log(...this.formatArgs(args));
+        }
+        catch (error) {
+            console.log('Error on formating args', error);
+            console.log('Args =>', ...args);
+        }
+    }
+    logWarning(message) {
+        console.log(this.toYellow(message));
+    }
+    getUniqueTimeLabel(label) {
+        const timeLabel = `[${Math.random() * Math.pow(10, 18)}] ${label}`;
+        return timeLabel;
+    }
+    time(label) {
+        if (this._timeLabels.has(label)) {
+            console.warn(`Label '${label}' already exists for logger.time()`);
+            return;
+        }
+        const start = node_process_1.hrtime.bigint();
+        this._timeLabels.set(label, start);
+    }
+    timeEnd(label) {
+        if (!this._timeLabels.has(label)) {
+            console.warn(`Label '${label}' does not exist for logger.time()`);
+            return 0;
+        }
+        const start = this._timeLabels.get(label);
+        const end = node_process_1.hrtime.bigint();
+        const diff = +(Number(end - start) / 1000000).toFixed(2);
+        const color = process.env.LOGGING_OBJECT_INLINE !== "false"
+            ? this.noColor
+            : (diff > 100 ? this.toRed : this.toYellow);
+        // console.log(' ');
+        if (diff > 100 || (label.includes('update24hStat') && diff > 25)) {
+            this.log(`Benchmark took ${color(diff)} milliseconds for ${color(label)}`);
+        }
+        this._timeLabels.delete(label);
+        return +diff;
+    }
+    logRabbit(...args) {
+        this.log(...this.formatArgs(["[Rabbit]", ...args]));
+    }
+    logPair(...args) {
+        this.log(...this.formatArgs(args, "Pair"));
+    }
+    logPairTime(pair, label) {
+        this.time(`${this.prefixLabel("Pair", pair)} ${label}`);
+    }
+    logPairTimeEnd(pair, label) {
+        this.timeEnd(`${this.prefixLabel("Pair", pair)} ${label}`);
+    }
+    logOrder(...args) {
+        this.log(...this.formatArgs(args, "OrderID"));
+    }
+    logOrderTime(id, label) {
+        this.time(`${this.prefixLabel("OrderID", id)} ${label}`);
+    }
+    logOrderTimeEnd(id, label) {
+        this.timeEnd(`${this.prefixLabel("OrderID", id)} ${label}`);
+    }
+    logTrade(...args) {
+        this.log(...this.formatArgs(args, "TradeID"));
+    }
+    logCompany(...args) {
+        this.log(...this.formatArgs(args, "CompanyID"));
+    }
+    logTradeTime(id, label) {
+        this.time(`${this.prefixLabel("TradeID", id)} ${label}`);
+    }
+    logTradeTimeEnd(id, label) {
+        this.timeEnd(`${this.prefixLabel("TradeID", id)} ${label}`);
+    }
+    logOperation(...args) {
+        this.log(...this.formatArgs(args, "OperationID"));
+    }
+    logVaa(...args) {
+        this.log(...this.formatArgs(args, "VaaId"));
+    }
+    logRequest(event, maskFunction = (_, body) => body) {
+        const { httpMethod, path, queryStringParameters, body } = event;
+        this.log(httpMethod, path, { queryStringParameters, body: maskFunction(path, body) });
+    }
+    formatArgs(args, prefix = null) {
+        return args.map((value, index) => {
+            if (index === 0 && typeof value === "string" && prefix === "Pair") {
+                return `[${value}]`;
+            }
+            if (index === 0 && !!prefix) {
+                return this.prefixLabel(prefix, typeof value === "object" ? JSON.stringify(value) : value);
+            }
+            if (typeof value === "object" && process.env.LOGGING_OBJECT_INLINE !== "false") {
+                return JSON.stringify(value);
+            }
+            return value;
+        });
+    }
+    prefixLabel(prefix, value) {
+        return value ? `[${prefix}: ${value}]` : `[${prefix}]`;
+    }
+    toYellow(value) {
+        return `\x1b[33m${value}\x1b[0m`;
+    }
+    toRed(value) {
+        return `\x1b[31m${value}\x1b[0m`;
+    }
+    noColor(value) {
+        return value;
+    }
+}
+exports.Logger = Logger;
+exports["default"] = new Logger();
+
+
+/***/ }),
+
+/***/ 696:
+/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
+
+
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports.encodeMessage = encodeMessage;
+exports.generateTxnForSign = generateTxnForSign;
+exports.signTxn = signTxn;
+const algosdk_1 = __importDefault(__webpack_require__(9709));
+const Encoding_1 = __webpack_require__(8593);
+function encodeMessage(msg) {
+    return (0, Encoding_1.encodeString)(msg);
+    // removed by dead control flow
+
+    // removed by dead control flow
+
+}
+function generateTxnForSign(addr, note, encoding) {
+    return algosdk_1.default.makePaymentTxnWithSuggestedParamsFromObject({
+        from: addr,
+        to: addr,
+        amount: 0,
+        note: note && new Uint8Array(Buffer.from(note, encoding)),
+        suggestedParams: {
+            fee: 0,
+            firstRound: 1,
+            lastRound: 2,
+            genesisHash: 'SGO1GKSzyE7IEPItTxCByw9x8FmnrCDexi9/cOUJOiI=',
+            genesisID: 'testnet-v1.0',
+        },
+    });
+}
+function signTxn(activeAddress, data, encoding, signTransactions) {
+    return signTransaction(generateTxnForSign(activeAddress, data, encoding), signTransactions);
+}
+async function signTransaction(rawTxn, signTransactions) {
+    const encodedTransaction = algosdk_1.default.encodeUnsignedTransaction(rawTxn);
+    const signedTransactions = await signTransactions([encodedTransaction]);
+    const decodedTxns = algosdk_1.default.decodeSignedTransaction(signedTransactions[0]);
+    const signature = new Uint8Array(decodedTxns.sig);
+    return signature;
+}
+
+
+/***/ }),
+
+/***/ 835:
+/***/ ((__unused_webpack_module, exports) => {
+
+
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+var OrderSide;
+(function (OrderSide) {
+    OrderSide[OrderSide["Buy"] = 0] = "Buy";
+    OrderSide[OrderSide["Sell"] = 1] = "Sell";
+})(OrderSide || (OrderSide = {}));
+exports["default"] = OrderSide;
+
+
+/***/ }),
+
+/***/ 892:
+/***/ ((__unused_webpack_module, exports) => {
+
+
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports.PairComponentStatusType = exports.ComponentType = exports.ComponentStatusType = void 0;
+var ComponentStatusType;
+(function (ComponentStatusType) {
+    ComponentStatusType["ACTIVE"] = "ACTIVE";
+    ComponentStatusType["FAILED"] = "FAILED";
+    ComponentStatusType["STARTING"] = "STARTING";
+    ComponentStatusType["DRAINING"] = "DRAINING";
+    ComponentStatusType["TERMINATING"] = "TERMINATING";
+    ComponentStatusType["TERMINATED"] = "TERMINATED";
+})(ComponentStatusType || (exports.ComponentStatusType = ComponentStatusType = {}));
+var ComponentType;
+(function (ComponentType) {
+    ComponentType["MATCHING_ENGINE"] = "me";
+    ComponentType["ORDER_SERVICE"] = "ors";
+    ComponentType["API"] = "api";
+    ComponentType["SOCKET_SERVICE"] = "ws";
+    ComponentType["TRANSACTION_SERVICE"] = "tns";
+})(ComponentType || (exports.ComponentType = ComponentType = {}));
+var PairComponentStatusType;
+(function (PairComponentStatusType) {
+    PairComponentStatusType["ACTIVE"] = "ACTIVE";
+    PairComponentStatusType["FAILED"] = "FAILED";
+    PairComponentStatusType["UNASSIGNED"] = "UNASSIGNED";
+    PairComponentStatusType["ASSIGNED"] = "ASSIGNED";
+    PairComponentStatusType["STARTING"] = "STARTING";
+})(PairComponentStatusType || (exports.PairComponentStatusType = PairComponentStatusType = {}));
+
+
+/***/ }),
+
+/***/ 893:
+/***/ ((__unused_webpack_module, exports) => {
+
+
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports.NON_REPEATABLE_ACTIONS = exports.ActionEnum = exports.ActionSource = void 0;
+var ActionSource;
+(function (ActionSource) {
+    ActionSource["COMPANY"] = "COMPANY";
+    ActionSource["TWITTER"] = "TWITTER";
+    ActionSource["DISCORD"] = "DISCORD";
+    ActionSource["TELEGRAM"] = "TELEGRAM";
+})(ActionSource || (exports.ActionSource = ActionSource = {}));
+var ActionEnum;
+(function (ActionEnum) {
+    ActionEnum[ActionEnum["TWITTER_FOLLOW"] = 1] = "TWITTER_FOLLOW";
+    ActionEnum[ActionEnum["TWITTER_REPLY"] = 2] = "TWITTER_REPLY";
+    ActionEnum[ActionEnum["TWITTER_RETWEET"] = 3] = "TWITTER_RETWEET";
+    ActionEnum[ActionEnum["TWITTER_LIKE"] = 4] = "TWITTER_LIKE";
+    ActionEnum[ActionEnum["COMPANY_FIRST_LOGIN"] = 5] = "COMPANY_FIRST_LOGIN";
+    ActionEnum[ActionEnum["COMPANY_CONFIRM_EMAIL"] = 6] = "COMPANY_CONFIRM_EMAIL";
+    ActionEnum[ActionEnum["COMPANY_DEPOSIT"] = 7] = "COMPANY_DEPOSIT";
+    ActionEnum[ActionEnum["COMPANY_TRADE"] = 8] = "COMPANY_TRADE";
+    ActionEnum[ActionEnum["TELEGRAM_JOIN_GROUP"] = 9] = "TELEGRAM_JOIN_GROUP";
+    ActionEnum[ActionEnum["DISCORD_JOIN_SERVER"] = 10] = "DISCORD_JOIN_SERVER";
+    ActionEnum[ActionEnum["AFFILIATE_POINTS_REWARD"] = 11] = "AFFILIATE_POINTS_REWARD";
+})(ActionEnum || (exports.ActionEnum = ActionEnum = {}));
+exports.NON_REPEATABLE_ACTIONS = [
+    ActionEnum.TWITTER_FOLLOW,
+    ActionEnum.TELEGRAM_JOIN_GROUP,
+    ActionEnum.DISCORD_JOIN_SERVER,
+    ActionEnum.COMPANY_CONFIRM_EMAIL,
+    ActionEnum.COMPANY_FIRST_LOGIN,
+];
+
+
+/***/ }),
+
+/***/ 1048:
+/***/ ((__unused_webpack_module, exports) => {
+
+
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports.WithdrawalWalletType = void 0;
+var WithdrawalWalletType;
+(function (WithdrawalWalletType) {
+    WithdrawalWalletType["SOLANA"] = "SOLANA";
+    WithdrawalWalletType["ALGORAND"] = "ALGORAND";
+    WithdrawalWalletType["EVM"] = "EVM";
+})(WithdrawalWalletType || (exports.WithdrawalWalletType = WithdrawalWalletType = {}));
+
+
+/***/ }),
+
+/***/ 1134:
+/***/ ((__unused_webpack_module, exports) => {
+
+
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+var OrderType;
+(function (OrderType) {
+    OrderType[OrderType["Limit"] = 0] = "Limit";
+    OrderType[OrderType["IOC"] = 1] = "IOC";
+    OrderType[OrderType["POST"] = 2] = "POST";
+    OrderType[OrderType["Market"] = 3] = "Market";
+})(OrderType || (OrderType = {}));
+exports["default"] = OrderType;
+
+
+/***/ }),
+
+/***/ 1174:
+/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
+
+
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports.Operations = void 0;
+exports.absolute = absolute;
+exports.ceil = ceil;
+exports.toFixed = toFixed;
+exports.floor = floor;
+exports.round = round;
+exports.plus = plus;
+exports.minus = minus;
+exports.multiply = multiply;
+exports.toUsd = toUsd;
+exports.divide = divide;
+exports.greaterThanOrEqual = greaterThanOrEqual;
+exports.greaterThan = greaterThan;
+exports.lessThanOrEqual = lessThanOrEqual;
+exports.lessThan = lessThan;
+exports.equal = equal;
+exports.mod = mod;
+exports.modZero = modZero;
+exports.bn_operation = bn_operation;
+exports.roundNumber = roundNumber;
+exports.convertFromBaseUnits = convertFromBaseUnits;
+exports.convertToBaseUnits = convertToBaseUnits;
+const bignumber_js_1 = __importDefault(__webpack_require__(6168));
+bignumber_js_1.default.config({ DECIMAL_PLACES: 40, EXPONENTIAL_AT: 45 });
+var Operations;
+(function (Operations) {
+    Operations["MINUS"] = "-";
+    Operations["PLUS"] = "+";
+    Operations["MULTIPLY"] = "*";
+    Operations["DIVIDE"] = "/";
+    Operations["GREATER_THAN_OR_EQUAL"] = ">=";
+    Operations["GREATER_THAN"] = ">";
+    Operations["LESS_THAN_OR_EQUAL"] = "<=";
+    Operations["LESS_THAN"] = "<";
+    Operations["EQUAL"] = "==";
+    Operations["MOD"] = "mod";
+})(Operations || (exports.Operations = Operations = {}));
+function absolute(value) {
+    let x = new bignumber_js_1.default(value);
+    const res = x.abs().toString();
+    // console.log('Absolute value', { value, res })
+    return res;
+}
+function ceil(value) {
+    let x = new bignumber_js_1.default(String(value));
+    const res = x.integerValue(bignumber_js_1.default.ROUND_CEIL).toString();
+    if (!equal(value, res)) {
+        console.log('Ceil value', { value, res });
+    }
+    return res;
+}
+function toFixed(value, decimalPlaces, roundUpToFirstSignificant = false) {
+    const x = new bignumber_js_1.default(String(value));
+    let res;
+    if (roundUpToFirstSignificant) {
+        const valueStr = x.toFixed();
+        const decimalIndex = valueStr.indexOf('.');
+        if (decimalIndex >= 0) {
+            const fractionalPart = valueStr.slice(decimalIndex + 1);
+            let leadingZeros = 0;
+            for (let char of fractionalPart) {
+                if (char === '0') {
+                    leadingZeros++;
+                }
+                else {
+                    break;
+                }
+            }
+            const totalDecimalPlaces = leadingZeros + 1;
+            res = x.toFixed(totalDecimalPlaces, bignumber_js_1.default.ROUND_UP);
+        }
+        else {
+            res = x.toFixed(0);
+        }
+    }
+    else {
+        res = x.toFixed(decimalPlaces);
+    }
+    console.log('Fixed value', { value, res });
+    return res;
+}
+function floor(value) {
+    let x = new bignumber_js_1.default(String(value));
+    const res = x.integerValue(bignumber_js_1.default.ROUND_FLOOR).toString();
+    console.log('Floor value', { value, res });
+    return res;
+}
+function round(value) {
+    let x = new bignumber_js_1.default(String(value));
+    const res = x.integerValue(bignumber_js_1.default.ROUND_HALF_UP).toString();
+    console.log('Round value', { value, res });
+    return res;
+}
+function plus(value1, value2) {
+    return bn_operation(value1, value2, Operations.PLUS);
+}
+function minus(value1, value2) {
+    return bn_operation(value1, value2, Operations.MINUS);
+}
+function multiply(value1, value2) {
+    return bn_operation(value1, value2, Operations.MULTIPLY);
+}
+function toUsd(amount, price) {
+    return multiply(amount, price || 0);
+}
+;
+function divide(value1, value2) {
+    return bn_operation(value1, value2, Operations.DIVIDE);
+}
+function greaterThanOrEqual(value1, value2) {
+    return Boolean(bn_operation(value1, value2, Operations.GREATER_THAN_OR_EQUAL));
+}
+function greaterThan(value1, value2) {
+    return Boolean(bn_operation(value1, value2, Operations.GREATER_THAN));
+}
+function lessThanOrEqual(value1, value2) {
+    return Boolean(bn_operation(value1, value2, Operations.LESS_THAN_OR_EQUAL));
+}
+function lessThan(value1, value2) {
+    return Boolean(bn_operation(value1, value2, Operations.LESS_THAN));
+}
+function equal(value1, value2) {
+    return Boolean(bn_operation(value1, value2, Operations.EQUAL));
+}
+function mod(value1, value2) {
+    return bn_operation(value1, value2, Operations.MOD);
+}
+function modZero(value1, value2) {
+    return equal(mod(value1, value2), 0);
+}
+function bn_operation(a, b, operation) {
+    a = new bignumber_js_1.default(String(a));
+    b = new bignumber_js_1.default(String(b));
+    switch (operation.toLowerCase()) {
+        case '-':
+            return a.minus(b).toString();
+        case '+':
+            return a.plus(b).toString();
+        case '*':
+        case 'x':
+            return a.multipliedBy(b).toString();
+        case '÷':
+        case '/':
+            return a.dividedBy(b).toString();
+        case '>=':
+            return a.isGreaterThanOrEqualTo(b);
+        case '>':
+            return a.isGreaterThan(b);
+        case '<=':
+            return a.isLessThanOrEqualTo(b);
+        case '<':
+            return a.isLessThan(b);
+        case '==':
+            return a.isEqualTo(b);
+        case 'mod':
+            return a.modulo(b);
+        default:
+            break;
+    }
+}
+function getExponentialNumberComponents(x) {
+    if (x.toString().includes('e')) {
+        const parts = x.toString().split('e');
+        return [parseFloat(parts[0]), parseFloat(parts[1])];
+    }
+    return [x, 0];
+}
+function generateExponentialNumberFromComponents(decimalPart, exponent) {
+    return decimalPart + (exponent < 0 ? `e${exponent}` : `e+${exponent}`);
+}
+function roundNumber({ decimalPlaces = 0 }, x) {
+    if (decimalPlaces > 0) {
+        const [decimal, decimalExponentialPart] = getExponentialNumberComponents(x);
+        const [rounded, roundedExponentialPart] = getExponentialNumberComponents(Math.round(Number(generateExponentialNumberFromComponents(decimal, decimalExponentialPart + decimalPlaces))));
+        return Number(generateExponentialNumberFromComponents(rounded, roundedExponentialPart - decimalPlaces));
+    }
+    return Math.round(x);
+}
+function convertFromBaseUnits(assetDecimals, quantity) {
+    const decimals = Number(assetDecimals);
+    return roundNumber({ decimalPlaces: decimals }, 
+    // eslint-disable-next-line no-magic-numbers
+    Math.pow(10, -decimals) * Number(quantity));
+}
+/**
+ * Computs quantity * 10^(assetDecimals) and rounds the result
+ */
+function convertToBaseUnits(assetDecimals, quantity) {
+    // eslint-disable-next-line no-magic-numbers
+    const baseAmount = Math.pow(10, Number(assetDecimals)) * Number(quantity);
+    // make sure the final value is an integer. This prevents this kind of computation errors: 0.0012 * 100000 = 119.99999999999999 and rounds this result into 120
+    return roundNumber({ decimalPlaces: 0 }, baseAmount);
+}
+
+
+/***/ }),
+
+/***/ 1283:
+/***/ ((__unused_webpack_module, exports) => {
+
+
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports.StateType = void 0;
+var StateType;
+(function (StateType) {
+    StateType["VERSION"] = "version";
+    StateType["LAST_ALGO_BLOCK"] = "last_algo_block";
+    StateType["PRICES_PROVIDER_API_KEY"] = "prices_provider_api_key";
+    StateType["DEFAULT_API_DOMAIN"] = "default_api_domain";
+    StateType["NONCE_ACCOUNTS_SOLANA"] = "nonce_accounts_solana";
+    StateType["ARCHIVE_DATA_BATCH_SIZE"] = "archive_data_batch_size";
+    StateType["ARCHIVE_TASK_LOCK"] = "archive_task_lock";
+})(StateType || (exports.StateType = StateType = {}));
+
+
+/***/ }),
+
+/***/ 1492:
+/***/ ((__unused_webpack_module, exports) => {
+
+
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+var OrderStatus;
+(function (OrderStatus) {
+    OrderStatus[OrderStatus["Open"] = 1] = "Open";
+    OrderStatus[OrderStatus["Canceled"] = 2] = "Canceled";
+    OrderStatus[OrderStatus["Matched"] = 3] = "Matched";
+    OrderStatus[OrderStatus["SelfMatched"] = 4] = "SelfMatched";
+    OrderStatus[OrderStatus["Expired"] = 5] = "Expired";
+})(OrderStatus || (OrderStatus = {}));
+exports["default"] = OrderStatus;
+
+
+/***/ }),
+
+/***/ 1682:
+/***/ ((__unused_webpack_module, exports) => {
+
+
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports.SettingTypeColumn = void 0;
+var SettingTypeColumn;
+(function (SettingTypeColumn) {
+    SettingTypeColumn["STRING"] = "string";
+    SettingTypeColumn["BOOLEAN"] = "boolean";
+    SettingTypeColumn["INT"] = "int";
+    SettingTypeColumn["FLOAT"] = "float";
+    SettingTypeColumn["SINGLE_CHOICE"] = "single-choice";
+    SettingTypeColumn["MULTI_CHOICE"] = "multi-choice";
+})(SettingTypeColumn || (exports.SettingTypeColumn = SettingTypeColumn = {}));
+
+
+/***/ }),
+
+/***/ 1708:
+/***/ ((module) => {
+
+module.exports = require("node:process");
+
+/***/ }),
+
+/***/ 2137:
+/***/ ((__unused_webpack_module, exports) => {
+
+
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports.mapToCodexBalanceDto = mapToCodexBalanceDto;
+function mapToCodexBalanceDto(o) {
+    return {
+        hash: o.hash,
+        loginAddress: o.loginAddress,
+        loginChainId: o.loginChainId,
+        tokenId: o.token?.id,
+        tokenAddress: o.tokenId,
+        tokenChainId: o.tokenChainId,
+        amount: o.amount,
+        lockedAmount: o.lockedAmount
+    };
+}
+
+
+/***/ }),
+
+/***/ 2216:
+/***/ ((module) => {
+
+module.exports = __WEBPACK_EXTERNAL_MODULE__2216__;
+
+/***/ }),
+
+/***/ 2224:
+/***/ ((__unused_webpack_module, exports) => {
+
+
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports.AffiliateSortByEnum = void 0;
+var AffiliateSortByEnum;
+(function (AffiliateSortByEnum) {
+    AffiliateSortByEnum["INVITED_ACCOUNTS_COUNT"] = "invitedAccountsCount";
+    AffiliateSortByEnum["CREATED_AT"] = "createdAt";
+    AffiliateSortByEnum["FEE_SHARE"] = "feeShare";
+    AffiliateSortByEnum["ADDRESS"] = "address";
+    AffiliateSortByEnum["REFERRAL_TRADING_VOLUME"] = "referralTradingVolume";
+})(AffiliateSortByEnum || (exports.AffiliateSortByEnum = AffiliateSortByEnum = {}));
+
+
+/***/ }),
+
+/***/ 2228:
+/***/ ((__unused_webpack_module, exports) => {
+
+
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports.HTTPSRPC_MAINNET = exports.HTTPSRPC_TESTNET = exports.ChainNames = exports.Chains = void 0;
+var Chains;
+(function (Chains) {
+    Chains[Chains["Solana"] = 1] = "Solana";
+    Chains[Chains["Algorand"] = 8] = "Algorand";
+    Chains[Chains["Polygon"] = 5] = "Polygon";
+    Chains[Chains["Bsc"] = 4] = "Bsc";
+    Chains[Chains["Avalanche"] = 6] = "Avalanche";
+    Chains[Chains["Arbitrum"] = 23] = "Arbitrum";
+    Chains[Chains["Optimism"] = 24] = "Optimism";
+    Chains[Chains["Base"] = 30] = "Base";
+    Chains[Chains["Ethereum"] = 2] = "Ethereum";
+    Chains[Chains["Sepolia"] = 10002] = "Sepolia";
+    Chains[Chains["ArbitrumSepolia"] = 10003] = "ArbitrumSepolia";
+    Chains[Chains["BaseSepolia"] = 10004] = "BaseSepolia";
+    Chains[Chains["OptimismSepolia"] = 10005] = "OptimismSepolia";
+    Chains[Chains["PolygonAmoy"] = 10007] = "PolygonAmoy";
+})(Chains || (exports.Chains = Chains = {}));
+exports.ChainNames = {
+    [Chains.Solana]: "Solana",
+    [Chains.Ethereum]: "Ethereum",
+    [Chains.Polygon]: "Polygon",
+    [Chains.Bsc]: "BNB Chain",
+    [Chains.Avalanche]: "Avalanche",
+    [Chains.Algorand]: "Algorand",
+    [Chains.Arbitrum]: "Arbitrum",
+    [Chains.Optimism]: "Optimism",
+    [Chains.Base]: "Base",
+    [Chains.Sepolia]: "Ethereum Sepolia",
+    [Chains.ArbitrumSepolia]: "Arbitrum Sepolia",
+    [Chains.BaseSepolia]: "Base Sepolia",
+    [Chains.OptimismSepolia]: "Optimism Sepolia",
+    [Chains.PolygonAmoy]: "Polygon Amoy",
+};
+exports.HTTPSRPC_TESTNET = {
+    [Chains.Bsc]: [
+        '',
+        'https://bsc-testnet.public.blastapi.io',
+        'https://bsc-testnet.blockpi.network/v1/rpc/private',
+        'https://bsc-testnet-rpc.publicnode.com',
+        'https://api.zan.top/bsc-testnet',
+        'https://data-seed-prebsc-2-s1.bnbchain.org:8545',
+        'https://data-seed-prebsc-2-s2.bnbchain.org:8545',
+        'https://data-seed-prebsc-2-s3.bnbchain.org:8545',
+        'https://data-seed-prebsc-1-s1.bnbchain.org:8545',
+        'https://data-seed-prebsc-1-s2.bnbchain.org:8545',
+        'https://data-seed-prebsc-1-s3.bnbchain.org:8545',
+        'https://endpoints.omniatech.io/v1/bsc/testnet/public',
+    ],
+    [Chains.Avalanche]: [
+        '',
+        'https://rpc.ankr.com/avalanche_fuji',
+        'https://rpc.ankr.com/avalanche_fuji-c',
+        'https://api.avax-test.network/ext/bc/C/rpc',
+        'https://ava-testnet.public.blastapi.io/ext/bc/C/rpc',
+        'https://endpoints.omniatech.io/v1/avax/fuji/public',
+        'https://avalanche-fuji.blockpi.network/v1/rpc/private',
+        'https://avalanche-fuji-c-chain-rpc.publicnode.com',
+        'https://avalanche-fuji.blockpi.network/v1/rpc/private',
+    ],
+    [Chains.Sepolia]: [
+        'https://ethereum-sepolia-rpc.publicnode.com',
+        'https://sepolia.gateway.tenderly.co',
+        'https://eth-sepolia.public.blastapi.io',
+        'https://ethereum-sepolia.blockpi.network/v1/rpc/private',
+        'https://sepolia.drpc.org',
+        'https://endpoints.omniatech.io/v1/eth/sepolia/public',
+        'https://1rpc.io/sepolia',
+        'https://gateway.tenderly.co/public/sepolia',
+        'https://sepolia.gateway.tenderly.co',
+        'https://api.zan.top/eth-sepolia',
+        'https://ethereum-sepolia.rpc.subquery.network/public',
+    ],
+    [Chains.ArbitrumSepolia]: [
+        '',
+        'https://arbitrum-sepolia.blockpi.network/v1/rpc/private ',
+        'https://arbitrum-sepolia.gateway.tenderly.co',
+        'https://endpoints.omniatech.io/v1/arbitrum/sepolia/public',
+        'https://api.zan.top/arb-sepolia',
+        'https://sepolia-rollup.arbitrum.io/rpc',
+    ],
+    [Chains.BaseSepolia]: [
+        '',
+        'https://sepolia.base.org',
+        'https://base-sepolia-rpc.publicnode.com',
+        'https://base-sepolia.gateway.tenderly.co',
+        'https://base-sepolia.blockpi.network/v1/rpc/private',
+        'https://node.histori.xyz/base-sepolia/8ry9f6t9dct1se2hlagxnd9n2a',
+    ],
+    [Chains.OptimismSepolia]: [
+        '',
+        'https://optimism-sepolia.blockpi.network/v1/rpc/private',
+        'https://sepolia.optimism.io',
+        'https://api.zan.top/opt-sepolia',
+        'https://optimism-sepolia.gateway.tenderly.co',
+        'https://optimism-sepolia.drpc.org',
+        'https://endpoints.omniatech.io/v1/op/sepolia/public',
+    ],
+    [Chains.PolygonAmoy]: [
+        'https://rpc-amoy.polygon.technology',
+        'https://polygon-amoy-bor-rpc.publicnode.com',
+        'https://rpc.ankr.com/polygon_amoy',
+        'https://polygon-amoy.drpc.org',
+        'https://api.zan.top/polygon-amoy',
+        'https://polygon-amoy.gateway.tenderly.co',
+    ],
+};
+exports.HTTPSRPC_MAINNET = {
+    [Chains.Ethereum]: [
+        '',
+        'https://eth.llamarpc.com',
+        'https://ethereum.blockpi.network/v1/rpc/public',
+        'https://eth-mainnet.nodereal.io/v1/1659dfb40aa24bbb8153a677b98064d7',
+        'https://uk.rpc.blxrbdn.com',
+        'https://singapore.rpc.blxrbdn.com',
+        'https://virginia.rpc.blxrbdn.com',
+        'https://eth-mainnet.public.blastapi.io',
+        'https://api.securerpc.com/v1',
+        'https://mainnet.gateway.tenderly.co',
+        'https://eth-pokt.nodies.app',
+        'https://eth.blockrazor.xyz',
+        'https://eth.merkle.io',
+        'https://gateway.tenderly.co/public/mainnet',
+        'https://eth.rpc.blxrbdn.com',
+    ],
+    [Chains.Bsc]: [
+        '',
+        'https://bsc.blockrazor.xyz',
+        'https://bscrpc.com',
+        'https://bsc-mainnet.public.blastapi.io',
+        'https://binance.llamarpc.com',
+        'https://go.getblock.io/cc778cdbdf5c4b028ec9456e0e6c0cf3',
+        'https://bsc-pokt.nodies.app',
+        'https://56.rpc.thirdweb.com',
+        'https://bsc.blockpi.network/v1/rpc/private',
+        'https://bsc.rpc.blxrbdn.com',
+        'https://bsc-dataseed.bnbchain.org',
+        'https://endpoints.omniatech.io/v1/bsc/mainnet/public',
+        'https://bsc-dataseed1.ninicoin.io',
+        'https://bsc-dataseed2.defibit.io',
+        'https://bsc-dataseed2.ninicoin.io',
+        'https://0.48.club',
+        'https://bsc-dataseed3.defibit.io',
+    ],
+    [Chains.Polygon]: [
+        '',
+        'https://polygon.llamarpc.com',
+        'https://polygon-rpc.com',
+        'https://rpc-mainnet.matic.quiknode.pro',
+        'https://endpoints.omniatech.io/v1/matic/mainnet/public',
+        'https://polygon-pokt.nodies.app',
+        'https://polygon-bor-rpc.publicnode.com',
+        'https://polygon.rpc.subquery.network/public',
+        'https://polygon-bor-rpc.publicnode.com',
+        'https://polygon.blockpi.network/v1/rpc/private',
+        'https://polygon.api.onfinality.io/public',
+        'https://polygon.lava.build',
+        'https://api.zan.top/polygon-mainnet',
+        'https://polygon.meowrpc.com',
+    ],
+    [Chains.Avalanche]: [
+        '',
+        'https://avalanche-c-chain-rpc.publicnode.com',
+        'https://ava-mainnet.public.blastapi.io/ext/bc/C/rpc',
+        'https://endpoints.omniatech.io/v1/avax/mainnet/public',
+        'https://avalanche-c-chain-rpc.publicnode.com',
+        'https://avalanche.blockpi.network/v1/rpc/private',
+        'https://avalanche.public-rpc.com',
+        'https://avalanche.drpc.org',
+        'https://avax.meowrpc.com',
+        'https://endpoints.omniatech.io/v1/avax/mainnet/public',
+        'https://api.avax.network/ext/bc/C/rpc',
+        'https://1rpc.io/avax/c',
+        'https://avax-pokt.nodies.app/ext/bc/C/rpc',
+        'https://endpoints.omniatech.io/v1/avax/mainnet/public',
+        'https://api.zan.top/avax-mainnet/ext/bc/C/rpc',
+    ],
+    [Chains.Arbitrum]: [
+        '',
+        'https://arbitrum.llamarpc.com',
+        'https://arbitrum.rpc.subquery.network/public',
+        'https://endpoints.omniatech.io/v1/arbitrum/one/public',
+        'https://arbitrum.meowrpc.com',
+        'https://arbitrum.gateway.tenderly.co',
+        'https://arbitrum-one.public.blastapi.io',
+        'https://arb1.lava.build',
+        'https://arbitrum-one.publicnode.com',
+        'https://arbitrum.blockpi.network/v1/rpc/public',
+        'https://arb-pokt.nodies.app',
+        'https://api.zan.top/arb-one',
+        'https://arb1.arbitrum.io/rpc',
+        'https://arbitrum.drpc.org',
+        'https://1rpc.io/arb',
+    ],
+    [Chains.Optimism]: [
+        '',
+        'https://optimism.llamarpc.com',
+        'https://op-pokt.nodies.app',
+        'https://optimism-mainnet.public.blastapi.io',
+        'https://optimism.blockpi.network/v1/rpc/public',
+        'https://endpoints.omniatech.io/v1/op/mainnet/public',
+        'https://optimism-rpc.publicnode.com',
+        'https://optimism.drpc.org',
+        'https://1rpc.io/op',
+        'https://optimism.gateway.tenderly.co',
+        'https://optimism.lava.build',
+        'https://optimism.rpc.subquery.network/public',
+        'https://mainnet.optimism.io',
+        'https://optimism-rpc.publicnode.com',
+        'https://gateway.tenderly.co/public/optimism',
+    ],
+    [Chains.Base]: [
+        '',
+        'https://base.llamarpc.com',
+        'https://base-mainnet.public.blastapi.io',
+        'https://base-rpc.publicnode.com',
+        'https://base.blockpi.network/v1/rpc/public',
+        'https://base.drpc.org',
+        'https://mainnet.base.org',
+        'https://base.api.onfinality.io/public',
+        'https://base-pokt.nodies.app',
+        'https://1rpc.io/base',
+        'https://developer-access-mainnet.base.org',
+        'https://endpoints.omniatech.io/v1/base/mainnet/public',
+        'https://base.rpc.subquery.network/public',
+        'https://base.api.onfinality.io/public',
+        'https://base.meowrpc.com',
+        'https://base.gateway.tenderly.co',
+    ],
+};
+
+
+/***/ }),
+
+/***/ 2623:
+/***/ ((__unused_webpack_module, exports) => {
+
+
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports.TransactionType = exports.CCTPStatus = exports.ActionTypeEnum = exports.OperationStatusEnum = void 0;
+var OperationStatusEnum;
+(function (OperationStatusEnum) {
+    OperationStatusEnum["Pending"] = "pending";
+    OperationStatusEnum["Completed"] = "completed";
+    OperationStatusEnum["Failed"] = "failed";
+    OperationStatusEnum["Received"] = "received";
+})(OperationStatusEnum || (exports.OperationStatusEnum = OperationStatusEnum = {}));
+var ActionTypeEnum;
+(function (ActionTypeEnum) {
+    ActionTypeEnum["Deposit"] = "deposit";
+    ActionTypeEnum["Withdraw"] = "withdraw";
+    ActionTypeEnum["Rebalance"] = "rebalance";
+})(ActionTypeEnum || (exports.ActionTypeEnum = ActionTypeEnum = {}));
+var CCTPStatus;
+(function (CCTPStatus) {
+    CCTPStatus["PENDING"] = "pending";
+    CCTPStatus["COMPLETED"] = "completed";
+    CCTPStatus["FAILED"] = "failed";
+})(CCTPStatus || (exports.CCTPStatus = CCTPStatus = {}));
+var TransactionType;
+(function (TransactionType) {
+    TransactionType["USER_TO_TMC"] = "user_to_tmc";
+    TransactionType["TMC_TO_USER"] = "tmc_to_user";
+    TransactionType["RELAYER_TO_TMC"] = "relayer_to_tmc";
+    TransactionType["RELAYER_TO_CODEX"] = "relayer_to_codex";
+    TransactionType["RELAYER_TO_CIRCLE"] = "relayer_to_circle";
+})(TransactionType || (exports.TransactionType = TransactionType = {}));
+
+
+/***/ }),
+
+/***/ 2739:
+/***/ ((__unused_webpack_module, exports) => {
+
+
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports.Notification = void 0;
+var Notification;
+(function (Notification) {
+    Notification[Notification["SELF_TRADE"] = 1] = "SELF_TRADE";
+    Notification[Notification["FULL_FILLED"] = 2] = "FULL_FILLED";
+    Notification[Notification["FULL_CANCELLED"] = 3] = "FULL_CANCELLED";
+    Notification[Notification["PARTIALLY_CANCELLED"] = 4] = "PARTIALLY_CANCELLED";
+    Notification[Notification["CREATED"] = 5] = "CREATED";
+})(Notification || (exports.Notification = Notification = {}));
+
+
+/***/ }),
+
+/***/ 2797:
+/***/ ((__unused_webpack_module, exports) => {
+
+
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+var AvailablePairSettings;
+(function (AvailablePairSettings) {
+    AvailablePairSettings["MFT_AUDIO_LINK"] = "mft.audioLink";
+    AvailablePairSettings["MFT_TITLE"] = "mft.title";
+    AvailablePairSettings["MODE_PRE_SALE"] = "mode.preSale";
+    AvailablePairSettings["MAKER_FEE"] = "makerFee";
+    AvailablePairSettings["TAKER_FEE"] = "takerFee";
+    AvailablePairSettings["VIEW_BASE_COIN_ICON_LINK"] = "view.baseCoinIconLink";
+    AvailablePairSettings["VIEW_BASE_COIN_MARKET_LINK"] = "view.baseCoinMarketLink";
+    AvailablePairSettings["VIEW_PRICE_COIN_ICON_LINK"] = "view.priceCoinIconLink";
+    AvailablePairSettings["VIEW_PRICE_COIN_MARKET_LINK"] = "view.priceCoinMarketLink";
+})(AvailablePairSettings || (AvailablePairSettings = {}));
+exports["default"] = AvailablePairSettings;
+
+
+/***/ }),
+
+/***/ 3004:
+/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
+
+
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports.TradingKeyType = exports.OrderType = exports.OrderStatus = exports.OrderSide = exports.AvailablePairSettings = void 0;
+const available_pair_settings_enum_1 = __importDefault(__webpack_require__(2797));
+exports.AvailablePairSettings = available_pair_settings_enum_1.default;
+const order_side_enum_1 = __importDefault(__webpack_require__(835));
+exports.OrderSide = order_side_enum_1.default;
+const order_status_enum_1 = __importDefault(__webpack_require__(1492));
+exports.OrderStatus = order_status_enum_1.default;
+const order_type_enum_1 = __importDefault(__webpack_require__(1134));
+exports.OrderType = order_type_enum_1.default;
+const tradingKeyType_enum_1 = __webpack_require__(3487);
+Object.defineProperty(exports, "TradingKeyType", ({ enumerable: true, get: function () { return tradingKeyType_enum_1.TradingKeyType; } }));
+__exportStar(__webpack_require__(893), exports);
+__exportStar(__webpack_require__(3338), exports);
+__exportStar(__webpack_require__(3245), exports);
+__exportStar(__webpack_require__(6828), exports);
+__exportStar(__webpack_require__(2224), exports);
+__exportStar(__webpack_require__(892), exports);
+__exportStar(__webpack_require__(2623), exports);
+__exportStar(__webpack_require__(3854), exports);
+__exportStar(__webpack_require__(4132), exports);
+__exportStar(__webpack_require__(3516), exports);
+__exportStar(__webpack_require__(4199), exports);
+__exportStar(__webpack_require__(1682), exports);
+__exportStar(__webpack_require__(1283), exports);
+__exportStar(__webpack_require__(5237), exports);
+__exportStar(__webpack_require__(1048), exports);
+
+
+/***/ }),
+
+/***/ 3245:
+/***/ ((__unused_webpack_module, exports) => {
+
+
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports.PromptTypeEnum = void 0;
+var PromptTypeEnum;
+(function (PromptTypeEnum) {
+    PromptTypeEnum["INSTRUCTIONS"] = "INSTRUCTIONS";
+    PromptTypeEnum["TEXT_STYLE"] = "TEXT_STYLE";
+    PromptTypeEnum["TEXT_TONE"] = "TEXT_TONE";
+    PromptTypeEnum["REACTION_TYPE"] = "REACTION_TYPE";
+    PromptTypeEnum["COMMENT_LENGTH"] = "COMMENT_LENGTH";
+    PromptTypeEnum["CONTEXT"] = "CONTEXT";
+})(PromptTypeEnum || (exports.PromptTypeEnum = PromptTypeEnum = {}));
+
+
+/***/ }),
+
+/***/ 3298:
+/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
+
+
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+const client_secrets_manager_1 = __webpack_require__(2216);
+class SecretHelper {
+    constructor() {
+        this.creatorMnemonicSecretName = process.env.CreatorSecret;
+        this.dispenserMnemonicSecretName = process.env.DispenserSecret;
+        this.transactionMnemonicSecretName = process.env.TransactionSecret;
+        this.relayerMnemonicSecretName = process.env.RelayerSecret;
+        this.ondatoCredentialsSecretName = process.env.OndatoSecret;
+    }
+    async getCreatorMnemonic() {
+        const creatorMnemonic = await this.getSecrets(this.creatorMnemonicSecretName);
+        return JSON.parse(creatorMnemonic).creator;
+    }
+    async getDispenserMnemonic() {
+        const dispenserMnemonic = await this.getSecrets(this.dispenserMnemonicSecretName);
+        return JSON.parse(dispenserMnemonic).dispenser;
+    }
+    async getTransactionMnemonic() {
+        const transactionMnemonic = await this.getSecrets(this.transactionMnemonicSecretName);
+        return JSON.parse(transactionMnemonic).txs;
+    }
+    async getRelayerMnemonics() {
+        const relayerMnemonic = await this.getSecrets(this.relayerMnemonicSecretName);
+        return JSON.parse(relayerMnemonic);
+    }
+    async getOndatoSecrets() {
+        const ondatoSecrets = await this.getSecrets(this.ondatoCredentialsSecretName);
+        return JSON.parse(ondatoSecrets);
+    }
+    getClient() {
+        return new client_secrets_manager_1.SecretsManager({ region: 'us-east-1' });
+    }
+    getSecrets(secretName) {
+        // console.log(`Getting secrets by name: ${secretName}`);
+        return new Promise((resolve, reject) => {
+            try {
+                const command = new client_secrets_manager_1.GetSecretValueCommand({ SecretId: secretName });
+                const client = this.getClient();
+                client.send(command, (err, data) => {
+                    if (err) {
+                        console.log('-----error in secrets---------', err);
+                        reject(err);
+                    }
+                    else {
+                        // console.log('secrets successfully received');
+                        resolve(data.SecretString);
+                    }
+                });
+            }
+            catch (error) {
+                console.log('error curl', error);
+                reject(error);
+            }
+        });
+    }
+    saveSecret(secretName, secretValue) {
+        console.log(`Saving secret with name: ${secretName}`);
+        return new Promise((resolve, reject) => {
+            try {
+                const command = new client_secrets_manager_1.PutSecretValueCommand({
+                    SecretId: secretName,
+                    SecretString: secretValue,
+                });
+                const client = this.getClient();
+                client.send(command, (err, data) => {
+                    if (err) {
+                        console.log('-----error in saving secret---------', err);
+                        reject(err);
+                    }
+                    else {
+                        console.log('secret successfully saved');
+                        resolve();
+                    }
+                });
+            }
+            catch (error) {
+                console.log('error curl', error);
+                reject(error);
+            }
+        });
+    }
+}
+exports["default"] = new SecretHelper();
+
+
+/***/ }),
+
+/***/ 3338:
+/***/ ((__unused_webpack_module, exports) => {
+
+
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports.TweetType = exports.SeasonStatusEnum = void 0;
+var SeasonStatusEnum;
+(function (SeasonStatusEnum) {
+    SeasonStatusEnum["CREATED"] = "created";
+    SeasonStatusEnum["STARTED"] = "started";
+    SeasonStatusEnum["PAUSED"] = "paused";
+    SeasonStatusEnum["CLOSED"] = "closed";
+})(SeasonStatusEnum || (exports.SeasonStatusEnum = SeasonStatusEnum = {}));
+var TweetType;
+(function (TweetType) {
+    TweetType["Post"] = "POST";
+    TweetType["Comment"] = "COMMENT";
+})(TweetType || (exports.TweetType = TweetType = {}));
+
+
+/***/ }),
+
+/***/ 3450:
+/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
+
+
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports.printUnpackedLocalData = exports.getAccounInfoFormLocalStorage = void 0;
+exports.unpackData = unpackData;
+exports.decodeString = decodeString;
+const algosdk_1 = __importStar(__webpack_require__(9709));
+const orderByteSize = 28;
+const getAccounInfoFormLocalStorage = (localState) => {
+    const uintArray = Buffer.from(localState, 'base64');
+    const unpackedData = unpackData(uintArray, {
+        "priceCoin_locked": {
+            type: "uint",
+        },
+        "priceCoin_available": {
+            type: "uint",
+        },
+        "baseCoin_locked": {
+            type: "uint",
+        },
+        "baseCoin_available": {
+            type: "uint",
+        },
+        "companyId": {
+            type: "uint",
+        },
+        "WLFeeShare": {
+            type: "uint",
+        },
+        "WLCustomFee": {
+            type: "uint",
+        },
+        "slotMap": {
+            type: "uint",
+        },
+    });
+    return unpackedData;
+};
+exports.getAccounInfoFormLocalStorage = getAccounInfoFormLocalStorage;
+function unpackData(data, format) {
+    const result = new Map();
+    let index = 0;
+    for (const [name, type] of Object.entries(format)) {
+        if (index >= data.length) {
+            throw new Error('Array index out of bounds');
+        }
+        let value;
+        switch (type.type) {
+            case 'address':
+                value = (0, algosdk_1.encodeAddress)(data.slice(index, index + 32));
+                index += 32;
+                break;
+            case 'bytes':
+                value = data.slice(index, index + type.size);
+                value = algosdk_1.default.decodeUint64(value, "mixed");
+                index += type.size;
+                break;
+            case 'uint':
+                value = algosdk_1.default.decodeUint64(data.slice(index, index + 8), "mixed");
+                index += 8;
+                break;
+            case 'string':
+                value = decodeString(data.slice(index, index + type.size));
+                index += type.size;
+                break;
+        }
+        result.set(name, value);
+    }
+    return Object.fromEntries(result);
+}
+function decodeString(value) {
+    return Buffer.from(value).toString('utf-8');
+}
+const printUnpackedLocalData = (localState) => {
+    const uintArray = Buffer.from(localState, 'base64');
+    const unpackedData = [];
+    for (let i = 0; i < 4; i++) {
+        let data = unpackData(uintArray.subarray(orderByteSize * i, orderByteSize * (i + 1)), {
+            "orderID": {
+                type: "uint",
+            },
+            "side": {
+                type: "string",
+                size: 1
+            },
+            "price": {
+                type: "uint",
+            },
+            "amount": {
+                type: "uint",
+            },
+            "type": {
+                type: "string",
+                size: 1
+            },
+            "directSettle": {
+                type: "string",
+                size: 1
+            },
+            "storageSlot": {
+                type: "bytes",
+                size: 1
+            }
+        });
+        unpackedData.push(data);
+    }
+    return unpackedData;
+};
+exports.printUnpackedLocalData = printUnpackedLocalData;
+
+
+/***/ }),
+
+/***/ 3487:
+/***/ ((__unused_webpack_module, exports) => {
+
+
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports.TradingKeyType = void 0;
+var TradingKeyType;
+(function (TradingKeyType) {
+    TradingKeyType["User"] = "User";
+    TradingKeyType["Api"] = "API";
+})(TradingKeyType || (exports.TradingKeyType = TradingKeyType = {}));
+
+
+/***/ }),
+
+/***/ 3516:
+/***/ ((__unused_webpack_module, exports) => {
+
+
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports.SortDirectionEnum = void 0;
+var SortDirectionEnum;
+(function (SortDirectionEnum) {
+    SortDirectionEnum["ASCENDING"] = "ASC";
+    SortDirectionEnum["DESCENDING"] = "DESC";
+})(SortDirectionEnum || (exports.SortDirectionEnum = SortDirectionEnum = {}));
+
+
+/***/ }),
+
+/***/ 3528:
+/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
+
+
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+__exportStar(__webpack_require__(9321), exports);
+__exportStar(__webpack_require__(8398), exports);
+__exportStar(__webpack_require__(696), exports);
+__exportStar(__webpack_require__(8980), exports);
+__exportStar(__webpack_require__(1174), exports);
+__exportStar(__webpack_require__(7413), exports);
+__exportStar(__webpack_require__(298), exports);
+__exportStar(__webpack_require__(7639), exports);
+__exportStar(__webpack_require__(5281), exports);
+__exportStar(__webpack_require__(3298), exports);
+__exportStar(__webpack_require__(180), exports);
+
+
+/***/ }),
+
+/***/ 3854:
+/***/ ((__unused_webpack_module, exports) => {
+
+
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports.TradeSubStatus = exports.TradeStatus = void 0;
+var TradeStatus;
+(function (TradeStatus) {
+    TradeStatus["Unconfirmed"] = "UNCONFIRMED";
+    TradeStatus["Confirmed"] = "CONFIRMED";
+    TradeStatus["Rejected"] = "REJECTED";
+})(TradeStatus || (exports.TradeStatus = TradeStatus = {}));
+var TradeSubStatus;
+(function (TradeSubStatus) {
+    TradeSubStatus["RESUBMITTED"] = "RESUBMITTED";
+    TradeSubStatus["PROCESSED"] = "PROCESSED";
+    TradeSubStatus["REMATCHED"] = "REMATCHED";
+})(TradeSubStatus || (exports.TradeSubStatus = TradeSubStatus = {}));
+
+
+/***/ }),
+
+/***/ 4132:
+/***/ ((__unused_webpack_module, exports) => {
+
+
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports.MarketMakerSortByEnum = exports.MarketMakerRebateTier = void 0;
+var MarketMakerRebateTier;
+(function (MarketMakerRebateTier) {
+    MarketMakerRebateTier[MarketMakerRebateTier["FIRST"] = 1] = "FIRST";
+    MarketMakerRebateTier[MarketMakerRebateTier["SECOND"] = 2] = "SECOND";
+    MarketMakerRebateTier[MarketMakerRebateTier["THIRD"] = 3] = "THIRD";
+    MarketMakerRebateTier[MarketMakerRebateTier["FOURTH"] = 4] = "FOURTH";
+})(MarketMakerRebateTier || (exports.MarketMakerRebateTier = MarketMakerRebateTier = {}));
+var MarketMakerSortByEnum;
+(function (MarketMakerSortByEnum) {
+    MarketMakerSortByEnum["REBATE_TIER"] = "rebateTier";
+    MarketMakerSortByEnum["CREATED_AT"] = "createdAt";
+    MarketMakerSortByEnum["NAME"] = "name";
+    MarketMakerSortByEnum["TAKER_FEE"] = "takerFee";
+    MarketMakerSortByEnum["ENABLED"] = "enabled";
+    MarketMakerSortByEnum["ADDRESS"] = "address";
+    MarketMakerSortByEnum["CHAIN"] = "chainId";
+})(MarketMakerSortByEnum || (exports.MarketMakerSortByEnum = MarketMakerSortByEnum = {}));
+
+
+/***/ }),
+
+/***/ 4199:
+/***/ ((__unused_webpack_module, exports) => {
+
+
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports.ScheduledNotificationStatusEnum = exports.NotificationStatusEnum = exports.NotificationPriorityEnum = exports.CombinedNotificationEnum = exports.AccountNotificationEnum = exports.GlobalNotificationEnum = void 0;
+var GlobalNotificationEnum;
+(function (GlobalNotificationEnum) {
+    GlobalNotificationEnum["GLOBAL_PAIR_DELISTING"] = "GLOBAL_PAIR_DELISTING";
+    GlobalNotificationEnum["GLOBAL_NEW_PAIR_LISTING"] = "GLOBAL_NEW_PAIR_LISTING";
+    GlobalNotificationEnum["GLOBAL_SYSTEM_MAINTENANCE"] = "GLOBAL_SYSTEM_MAINTENANCE";
+    GlobalNotificationEnum["GLOBAL_SMART_CONTRACT_UPDATE"] = "GLOBAL_SMART_CONTRACT_UPDATE";
+})(GlobalNotificationEnum || (exports.GlobalNotificationEnum = GlobalNotificationEnum = {}));
+var AccountNotificationEnum;
+(function (AccountNotificationEnum) {
+    AccountNotificationEnum["ACCOUNT_POINTS_UNLOCK_ACHIEVEMENT"] = "ACCOUNT_POINTS_UNLOCK_ACHIEVEMENT";
+    AccountNotificationEnum["ACCOUNT_KYC_STATUS_CHANGED"] = "ACCOUNT_KYC_STATUS_CHANGED";
+    AccountNotificationEnum["ACCOUNT_AFFILIATE_DASHBOARD_UNLOCKED"] = "ACCOUNT_AFFILIATE_DASHBOARD_UNLOCKED";
+})(AccountNotificationEnum || (exports.AccountNotificationEnum = AccountNotificationEnum = {}));
+exports.CombinedNotificationEnum = {
+    ...GlobalNotificationEnum,
+    ...AccountNotificationEnum,
+};
+var NotificationPriorityEnum;
+(function (NotificationPriorityEnum) {
+    NotificationPriorityEnum["CRITICAL"] = "CRITICAL";
+    NotificationPriorityEnum["IMPORTANT"] = "IMPORTANT";
+    NotificationPriorityEnum["INFO"] = "INFO";
+})(NotificationPriorityEnum || (exports.NotificationPriorityEnum = NotificationPriorityEnum = {}));
+var NotificationStatusEnum;
+(function (NotificationStatusEnum) {
+    NotificationStatusEnum["UNREAD"] = "UNREAD";
+    NotificationStatusEnum["READ"] = "READ";
+})(NotificationStatusEnum || (exports.NotificationStatusEnum = NotificationStatusEnum = {}));
+var ScheduledNotificationStatusEnum;
+(function (ScheduledNotificationStatusEnum) {
+    ScheduledNotificationStatusEnum["PENDING"] = "PENDING";
+    ScheduledNotificationStatusEnum["PROCESSED"] = "PROCESSED";
+    ScheduledNotificationStatusEnum["FAILED"] = "FAILED";
+})(ScheduledNotificationStatusEnum || (exports.ScheduledNotificationStatusEnum = ScheduledNotificationStatusEnum = {}));
+
+
+/***/ }),
+
+/***/ 5237:
+/***/ ((__unused_webpack_module, exports) => {
+
+
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports.UpgradeStatus = void 0;
+var UpgradeStatus;
+(function (UpgradeStatus) {
+    UpgradeStatus["SUCCESS"] = "success";
+    UpgradeStatus["FAILED"] = "failed";
+    UpgradeStatus["PENDING"] = "pending";
+})(UpgradeStatus || (exports.UpgradeStatus = UpgradeStatus = {}));
+
+
+/***/ }),
+
+/***/ 5281:
+/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
+
+
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+const ioredis_1 = __importDefault(__webpack_require__(6615));
+class RedisHelper {
+    constructor() {
+        this.host = process.env.REDIS_HOSTNAME;
+        this.port = process.env.REDIS_PORT;
+        this.client = new ioredis_1.default({
+            host: this.host,
+            port: Number(this.port),
+            lazyConnect: true,
+        });
+        this.operationQueue = [];
+        this.runningOperations = false;
+        this.client.on('connect', () => {
+            // console.log('Redis Connected');
+        });
+        this.client.on('ready', () => {
+            // console.log('Redis Ready');
+            this.performPendingOperations();
+        });
+        this.client.on('error', (err) => {
+            console.error('Redis error:', err.message);
+        });
+        this.client.on('close', () => {
+            console.log('Redis connection closed');
+        });
+    }
+    async performPendingOperations() {
+        this.runningOperations = true;
+        while (this.operationQueue.length > 0) {
+            const operation = this.operationQueue.shift();
+            if (operation) {
+                try {
+                    await operation();
+                }
+                catch (err) {
+                    console.error('Error performing Redis operation:', err);
+                }
+            }
+        }
+        this.runningOperations = false;
+    }
+    async setString(key, value, expires = 0, database = '') {
+        const operation = async () => {
+            if (database !== '') {
+                this.client.select(Number(database));
+            }
+            await this.client.set(key, value);
+            if (expires !== 0) {
+                await this.client.expire(key, expires * 60);
+            }
+        };
+        await this.performOperation(operation);
+    }
+    async incrementKey(key, expires = 0, database = '') {
+        const operation = async () => {
+            if (database !== '') {
+                this.client.select(Number(database));
+            }
+            await this.client.incr(key);
+            if (expires !== 0) {
+                const ttl = await this.client.ttl(key);
+                if (ttl === -1) {
+                    await this.client.expire(key, expires * 60);
+                }
+            }
+        };
+        await this.performOperation(operation);
+    }
+    async scanKeys(pattern, database = '') {
+        const matchedKeys = [];
+        const operation = async () => {
+            if (database !== '') {
+                this.client.select(Number(database));
+            }
+            let cursor = '0';
+            do {
+                const [nextCursor, keys] = await this.client.scan(cursor, 'MATCH', pattern, 'COUNT', 100);
+                cursor = nextCursor;
+                matchedKeys.push(...keys);
+            } while (cursor !== '0');
+        };
+        await this.performOperation(operation);
+        return matchedKeys;
+    }
+    getString(key, database = '') {
+        return new Promise(async (resolve, reject) => {
+            const operation = async () => {
+                try {
+                    if (database !== '') {
+                        await this.client.select(Number(database));
+                    }
+                    const value = await this.client.get(key);
+                    resolve(value);
+                }
+                catch (err) {
+                    reject(err);
+                }
+            };
+            this.performOperation(operation);
+        });
+    }
+    async deleteString(key, database = '') {
+        const operation = async () => {
+            if (database !== '') {
+                this.client.select(Number(database));
+            }
+            await this.client.del(key);
+        };
+        await this.performOperation(operation);
+    }
+    async deleteByKeyPattern(pattern, database = '') {
+        const operation = async () => {
+            if (database !== '') {
+                this.client.select(Number(database));
+            }
+            const keys = await this.client.keys(pattern);
+            if (keys.length > 0) {
+                await this.client.unlink(keys);
+                console.log(`Deleted ${keys.length} keys`);
+            }
+            else {
+                console.log('No keys for delete');
+            }
+        };
+        await this.performOperation(operation);
+    }
+    async destroyDb(dbKey) {
+        const response = await this.client.del(dbKey);
+        return response === 1;
+    }
+    async performOperation(operation) {
+        this.operationQueue.push(operation);
+        if (!this.runningOperations) {
+            try {
+                await this.performPendingOperations();
+            }
+            catch (error) {
+                console.error('Error during performing Redis operation', error);
+            }
+        }
+    }
+    async close() {
+        console.log('Closing Redis client for graceful shutdown...');
+        try {
+            while (this.operationQueue.length > 0 || this.runningOperations) {
+                await new Promise((resolve) => setTimeout(resolve, 100));
+            }
+            await this.client.quit();
+            console.log('Redis client closed successfully');
+        }
+        catch (error) {
+            console.error('Error during Redis client shutdown:', error);
+        }
+    }
+    async createStream(key) {
+        // console.log(`[Stream '${key}'] Creating...`);
+        await this.client.xgroup('CREATE', key, 'group', '$', 'MKSTREAM');
+    }
+    async writeToStream(key, message) {
+        try {
+            // console.log(`[Stream '${key}']`, `Try write to stream`);
+            if (await this.streamExists(key)) {
+                // console.log(`[Stream '${key}']`, `Writing the message`, JSON.stringify(message));
+                await this.client.xadd(key, '*', 'message', JSON.stringify(message));
+            }
+        }
+        catch (error) {
+            console.log(`[Stream '${key}']`, 'Error while writing to stream', error);
+        }
+    }
+    async readStream(key, timeout) {
+        // console.log(`[Stream '${key}'] Reading with timeout ${timeout}s...`);
+        const results = await this.client.xreadgroup('GROUP', 'group', 'consumer', 'COUNT', 1, 'BLOCK', timeout * 1000, 'STREAMS', key, '>');
+        if (results && results.length > 0) {
+            const [, entries] = results[0];
+            if (entries && entries.length > 0) {
+                const [, [, message]] = entries[0];
+                return JSON.parse(message);
+            }
+        }
+        return null;
+    }
+    async deleteStream(key) {
+        // console.log(`[Stream '${key}']`, `Try delete stream`);
+        if (await this.streamExists(key)) {
+            // console.log(`[Stream '${key}']`, `Deleting...`);
+            await this.client.del(key);
+        }
+    }
+    async setTTL(key, ttlSeconds) {
+        await this.client.expire(key, ttlSeconds);
+    }
+    async streamExists(key) {
+        const exists = await this.client.exists(key);
+        // console.log(`Key '${key}' in redis exists: ${exists}`);
+        return exists === 1;
+    }
+}
+exports["default"] = new RedisHelper();
+
+
+/***/ }),
+
+/***/ 5320:
+/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
+
+
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports.mapToUserTradeDto = mapToUserTradeDto;
+exports.mapToOrderTradeDto = mapToOrderTradeDto;
+exports.isMaker = isMaker;
+const order_helper_1 = __webpack_require__(7542);
+const utils_1 = __webpack_require__(8398);
+const big_number_helper_1 = __webpack_require__(1174);
+const _enums_1 = __webpack_require__(9965);
+function mapToUserTradeDto(t, baseAsset, priceAsset) {
+    const o = t.buyOrder && t.sellOrder
+        ? (t.buyOrderId > t.sellOrderId ? t.buyOrder : t.sellOrder) // which order is self order
+        : (t.buyOrder || t.sellOrder); // user order
+    return {
+        pairId: t.pairId,
+        orderId: o?.id,
+        orderSide: (o && (0, order_helper_1.mapOrderSideToShort)(o.side)),
+        ...mapAssets(baseAsset, priceAsset),
+        ...mapTrade(t, o),
+    };
+}
+function mapToOrderTradeDto(order, trades, pairKey, baseAsset, priceAsset) {
+    return {
+        id: order.id,
+        pairId: order.pairId,
+        // @ts-ignore
+        pair: pairKey || order.pair?.pairKey,
+        ...mapAssets(baseAsset, priceAsset),
+        amount: order.amount,
+        price: order.price,
+        total: order.total,
+        filledAmount: order.filledAmount,
+        filledTotal: order.filledTotal,
+        avgPrice: order.excutedPrice,
+        status: order.status,
+        side: order.side,
+        type: order.type,
+        userId: order.userId,
+        createdAt: order.createdAt?.getTime(),
+        completedAt: order.completedAt?.getTime() || null,
+        updatedAt: order.updatedAt?.getTime(),
+        trades: trades && trades.map((t) => mapTrade(t, order)),
+    };
+}
+function mapAssets(baseAsset, priceAsset) {
+    return {
+        baseTokenId: baseAsset?.id,
+        baseTokenDecimal: baseAsset?.decimals,
+        quoteTokenId: priceAsset?.id,
+        quoteTokenDecimal: priceAsset?.decimals,
+    };
+}
+function mapTrade(t, o) {
+    return {
+        tradeId: t.tradeId,
+        status: t.txStatus,
+        amount: t.amount,
+        total: t.total,
+        price: t.price,
+        fee: o && t.tradeFees
+            .filter(f => (0, utils_1.equalIgnoreCase)(f.address, o.userId))
+            .reduce((acc, cur) => (0, big_number_helper_1.plus)(acc, cur.fee), '0'),
+        createdAt: t.createdAt?.getTime(),
+        updatedAt: t.updatedAt?.getTime(),
+        isBuyer: o && o.side === _enums_1.OrderSide.Buy,
+        isMaker: o && isMaker(o.side, t.tradeSide),
+    };
+}
+function isMaker(oSide, tSide) {
+    return oSide === _enums_1.OrderSide.Buy && tSide === _enums_1.OrderSide.Sell
+        || oSide === _enums_1.OrderSide.Sell && tSide === _enums_1.OrderSide.Buy;
+}
+
+
+/***/ }),
+
+/***/ 6119:
+/***/ ((__unused_webpack_module, exports) => {
+
+
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports.TwitterAccessScopeEnum = void 0;
+var TwitterAccessScopeEnum;
+(function (TwitterAccessScopeEnum) {
+    TwitterAccessScopeEnum["USERS_READ"] = "users.read";
+    TwitterAccessScopeEnum["FOLLOWS_READ"] = "follows.read";
+    TwitterAccessScopeEnum["FOLLOWS_WRITE"] = "follows.write";
+    TwitterAccessScopeEnum["TWEET_READ"] = "tweet.read";
+    TwitterAccessScopeEnum["TWEET_WRITE"] = "tweet.write";
+    TwitterAccessScopeEnum["OFFLINE_ACCESS"] = "offline.access";
+    TwitterAccessScopeEnum["LIKE_READ"] = "like.read";
+    TwitterAccessScopeEnum["LIKE_WRITE"] = "like.write";
+})(TwitterAccessScopeEnum || (exports.TwitterAccessScopeEnum = TwitterAccessScopeEnum = {}));
+
+
+/***/ }),
+
+/***/ 6168:
+/***/ ((module) => {
+
+module.exports = __WEBPACK_EXTERNAL_MODULE__6168__;
+
+/***/ }),
+
+/***/ 6615:
+/***/ ((module) => {
+
+module.exports = __WEBPACK_EXTERNAL_MODULE__6615__;
+
+/***/ }),
+
+/***/ 6828:
+/***/ ((__unused_webpack_module, exports) => {
+
+
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports.KYCAuthenticationStatus = exports.LastLookAction = exports.FeeTier = void 0;
+var FeeTier;
+(function (FeeTier) {
+    FeeTier[FeeTier["FEE_TIER_1"] = 1] = "FEE_TIER_1";
+    FeeTier[FeeTier["FEE_TIER_2"] = 2] = "FEE_TIER_2";
+    FeeTier[FeeTier["FEE_TIER_3"] = 3] = "FEE_TIER_3";
+    FeeTier[FeeTier["FEE_TIER_4"] = 4] = "FEE_TIER_4";
+    FeeTier[FeeTier["FEE_TIER_5"] = 5] = "FEE_TIER_5";
+    FeeTier[FeeTier["FEE_TIER_6"] = 6] = "FEE_TIER_6";
+})(FeeTier || (exports.FeeTier = FeeTier = {}));
+var LastLookAction;
+(function (LastLookAction) {
+    LastLookAction[LastLookAction["Approve"] = 1] = "Approve";
+    LastLookAction[LastLookAction["Reject"] = 0] = "Reject";
+})(LastLookAction || (exports.LastLookAction = LastLookAction = {}));
+var KYCAuthenticationStatus;
+(function (KYCAuthenticationStatus) {
+    KYCAuthenticationStatus["INITIATED"] = "INITIATED";
+    KYCAuthenticationStatus["CREATED"] = "CREATED";
+    KYCAuthenticationStatus["PROCESSING"] = "PROCESSING";
+    KYCAuthenticationStatus["APPROVED"] = "APPROVED";
+    KYCAuthenticationStatus["REJECTED"] = "REJECTED";
+})(KYCAuthenticationStatus || (exports.KYCAuthenticationStatus = KYCAuthenticationStatus = {}));
+
+
+/***/ }),
+
+/***/ 6978:
+/***/ ((__unused_webpack_module, exports) => {
+
+
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports.MaintenanceMode = void 0;
+var MaintenanceMode;
+(function (MaintenanceMode) {
+    MaintenanceMode[MaintenanceMode["Off"] = 0] = "Off";
+    MaintenanceMode[MaintenanceMode["Full"] = 1] = "Full";
+    MaintenanceMode[MaintenanceMode["Partial"] = 2] = "Partial";
+    MaintenanceMode[MaintenanceMode["Scheduled"] = 3] = "Scheduled";
+})(MaintenanceMode || (exports.MaintenanceMode = MaintenanceMode = {}));
+
+
+/***/ }),
+
+/***/ 7413:
+/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
+
+
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports.extractAppOrders = extractAppOrders;
+const decode_1 = __webpack_require__(3450);
+const logger_1 = __importDefault(__webpack_require__(298));
+function extractAppOrders(account, appId) {
+    logger_1.default.log('accountInfo', account);
+    if (!account?.hasOwnProperty('apps-local-state')) {
+        logger_1.default.log(`No apps-local-state at account`, account);
+        return [];
+    }
+    let localState = account['apps-local-state'];
+    if (!localState?.length) {
+        logger_1.default.log('apps-local-state', localState);
+        return [];
+    }
+    const ordersInApp = localState.filter((state) => !state.deleted && state.id === appId);
+    logger_1.default.log(`[App Id: ${appId}]`, ordersInApp);
+    return ordersInApp
+        .map(state => {
+        const balancesKey = state['key-value'].find((el) => (el.key === "YWNjb3VudEluZm8="));
+        const ordersKey = state['key-value'].filter((el) => (el.key !== "YWNjb3VudEluZm8="));
+        const decodedBalances = (0, decode_1.getAccounInfoFormLocalStorage)(balancesKey.value.bytes);
+        const decodedOrders = ordersKey.map((el) => (0, decode_1.printUnpackedLocalData)(el.value.bytes));
+        return decodedOrders.flat(Infinity);
+    })
+        .flat().filter((o) => o.orderID !== 0);
+}
+
+
+/***/ }),
+
+/***/ 7542:
+/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
+
+
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports.mapOrderSideFromShort = mapOrderSideFromShort;
+exports.mapOrderSideToShort = mapOrderSideToShort;
+exports.mapOrderTypeShort = mapOrderTypeShort;
+exports.mapOrderSideFromShortToLong = mapOrderSideFromShortToLong;
+exports.mapOrderTypeShortToLong = mapOrderTypeShortToLong;
+const _enums_1 = __webpack_require__(9965);
+function mapOrderSideFromShort(value) {
+    switch (value) {
+        case "B": return _enums_1.OrderSide.Buy;
+        case "S": return _enums_1.OrderSide.Sell;
+        default:
+            throw new Error("Unknown order side short type: " + value);
+    }
+}
+function mapOrderSideToShort(value) {
+    switch (value) {
+        case _enums_1.OrderSide.Buy: return "B";
+        case _enums_1.OrderSide.Sell: return "S";
+        default:
+            throw new Error("Unknown order side type: " + value);
+    }
+}
+function mapOrderTypeShort(value) {
+    switch (value) {
+        case "I": return _enums_1.OrderType.IOC;
+        case "P": return _enums_1.OrderType.POST;
+        case "M": return _enums_1.OrderType.Market;
+        case "L":
+        default:
+            return _enums_1.OrderType.Limit;
+    }
+}
+function mapOrderSideFromShortToLong(value) {
+    switch (value) {
+        case "B": return "BUY";
+        case "S": return "SELL";
+        default:
+            throw new Error("Unknown order side short type: " + value);
+    }
+}
+function mapOrderTypeShortToLong(value) {
+    switch (value) {
+        case "I": return "IOC";
+        case "P": return "POST";
+        case "M": return "Market";
+        case "L":
+        default:
+            return "Limit";
+    }
+}
+
+
+/***/ }),
+
+/***/ 7639:
+/***/ ((__unused_webpack_module, exports) => {
+
+
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports.dropIndexIfExists = dropIndexIfExists;
+exports.createIndexIfNotExists = createIndexIfNotExists;
+exports.checkIfExists = checkIfExists;
+async function dropIndexIfExists(queryRunner, tableName, indexName) {
+    if (await checkIfExists(queryRunner, tableName, indexName)) {
+        await queryRunner.query(`ALTER TABLE \`${tableName}\` DROP index \`${indexName}\``);
+    }
+}
+async function createIndexIfNotExists(queryRunner, tableName, indexName, cols) {
+    if (!(await checkIfExists(queryRunner, tableName, indexName))) {
+        await queryRunner.query(`CREATE INDEX \`${indexName}\` ON \`${tableName}\` (${cols});`);
+    }
+}
+async function checkIfExists(queryRunner, tableName, indexName) {
+    let result = await queryRunner.query(`SELECT EXISTS(SELECT * FROM INFORMATION_SCHEMA.STATISTICS  WHERE TABLE_NAME = '${tableName}'
+  AND INDEX_NAME = '${indexName}' AND INDEX_SCHEMA='order_service') as existed`);
+    console.log(result);
+    return result.length > 0 && result[0].existed == 1;
+}
+
+
+/***/ }),
+
+/***/ 7818:
+/***/ ((module) => {
+
+module.exports = __WEBPACK_EXTERNAL_MODULE__7818__;
+
+/***/ }),
+
+/***/ 8398:
+/***/ ((__unused_webpack_module, exports) => {
+
+
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports.equalIgnoreCase = exports.listDateFormat = void 0;
+exports.getRandomInt = getRandomInt;
+exports.getDomains = getDomains;
+exports.cutEvent = cutEvent;
+exports.maskingString = maskingString;
+exports.removeField = removeField;
+const listDateFormat = (date) => {
+    let newDAte = new Date(date);
+    let parsedDate = newDAte.toLocaleDateString('default', {
+        year: 'numeric',
+        month: 'numeric',
+        day: 'numeric',
+    });
+    let time = newDAte.toLocaleTimeString('en-US', {
+        hour12: true,
+        hour: '2-digit',
+        minute: '2-digit',
+    });
+    return parsedDate + ' ' + time;
+};
+exports.listDateFormat = listDateFormat;
+const equalIgnoreCase = (value1, value2) => {
+    return String(value1).toLowerCase() === String(value2).toLowerCase();
+};
+exports.equalIgnoreCase = equalIgnoreCase;
+function getRandomInt(min, max) {
+    min = Math.ceil(min);
+    max = Math.floor(max);
+    return Math.floor(Math.random() * (max - min + 1)) + min;
+}
+function getDomains(domain) {
+    const domains = [];
+    const parts = domain.split('.');
+    for (let i = 0; i < parts.length - 1; i++) {
+        domains.push(parts.slice(i).join('.'));
+    }
+    return domains;
+}
+;
+function cutEvent(event) {
+    const headers = event.headers && removeUndefined({
+        'Authorization': event.headers['Authorization']?.substring(0, 200),
+        'CloudFront-Viewer-Country': event.headers['CloudFront-Viewer-Country'],
+        'Host': event.headers['Host'],
+        'origin': event.headers['origin'],
+        'Referer': event.headers['Referer'],
+        'User-Agent': event.headers['User-Agent'],
+        'wl-domain': event.headers['wl-domain'],
+        'X-API-Key': maskingString(event.headers['X-API-Key']),
+        'X-Forwarded-For': event.headers['X-Forwarded-For'],
+        'X-Forwarded-Port': event.headers['X-Forwarded-Port'],
+        'X-Forwarded-Proto': event.headers['X-Forwarded-Proto'],
+        'X-Trading-Key': event.headers['X-Trading-Key'],
+        'X-Wallet-Address': event.headers['X-Wallet-Address'],
+        'X-Wallet-Token': event.headers['X-Wallet-Token'],
+        'accessToken': maskingString(event.headers['accessToken']),
+        'companyId': event.headers['companyId'],
+        'seasonId': event.headers['seasonId'],
+    });
+    const requestContext = event.requestContext && removeUndefined({
+        identity: event.requestContext.identity && removeUndefined({
+            'userAgent': event.requestContext.identity['userAgent'],
+            'sourceIp': event.requestContext.identity['sourceIp'],
+        }),
+        domainName: event.requestContext.domainName,
+    });
+    return removeUndefined({
+        manage: event.manage,
+        path: event.path,
+        httpMethod: event.httpMethod,
+        headers,
+        requestContext,
+    });
+}
+function maskingString(str) {
+    if (!str?.length)
+        return str;
+    const maskLen = Math.round(str.length / 3);
+    const start = maskLen;
+    const end = str.length - maskLen;
+    const maskedStr = str.substring(0, start) + "*".repeat(maskLen) + str.substring(end);
+    return maskedStr;
+}
+function removeField(obj, fieldToRemove) {
+    if (Array.isArray(obj)) {
+        return obj.map(item => removeField(item, fieldToRemove));
+    }
+    else if (typeof obj === 'object' && obj !== null) {
+        return Object.fromEntries(Object.entries(obj)
+            .filter(([key]) => key !== fieldToRemove)
+            .map(([key, value]) => [key, removeField(value, fieldToRemove)]));
+    }
+    return obj; // Return primitives as-is
+}
+function removeUndefined(obj) {
+    return Object.fromEntries(Object.entries(obj).filter(([, value]) => value !== undefined));
+}
+
+
+/***/ }),
+
+/***/ 8593:
+/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
+
+
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports.decodeAddress = exports.encodeAddress = void 0;
+exports.concatArrays = concatArrays;
+exports.packData = packData;
+exports.unpackData = unpackData;
+exports.encodeArgArray = encodeArgArray;
+exports.encodeString = encodeString;
+exports.decodeString = decodeString;
+exports.encode32Bytes = encode32Bytes;
+exports.encodeUint64 = encodeUint64;
+exports.decodeUint64 = decodeUint64;
+exports.encodeBase64 = encodeBase64;
+exports.decodeBase64 = decodeBase64;
+exports.compareArrays = compareArrays;
+exports.getDeltaUint = getDeltaUint;
+exports.getDeltaBytes = getDeltaBytes;
+exports.toUnix = toUnix;
+exports.fromUnix = fromUnix;
+const algosdk_1 = __importStar(__webpack_require__(9709));
+// import sha512 from "js-sha512"
+const buffer_1 = __webpack_require__(18);
+function concatArrays(arrays) {
+    return arrays.reduce((a, b) => Uint8Array.from([...a, ...b]));
+}
+function packData(value, format) {
+    const chunks = [];
+    for (const [name, type] of Object.entries(format)) {
+        const v = value[name];
+        if (v === undefined) {
+            throw new Error(`Key ${name} missing from value`);
+        }
+        switch (type.type) {
+            case 'address':
+                if (v instanceof Uint8Array && v.length == 32) {
+                    chunks.push(v);
+                    break;
+                }
+                else if (typeof v === 'string') {
+                    chunks.push((0, algosdk_1.decodeAddress)(v).publicKey);
+                }
+                else {
+                    throw new Error(`${name}: Expected address, got ${v}`);
+                }
+                break;
+            case 'bytes':
+                if (v instanceof Uint8Array) {
+                    if (v.length == type.size) {
+                        chunks.push(v);
+                        break;
+                    }
+                    else {
+                        throw new Error(`${name}: Bytes length is wrong, expected ${type.size}, got ${v.length}`);
+                    }
+                }
+                else {
+                    throw new Error(`${name}: Expected bytes[${type.size}], got ${v}`);
+                }
+            case 'double':
+                if (typeof v === 'number') {
+                    const bytes = new ArrayBuffer(8);
+                    buffer_1.Buffer.from(bytes).writeDoubleLE(v, 0);
+                    chunks.push(new Uint8Array(bytes));
+                    break;
+                }
+                else {
+                    throw new Error(`${name}: Expected double, got ${v}`);
+                }
+            case 'number':
+            case 'uint':
+                if (typeof v === 'bigint' || typeof v === 'number') {
+                    chunks.push(encodeUint64(v));
+                    break;
+                }
+                else {
+                    throw new Error(`${name}: Expected uint or number, got ${v}`);
+                }
+            case 'string':
+                if (typeof v === 'string') {
+                    const str = encodeString(v);
+                    if (str.length == type.size) {
+                        chunks.push(str);
+                        break;
+                    }
+                    else {
+                        throw new Error(`${name}: Expected string length ${type.size}, got string length ${str.length}`);
+                    }
+                }
+                else {
+                    throw new Error(`${name}: Expected string length ${type.size}, got ${v}`);
+                }
+        }
+    }
+    return concatArrays(chunks);
+}
+function unpackData(data, format) {
+    const result = new Map();
+    let index = 0;
+    for (const [name, type] of Object.entries(format)) {
+        if (index >= data.length) {
+            throw new Error('Array index out of bounds');
+        }
+        let value;
+        switch (type.type) {
+            case 'address':
+                value = (0, algosdk_1.encodeAddress)(data.slice(index, index + 32));
+                index += 32;
+                break;
+            case 'bytes':
+                value = data.slice(index, index + type.size);
+                index += type.size;
+                break;
+            case 'double':
+                value = buffer_1.Buffer.from(data.slice(index, index + 8)).readDoubleLE(0);
+                index += 8;
+                break;
+            case 'number':
+                value = Number(decodeUint64(data.slice(index, index + 8)));
+                index += 8;
+                break;
+            case 'uint':
+                value = decodeUint64(data.slice(index, index + 8));
+                index += 8;
+                break;
+            case 'string':
+                value = decodeString(data.slice(index, index + type.size));
+                index += type.size;
+                break;
+        }
+        result.set(name, value);
+    }
+    return Object.fromEntries(result);
+}
+function encodeArgArray(params) {
+    return params.map(param => {
+        if (param instanceof Uint8Array)
+            return new Uint8Array(param);
+        if (typeof param === "string")
+            return encodeString(param);
+        if (typeof param === "boolean")
+            param = BigInt(param ? 1 : 0);
+        if (typeof param === "number")
+            param = BigInt(param);
+        return encodeUint64(param);
+    });
+}
+function encodeString(value) {
+    return new Uint8Array(buffer_1.Buffer.from(value));
+}
+function decodeString(value) {
+    return buffer_1.Buffer.from(value).toString('utf-8');
+}
+function encode32Bytes(value) {
+    const valueButes = algosdk_1.default.encodeUint64(value);
+    return concatArrays([new Uint8Array(32 - valueButes.length), valueButes]);
+}
+function encodeUint64(value) {
+    const bytes = buffer_1.Buffer.alloc(8);
+    for (let index = 0; index < 8; index++)
+        bytes[7 - index] = Number((BigInt(value) >> BigInt(index * 8)) & BigInt(0xFF));
+    return new Uint8Array(bytes);
+}
+function decodeUint64(value) {
+    let num = BigInt(0);
+    for (let index = 0; index < 8 && value?.length; index++)
+        num = (num << BigInt(8)) | BigInt(value[index]);
+    return num;
+}
+function encodeBase64(value) {
+    return buffer_1.Buffer.from(value).toString('base64');
+}
+function decodeBase64(value) {
+    return buffer_1.Buffer.from(value, 'base64');
+}
+// export const sha256HashLength = 32
+// export function sha256Hash(arr: sha512.Message): Uint8Array {
+//     return new Uint8Array(sha512.sha512_256.arrayBuffer(arr))
+// }
+// export function encodeApplicationAddress(id: number): Address {
+//     const APP_ID_PREFIX = Buffer.from('appID');
+//     const toBeSigned = concatArrays([APP_ID_PREFIX, encodeUint64(BigInt(id))]);
+//     return encodeAddress(sha256Hash(toBeSigned));
+// }
+function compareArrays(a, b) {
+    return a.length === b.length && a.reduce((equal, item, index) => equal && item === b[index], true);
+}
+function getDelta(response, key) {
+    const delta = response['global-state-delta'].find((v) => v.key === key);
+    if (delta === undefined)
+        return undefined;
+    return delta['value'];
+}
+function getDeltaUint(response, key) {
+    const delta = getDelta(response, key);
+    if (delta === undefined)
+        return undefined;
+    return BigInt(delta['uint']);
+}
+function getDeltaBytes(response, key) {
+    const delta = getDelta(response, key);
+    if (delta === undefined)
+        return undefined;
+    return decodeBase64(delta['bytes']);
+}
+function toUnix(date) {
+    return Math.floor(date.getTime() / 1000);
+}
+function fromUnix(timestamp) {
+    return new Date(timestamp * 1000);
+}
+var algosdk_2 = __webpack_require__(9709);
+Object.defineProperty(exports, "encodeAddress", ({ enumerable: true, get: function () { return algosdk_2.encodeAddress; } }));
+Object.defineProperty(exports, "decodeAddress", ({ enumerable: true, get: function () { return algosdk_2.decodeAddress; } }));
+
+
+/***/ }),
+
+/***/ 8980:
+/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
+
+
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports.decrypt = exports.encrypt = void 0;
+const client_kms_1 = __webpack_require__(7818);
+const logger_1 = __importDefault(__webpack_require__(298));
+const encrypt = async (string) => {
+    if (process.env.ENVIRONMENT === 'LOCAL') {
+        logger_1.default.logWarning('WARNING: AWS KMS encryption is bypassed in local environment.');
+        return string;
+    }
+    const input = {
+        KeyId: process.env.SOCIAL_SECRET_KEY_ID,
+        Plaintext: Buffer.from(string),
+    };
+    const command = new client_kms_1.EncryptCommand(input);
+    const result = await sendKmsCommand(command);
+    return Buffer.from(result.CiphertextBlob).toString('base64');
+};
+exports.encrypt = encrypt;
+const decrypt = async (encryptedString) => {
+    if (process.env.ENVIRONMENT === 'LOCAL') {
+        logger_1.default.logWarning('WARNING: AWS KMS decryption is bypassed in local environment.');
+        return encryptedString;
+    }
+    const input = {
+        KeyId: process.env.SOCIAL_SECRET_KEY_ID,
+        CiphertextBlob: Buffer.from(encryptedString, 'base64'),
+    };
+    const command = new client_kms_1.DecryptCommand(input);
+    const result = await sendKmsCommand(command);
+    return new TextDecoder().decode(result.Plaintext);
+};
+exports.decrypt = decrypt;
+const sendKmsCommand = async (command) => {
+    return new Promise((resolve, reject) => {
+        try {
+            const client = new client_kms_1.KMSClient({ region: 'us-east-1' });
+            client.send(command, (err, data) => {
+                if (err) {
+                    console.log('-----error in KMS operation---------', err);
+                    reject(err);
+                }
+                else {
+                    console.log('KMS command was successfully sent');
+                    resolve(data);
+                }
+            });
+        }
+        catch (error) {
+            console.log('KMSClient error', error);
+            reject(error);
+        }
+    });
+};
+
+
+/***/ }),
+
+/***/ 9321:
+/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
+
+
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+__exportStar(__webpack_require__(221), exports);
+__exportStar(__webpack_require__(2137), exports);
+__exportStar(__webpack_require__(5320), exports);
+
+
+/***/ }),
+
+/***/ 9709:
+/***/ ((module) => {
+
+module.exports = __WEBPACK_EXTERNAL_MODULE__9709__;
+
+/***/ }),
+
+/***/ 9965:
+/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
+
+
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+__exportStar(__webpack_require__(2228), exports);
+__exportStar(__webpack_require__(6978), exports);
+__exportStar(__webpack_require__(2739), exports);
+__exportStar(__webpack_require__(6119), exports);
+__exportStar(__webpack_require__(3004), exports);
+
+
+/***/ })
+
+/******/ 	});
+/************************************************************************/
+/******/ 	// The module cache
+/******/ 	var __webpack_module_cache__ = {};
+/******/ 	
+/******/ 	// The require function
+/******/ 	function __webpack_require__(moduleId) {
+/******/ 		// Check if module is in cache
+/******/ 		var cachedModule = __webpack_module_cache__[moduleId];
+/******/ 		if (cachedModule !== undefined) {
+/******/ 			return cachedModule.exports;
+/******/ 		}
+/******/ 		// Create a new module (and put it into the cache)
+/******/ 		var module = __webpack_module_cache__[moduleId] = {
+/******/ 			// no module.id needed
+/******/ 			// no module.loaded needed
+/******/ 			exports: {}
+/******/ 		};
+/******/ 	
+/******/ 		// Execute the module function
+/******/ 		__webpack_modules__[moduleId].call(module.exports, module, module.exports, __webpack_require__);
+/******/ 	
+/******/ 		// Return the exports of the module
+/******/ 		return module.exports;
+/******/ 	}
+/******/ 	
+/************************************************************************/
+/******/ 	
+/******/ 	// startup
+/******/ 	// Load entry module and return exports
+/******/ 	// This entry module is referenced by other modules so it can't be inlined
+/******/ 	var __webpack_exports__ = __webpack_require__(3528);
+/******/ 	
+/******/ 	return __webpack_exports__;
+/******/ })()
+;
+});