@ultrade/ultrade-js-sdk 0.2.6 → 2.0.0

package/dist/index.js

@@ -1,4 +1,25 @@
-"use strict";
+/******/ (() => { // webpackBootstrap
+/******/ 	"use strict";
+/******/ 	var __webpack_modules__ = ({
+
+/***/ 10:
+/***/ ((module) => {
+
+module.exports = require("@ultrade/shared/common/index");
+
+/***/ }),
+
+/***/ 65:
+/***/ ((module) => {
+
+module.exports = require("@ultrade/shared/helpers/algo.helper");
+
+/***/ }),
+
+/***/ 156:
+/***/ (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);
@@ -13,7 +34,1186 @@ var __createBinding = (this && this.__createBinding) || (Object.create ? (functi
 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(require("./amm"), exports);
-__exportStar(require("./constants"), exports);
-__exportStar(require("./types"), exports);
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports.SocketManager = void 0;
+__exportStar(__webpack_require__(985), exports);
+var sockets_1 = __webpack_require__(382);
+Object.defineProperty(exports, "SocketManager", ({ enumerable: true, get: function () { return sockets_1.SocketManager; } }));
+
+
+/***/ }),
+
+/***/ 185:
+/***/ (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.decodeString = exports.unpackData = void 0;
+const algosdk_1 = __importStar(__webpack_require__(241));
+const format = {
+    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',
+    },
+};
+const unpackData = (data) => {
+    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 = (0, exports.decodeString)(data.slice(index, index + type.size));
+                index += type.size;
+                break;
+        }
+        result.set(name, value);
+    }
+    return Object.fromEntries(result);
+};
+exports.unpackData = unpackData;
+const decodeString = (value) => {
+    return Buffer.from(value).toString('utf-8');
+};
+exports.decodeString = decodeString;
+
+
+/***/ }),
+
+/***/ 186:
+/***/ ((module) => {
+
+module.exports = require("@ultrade/shared/enums");
+
+/***/ }),
+
+/***/ 193:
+/***/ ((module) => {
+
+module.exports = require("@ultrade/shared/constants");
+
+/***/ }),
+
+/***/ 230:
+/***/ ((module) => {
+
+module.exports = require("@ultrade/shared/helpers/codex/index");
+
+/***/ }),
+
+/***/ 241:
+/***/ ((module) => {
+
+module.exports = require("algosdk");
+
+/***/ }),
+
+/***/ 287:
+/***/ ((module) => {
+
+module.exports = require("react-secure-storage");
+
+/***/ }),
+
+/***/ 382:
+/***/ ((__unused_webpack_module, exports) => {
+
+
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports.SocketManager = void 0;
+class SocketManager {
+    onDisconnect;
+    onConnectError;
+    socket = null;
+    socketPool = {};
+    websocketUrl;
+    socketIOFactory;
+    constructor(url, socketIOFactory, onDisconnect, onConnectError) {
+        this.onDisconnect = onDisconnect;
+        this.onConnectError = onConnectError;
+        this.websocketUrl = url;
+        this.socketIOFactory = socketIOFactory;
+        this.initializeSocket();
+    }
+    initializeSocket() {
+        if (this.socket === null) {
+            this.socket = this.socketIOFactory(this.websocketUrl, {
+                reconnection: true,
+                reconnectionDelay: 1000,
+                reconnectionAttempts: 9999,
+                transports: ['websocket'],
+            });
+            if (this.onDisconnect) {
+                this.socket.on('disconnect', () => {
+                    this.onDisconnect(this.socket.id);
+                });
+            }
+            if (this.onConnectError) {
+                this.socket.on('connect_error', (err) => {
+                    this.onConnectError(err);
+                });
+            }
+        }
+    }
+    getSocket() {
+        return this.socket;
+    }
+    subscribe(subscribeOptions, callback) {
+        const handlerId = Date.now();
+        if (this.socket === null) {
+            this.initializeSocket();
+        }
+        this.socket.onAny((event, ...args) => {
+            callback(event, args);
+        });
+        this.socket.io.on('reconnect', () => {
+            this.socket.emit('subscribe', subscribeOptions);
+        });
+        this.socket.emit('subscribe', subscribeOptions);
+        this.socketPool[handlerId] = subscribeOptions;
+        return handlerId;
+    }
+    unsubscribe(handlerId) {
+        const options = this.socketPool[handlerId];
+        if (options && this.socket) {
+            this.socket.emit('unsubscribe', options);
+            delete this.socketPool[handlerId];
+        }
+        if (Object.keys(this.socketPool).length === 0 && this.socket) {
+            this.disconnect();
+        }
+    }
+    disconnect() {
+        if (this.socket) {
+            this.socket.disconnect();
+            this.socket = null;
+        }
+    }
+    isConnected() {
+        return this.socket !== null && this.socket.connected;
+    }
+    on(event, handler) {
+        if (this.socket) {
+            this.socket.on(event, handler);
+        }
+    }
+    off(event, handler) {
+        if (this.socket) {
+            if (handler) {
+                this.socket.off(event, handler);
+            }
+            else {
+                this.socket.off(event);
+            }
+        }
+    }
+    emit(event, ...args) {
+        if (this.socket) {
+            this.socket.emit(event, ...args);
+        }
+    }
+    emitCurrentPair(data) {
+        this.emit('currentPair', data);
+    }
+    emitOrderFilter(data) {
+        this.emit('orderFilter', data);
+    }
+    onReconnect(handler) {
+        if (this.socket) {
+            this.socket.io.off('reconnect');
+            this.socket.io.on('reconnect', handler);
+            return () => {
+                if (this.socket) {
+                    this.socket.io.off('reconnect', handler);
+                }
+            };
+        }
+        return () => { };
+    }
+    offReconnect(handler) {
+        if (this.socket) {
+            if (handler) {
+                this.socket.io.off('reconnect', handler);
+            }
+            else {
+                this.socket.io.off('reconnect');
+            }
+        }
+    }
+}
+exports.SocketManager = SocketManager;
+
+
+/***/ }),
+
+/***/ 524:
+/***/ ((module) => {
+
+module.exports = require("@ultrade/shared/interfaces");
+
+/***/ }),
+
+/***/ 566:
+/***/ ((module) => {
+
+module.exports = require("@ultrade/shared/helpers/withdraw.helper");
+
+/***/ }),
+
+/***/ 610:
+/***/ (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.LocalStorageService = void 0;
+const react_secure_storage_1 = __importDefault(__webpack_require__(287));
+const host = new URL((window.location !== window.parent.location) ? document.referrer : document.location.href).host;
+const addHostPostfix = (key) => `${key}_${host}`;
+const secureLocalStorageProxy = new Proxy(react_secure_storage_1.default, {
+    get(target, prop, receiver) {
+        if (typeof prop === 'string' && typeof target[prop] === 'function') {
+            return function (...args) {
+                if (typeof prop === 'string' && ['setItem', 'getItem', 'removeItem'].includes(prop)) {
+                    args[0] = addHostPostfix(args[0]);
+                }
+                return target[prop].apply(target, args);
+            };
+        }
+        return Reflect.get(target, prop, receiver);
+    }
+});
+const localStorageProxy = new Proxy(localStorage, {
+    get(target, prop, receiver) {
+        if (typeof prop === 'string' && typeof target[prop] === 'function') {
+            return function (...args) {
+                if (typeof prop === 'string' && ['setItem', 'getItem', 'removeItem', 'key'].includes(prop)) {
+                    args[0] = addHostPostfix(args[0]);
+                }
+                return target[prop].apply(target, args);
+            };
+        }
+        return Reflect.get(target, prop, receiver);
+    }
+});
+class LocalStorageService {
+    isBrowser;
+    keys = {
+        mainWallet: 'main-wallet',
+        tradingKey: 'trading-key'
+    };
+    constructor() {
+        this.isBrowser = typeof window !== 'undefined';
+        if (!this.isBrowser) {
+            this.clearMainWallet = () => { };
+            this.getMainWallet = () => null;
+            this.setMainWallet = () => { };
+        }
+    }
+    setMainWallet(mainWallet) {
+        localStorageProxy.setItem(this.keys.mainWallet, JSON.stringify(mainWallet));
+    }
+    getMainWallet() {
+        const mainWalletStr = localStorageProxy.getItem(this.keys.mainWallet);
+        if (!mainWalletStr) {
+            return null;
+        }
+        const mainWallet = JSON.parse(mainWalletStr);
+        const tradingKey = secureLocalStorageProxy.getItem(`${this.keys.tradingKey}-${mainWallet.address}`);
+        // @ts-ignore
+        if (tradingKey && (tradingKey.expiredAt === 0 || Number(new Date(tradingKey.expiredAt)) - Date.now() > 1)) {
+            // @ts-ignore
+            mainWallet.tradingKey = tradingKey.address;
+        }
+        return mainWallet;
+    }
+    clearMainWallet() {
+        localStorageProxy.removeItem(this.keys.mainWallet);
+    }
+}
+exports.LocalStorageService = LocalStorageService;
+
+
+/***/ }),
+
+/***/ 726:
+/***/ (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.AlgodService = void 0;
+const algo_helper_1 = __webpack_require__(65);
+const algosdk_1 = __importDefault(__webpack_require__(241));
+const axios_1 = __importDefault(__webpack_require__(938));
+const utils_1 = __webpack_require__(185);
+class AlgodService {
+    client;
+    authCredentials;
+    indexerDomain;
+    constructor(algodClient, credentials, indexerDomain) {
+        this.client = algodClient;
+        this.authCredentials = credentials;
+        this.indexerDomain = indexerDomain;
+    }
+    isAppOptedIn(appLocalState, appId) {
+        return !!appLocalState?.find((app) => app.id === appId);
+    }
+    isAssetOptedIn(balances, assetId) {
+        return Object.keys(balances).includes(assetId.toString());
+    }
+    async optInAsset(userAddress, assetIndex) {
+        const params = await this.getTxnParams();
+        const response = algosdk_1.default.makeAssetTransferTxnWithSuggestedParamsFromObject({
+            suggestedParams: {
+                ...params,
+            },
+            from: userAddress,
+            to: userAddress,
+            assetIndex: assetIndex,
+            amount: 0,
+        });
+        return response;
+    }
+    async makeAppCallTransaction(assetIndex, senderAddress, appId, args, params) {
+        const accounts = [];
+        const foreignApps = [];
+        const foreignAssets = [assetIndex];
+        const txn = algosdk_1.default.makeApplicationNoOpTxn(senderAddress, params || await this.getTxnParams(), appId, args, accounts, foreignApps, foreignAssets);
+        return txn;
+    }
+    makeTransferTransaction(params, assetIndex, transferAmount, senderAddress, appAddress) {
+        if (transferAmount <= 0)
+            return null;
+        const txn_params = {
+            suggestedParams: {
+                ...params,
+            },
+            from: senderAddress,
+            to: appAddress,
+            amount: transferAmount,
+        };
+        if (assetIndex === 0) {
+            return algosdk_1.default.makePaymentTxnWithSuggestedParamsFromObject(txn_params);
+        }
+        txn_params.assetIndex = assetIndex;
+        return algosdk_1.default.makeAssetTransferTxnWithSuggestedParamsFromObject(
+        // @ts-ignore
+        txn_params);
+    }
+    get signer() {
+        return this.authCredentials.signer;
+    }
+    set signer(value) {
+        this.authCredentials.signer = value;
+    }
+    async signAndSend(txnGroup) {
+        if (!Array.isArray(txnGroup))
+            txnGroup = [txnGroup];
+        const recoveredAccount = this.getCurrentAccount();
+        if (recoveredAccount) {
+            const signedTxns = txnGroup.map((txn) => txn.signTxn(recoveredAccount.sk));
+            return this.client.sendRawTransaction(signedTxns).do();
+        }
+        return this.authCredentials.signer.signAndSend(txnGroup);
+    }
+    async signAndSendData(data, signMessage, sendAction, encoding) {
+        const message = typeof data === "string" ? data : JSON.stringify(data);
+        const payload = typeof data === "string" ? { message } : { ...data };
+        const signature = await signMessage(message, encoding);
+        return sendAction({
+            ...payload,
+            signature: signature
+        });
+    }
+    async getTxnParams() {
+        return await (0, algo_helper_1.getTxnParams)(this.client);
+    }
+    getCurrentAccount() {
+        if (!this.authCredentials.mnemonic)
+            return null;
+        return algosdk_1.default.mnemonicToSecretKey(this.authCredentials.mnemonic);
+    }
+    async getAccountInfo(address) {
+        return this.client.accountInformation(address).do();
+    }
+    constructArgsForAppCall(...args) {
+        const appArgs = [];
+        args.forEach((elem) => {
+            appArgs.push(new Uint8Array(elem.toBuffer ? elem.toBuffer() : Buffer.from(elem.toString())));
+        });
+        return appArgs;
+    }
+    validateCredentials() {
+        if (!this.authCredentials.mnemonic && !this.authCredentials.signer) {
+            throw 'You need specify mnemonic or signer to execute the method';
+        }
+    }
+    async getAppState(appId) {
+        try {
+            const app = await this.client.getApplicationByID(appId).do();
+            const globalState = (0, algo_helper_1.decodeStateArray)(app['params']['global-state']);
+            return globalState;
+        }
+        catch (error) {
+            console.log(`Attempt to load app by id ${appId}`);
+            console.log(error.message);
+        }
+    }
+    async getSuperAppId(appId) {
+        const state = await this.getAppState(appId);
+        return state?.['UL_SUPERADMIN_APP'] || 0;
+    }
+    async getPairBalances(appId, address) {
+        const { data } = await axios_1.default.get(`${this.indexerDomain}/v2/accounts/${address}?include-all=true`);
+        if (data.account.hasOwnProperty('apps-local-state')) {
+            const state = data.account['apps-local-state'].find((el) => el.id === appId && el.deleted === false);
+            if (!state) {
+                return null;
+            }
+            const key = state['key-value'].find((el) => el.key === 'YWNjb3VudEluZm8=');
+            const uintArray = Buffer.from(key.value.bytes, 'base64');
+            return (0, utils_1.unpackData)(uintArray);
+        }
+    }
+    async calculateTransferAmount(appId, address, side, quantity, price, decimal) {
+        const pairBalances = await this.getPairBalances(appId, address);
+        const availableBalance = (side === 'B'
+            ? pairBalances?.priceCoin_available
+            : pairBalances?.baseCoin_available) ?? 0;
+        if (side === 'B') {
+            quantity = (quantity / 10 ** decimal) * price;
+        }
+        const transferAmount = Math.ceil(quantity - availableBalance);
+        if (transferAmount < 0) {
+            return 0;
+        }
+        return transferAmount;
+    }
+}
+exports.AlgodService = AlgodService;
+
+
+/***/ }),
+
+/***/ 734:
+/***/ ((__unused_webpack_module, exports) => {
+
+
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports.SOCIAL_ACTION_SOURCE = exports.PRIVATE_STREAMS = exports.STREAMS = exports.ORDER_STATUS = exports.DIRECT_SETTLE = void 0;
+var DIRECT_SETTLE;
+(function (DIRECT_SETTLE) {
+    DIRECT_SETTLE["YES"] = "Y";
+    DIRECT_SETTLE["NO"] = "N";
+})(DIRECT_SETTLE || (exports.DIRECT_SETTLE = DIRECT_SETTLE = {}));
+var ORDER_STATUS;
+(function (ORDER_STATUS) {
+    ORDER_STATUS[ORDER_STATUS["OPEN_ORDER"] = 1] = "OPEN_ORDER";
+    ORDER_STATUS[ORDER_STATUS["CANCELLED"] = 2] = "CANCELLED";
+    ORDER_STATUS[ORDER_STATUS["MATCHED"] = 3] = "MATCHED";
+    ORDER_STATUS[ORDER_STATUS["SELF_MATCHED"] = 4] = "SELF_MATCHED";
+})(ORDER_STATUS || (exports.ORDER_STATUS = ORDER_STATUS = {}));
+var STREAMS;
+(function (STREAMS) {
+    STREAMS[STREAMS["QUOTE"] = 1] = "QUOTE";
+    STREAMS[STREAMS["LAST_PRICE"] = 2] = "LAST_PRICE";
+    STREAMS[STREAMS["DEPTH"] = 3] = "DEPTH";
+    STREAMS[STREAMS["LAST_CANDLESTICK"] = 4] = "LAST_CANDLESTICK";
+    STREAMS[STREAMS["ORDERS"] = 5] = "ORDERS";
+    STREAMS[STREAMS["TRADES"] = 6] = "TRADES";
+    STREAMS[STREAMS["SYSTEM"] = 7] = "SYSTEM";
+    STREAMS[STREAMS["WALLET_TRANSACTIONS"] = 8] = "WALLET_TRANSACTIONS";
+    STREAMS[STREAMS["ALL_STAT"] = 9] = "ALL_STAT";
+    STREAMS[STREAMS["CODEX_ASSETS"] = 12] = "CODEX_ASSETS";
+    STREAMS[STREAMS["CODEX_BALANCES"] = 10] = "CODEX_BALANCES";
+    STREAMS[STREAMS["LAST_LOOK"] = 11] = "LAST_LOOK";
+    STREAMS[STREAMS["SETTINGS_UPDATE"] = 13] = "SETTINGS_UPDATE";
+    STREAMS[STREAMS["NEW_NOTIFICATION"] = 14] = "NEW_NOTIFICATION";
+    STREAMS[STREAMS["POINT_SYSTEM_SETTINGS_UPDATE"] = 15] = "POINT_SYSTEM_SETTINGS_UPDATE";
+})(STREAMS || (exports.STREAMS = STREAMS = {}));
+exports.PRIVATE_STREAMS = [
+    STREAMS.ORDERS,
+    STREAMS.WALLET_TRANSACTIONS,
+    STREAMS.CODEX_BALANCES,
+    STREAMS.LAST_LOOK,
+];
+var SOCIAL_ACTION_SOURCE;
+(function (SOCIAL_ACTION_SOURCE) {
+    SOCIAL_ACTION_SOURCE["COMPANY"] = "COMPANY";
+    SOCIAL_ACTION_SOURCE["TWITTER"] = "TWITTER";
+    SOCIAL_ACTION_SOURCE["DISCORD"] = "DISCORD";
+    SOCIAL_ACTION_SOURCE["TELEGRAM"] = "TELEGRAM";
+})(SOCIAL_ACTION_SOURCE || (exports.SOCIAL_ACTION_SOURCE = SOCIAL_ACTION_SOURCE = {}));
+
+
+/***/ }),
+
+/***/ 845:
+/***/ ((module) => {
+
+module.exports = require("@ultrade/shared/helpers/codex.helper");
+
+/***/ }),
+
+/***/ 938:
+/***/ ((module) => {
+
+module.exports = require("axios");
+
+/***/ }),
+
+/***/ 985:
+/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
+
+
+// @ts-nocheck
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports.Client = void 0;
+const axios_1 = __importDefault(__webpack_require__(938));
+const constants_1 = __webpack_require__(193);
+const index_1 = __webpack_require__(10);
+const codex_helper_1 = __webpack_require__(845);
+const withdraw_helper_1 = __webpack_require__(566);
+const sockets_1 = __webpack_require__(382);
+const algodService_1 = __webpack_require__(726);
+const enums_1 = __webpack_require__(734);
+const localStorage_1 = __webpack_require__(610);
+const interfaces_1 = __webpack_require__(524);
+const interfaces_2 = __webpack_require__(524);
+const enums_2 = __webpack_require__(186);
+const index_2 = __webpack_require__(230);
+const DEFAULT_LOGIN_MESSAGE = `By signing this message you are logging into your trading account and agreeing to all terms and conditions of the platform.`;
+class Client {
+    client;
+    algodNode;
+    algodIndexer;
+    apiUrl;
+    companyId;
+    websocketUrl;
+    wallet;
+    _axios;
+    localStorageService;
+    isUltradeID;
+    socketManager;
+    constructor(options, authCredentials) {
+        if (options.network === "mainnet") {
+            this.algodNode = 'https://mainnet-api.algonode.cloud';
+            this.apiUrl = 'https://mainnet-api.algonode.cloud';
+            this.algodIndexer = 'https://mainnet-idx.algonode.cloud';
+        }
+        else if (options.network === "testnet") {
+            this.apiUrl = "https://testnet-apigw.ultradedev.net";
+            this.algodNode = 'https://testnet-api.algonode.cloud';
+            this.algodIndexer = 'https://testnet-idx.algonode.cloud';
+        }
+        else {
+            this.apiUrl = "http://localhost:5001";
+            this.algodNode = 'http://localhost:4001';
+            this.algodIndexer = 'http://localhost:8980';
+        }
+        if (options.apiUrl !== undefined) {
+            this.apiUrl = options.apiUrl;
+        }
+        if (options.companyId !== undefined) {
+            this.companyId = options.companyId;
+        }
+        this.websocketUrl = options.websocketUrl;
+        this.client = new algodService_1.AlgodService(options.algoSdkClient, authCredentials || {}, this.algodIndexer);
+        this._axios = this.axiosInterceptor(axios_1.default.create({
+            baseURL: this.apiUrl,
+        }));
+        this.localStorageService = new localStorage_1.LocalStorageService();
+        this.wallet = this.localStorageService.getMainWallet();
+        this.isUltradeID = false;
+        this.socketManager = new sockets_1.SocketManager(this.websocketUrl, options.socketIO, (socketId) => {
+            console.log(`Socket ${socketId} disconnected at`, new Date());
+        }, (err) => {
+            console.log(`Socket connect_error due to ${err}`);
+        });
+        console.log('SDK Wallet', this.wallet);
+    }
+    axiosInterceptor = (axios) => {
+        const tokenizedUrls = [
+            '/market/balances',
+            '/market/order',
+            '/market/orders',
+            '/market/account/kyc/status',
+            '/market/account/kyc/init',
+            '/market/withdrawal-fee',
+            '/market/operation-details',
+            '/wallet/key',
+            '/wallet/transactions',
+            '/wallet/transfer',
+            '/wallet/withdraw',
+            '/wallet/whitelist',
+            '/wallet/withdrawal-wallets',
+        ];
+        const tokenRequired = (config) => {
+            return config.withWalletCredentials || tokenizedUrls.some(value => config.url.includes(value));
+        };
+        const tradingKeyRequired = (config) => {
+            const urls = [
+                '/market/order',
+                // '/wallet/transfer',
+            ];
+            return config.withWalletCredentials || urls.some(value => config.url.includes(value));
+        };
+        const companyIdRequired = (config) => {
+            const urls = [
+                '/wallet/signin',
+                '/market/account/kyc/init',
+                '/notifications'
+            ];
+            return urls.some(value => config.url.includes(value));
+        };
+        const isSocialRequest = (config) => {
+            const urls = [
+                '/social/',
+            ];
+            return urls.some(value => config.url.includes(value));
+        };
+        const ifCollectStatistic = (config) => {
+            return tokenizedUrls.some(value => config.url.includes(value));
+        };
+        axios.interceptors.request.use((config) => {
+            if (this.wallet && tokenRequired(config)) {
+                config.headers['X-Wallet-Address'] = this.wallet.address;
+                config.headers['X-Wallet-Token'] = this.wallet.token;
+            }
+            if (this.wallet && ifCollectStatistic(config)) {
+                config.headers['CompanyId'] = this.companyId;
+            }
+            if (this.wallet && tradingKeyRequired(config)) {
+                const tradingKey = this.wallet?.tradingKey;
+                if (tradingKey) {
+                    config.headers['X-Trading-Key'] = tradingKey;
+                }
+            }
+            if (companyIdRequired(config)) {
+                config.headers['CompanyId'] = this.companyId;
+            }
+            if (isSocialRequest(config) && !config.headers.CompanyId) {
+                config.headers['CompanyId'] = this.isUltradeID ? 1 : this.companyId;
+            }
+            return config;
+        }, (error) => Promise.reject(error));
+        //Add a response interceptor
+        axios.interceptors.response.use((response) => {
+            return response.data;
+        }, async (error) => {
+            console.log('Request was failed', error);
+            const invalidToken = [401].includes(error?.response?.status);
+            if (invalidToken && tokenRequired(error.config)) {
+                this.wallet = null;
+                this.localStorageService.clearMainWallet();
+            }
+            return Promise.reject(error);
+        });
+        return axios;
+    };
+    // TODO: rework emit logic in SDK UL-1257
+    // public setState(args: AppSocketState) {
+    //   return ws.emitPair(args);
+    // }
+    // public setFilter(args: AppSocketState) {
+    //   return ws.emitFilter(args);
+    // }
+    get useUltradeID() {
+        return this.isUltradeID;
+    }
+    set useUltradeID(isUltrade) {
+        this.isUltradeID = isUltrade;
+    }
+    get isLogged() {
+        return !!this.wallet?.token;
+    }
+    get mainWallet() {
+        return this.wallet;
+    }
+    set mainWallet(wallet) {
+        this.wallet = wallet;
+        if (!wallet) {
+            this.localStorageService.clearMainWallet();
+        }
+        else {
+            this.localStorageService.setMainWallet(wallet);
+        }
+    }
+    setSigner(signer) {
+        this.client.signer = signer;
+    }
+    subscribe(subscribeOptions, callback) {
+        const requiresAuth = subscribeOptions.streams.some(stream => enums_1.PRIVATE_STREAMS.includes(stream));
+        if (requiresAuth && !this.mainWallet?.token && !this.mainWallet?.tradingKey) {
+            subscribeOptions.streams = subscribeOptions.streams.filter(stream => !enums_1.PRIVATE_STREAMS.includes(stream));
+            return this.socketManager.subscribe(subscribeOptions, callback);
+        }
+        if (requiresAuth) {
+            subscribeOptions.options = {
+                ...subscribeOptions.options,
+                token: this.mainWallet?.token,
+                tradingKey: this.mainWallet?.tradingKey
+            };
+            return this.socketManager.subscribe(subscribeOptions, callback);
+        }
+        return this.socketManager.subscribe(subscribeOptions, callback);
+    }
+    unsubscribe(handlerId) {
+        this.socketManager.unsubscribe(handlerId);
+    }
+    getPairList(companyId) {
+        const query = companyId ? `&companyId=${companyId}` : "";
+        return this._axios.get(`/market/markets?includeAllOrders=false${query}`);
+    }
+    getExchangeInfo(symbol) {
+        return this._axios.get(`/market/market?symbol=${symbol}`);
+    }
+    getPrice(symbol) {
+        return this._axios.get(`/market/price?symbol=${symbol}`);
+    }
+    getDepth(symbol, depth) {
+        return this._axios.get(`/market/depth?symbol=${symbol}&depth=${depth}`);
+    }
+    getSymbols(mask) {
+        return this._axios.get(`/market/symbols${mask ? '?mask=' + mask : ''}`);
+    }
+    getLastTrades(symbol) {
+        return this._axios.get(`/market/last-trades?symbol=${symbol}`);
+    }
+    getHistory(symbol, interval, startTime, endTime, limit = 500, page = 1) {
+        return this._axios.get(`/market/history?symbol=${symbol}&interval=${interval}&startTime=${startTime ?? ""}&endTime=${endTime ?? ""}&limit=${limit}&page=${page}`);
+    }
+    getOrders(symbol, status, limit = 50, endTime, startTime) {
+        const statusStr = !status
+            ? ""
+            : (status === 1)
+                ? enums_2.OrderStatus.Open
+                : [enums_2.OrderStatus.Canceled, enums_2.OrderStatus.Matched, enums_2.OrderStatus.SelfMatched, enums_2.OrderStatus.Expired].join(',');
+        const symbolQuery = symbol ? `&symbol=${symbol}` : "";
+        const statusQuery = statusStr ? `&status=${statusStr}` : "";
+        const startTimeQuery = startTime ? `&startTime=${startTime}` : "";
+        const endTimeQuery = endTime ? `&endTime=${endTime}` : "";
+        return this._axios.get(`/market/orders?limit=${limit}${symbolQuery}${statusQuery}${startTimeQuery}${endTimeQuery}`);
+    }
+    getOrderById(orderId) {
+        return this._axios.get(`/market/order/${orderId}`);
+    }
+    getSettings() {
+        const domain = new URL((window.location !== window.parent.location) ? document.referrer : document.location.href).host;
+        return this._axios.get(`/market/settings`, { headers: { "wl-domain": domain } });
+    }
+    getBalances() {
+        return this._axios.get(`/market/balances`);
+    }
+    getChains() {
+        return this._axios.get(`/market/chains`);
+    }
+    getCodexAssets() {
+        return this._axios.get(`/market/assets`);
+    }
+    getCCTPAssets() {
+        return this._axios.get(`/market/cctp-assets`);
+    }
+    getCCTPUnifiedAssets() {
+        return this._axios.get(`/market/cctp-unified-assets`);
+    }
+    getWithdrawalFee(assetAddress, chainId) {
+        return this._axios.get(`/market/withdrawal-fee?assetAddress=${assetAddress}&chainId=${chainId}`);
+    }
+    getKycStatus() {
+        return this._axios.get(`/market/account/kyc/status`);
+    }
+    getKycInitLink(embeddedAppUrl) {
+        return this._axios.post(`/market/account/kyc/init`, { embeddedAppUrl });
+    }
+    getDollarValues(assetIds = []) {
+        return this._axios.get(`/market/dollar-price?assetIds=${JSON.stringify(assetIds)}`);
+    }
+    getTransactionDetalis(transactionId) {
+        return this._axios.get(`/market/operation-details?operationId=${transactionId}`);
+    }
+    //#region Wallet
+    getWalletTransactions(type, page, limit = 100) {
+        return this._axios.get(`/wallet/transactions?type=${type}&limit=${limit}&page=${page}`, { withWalletCredentials: true });
+    }
+    getTradingKeys() {
+        return this._axios.get(`/wallet/keys`, { withWalletCredentials: true });
+    }
+    getTransfers(page, limit = 100) {
+        return this._axios.get(`/wallet/transfers?limit=${limit}&page=${page}`, { withWalletCredentials: true });
+    }
+    getPendingTransactions() {
+        return this._axios.get(`/wallet/transactions/pending`, { withWalletCredentials: true });
+    }
+    getWhitelist() {
+        return this._axios.get(`/wallet/whitelist`, { withWalletCredentials: true });
+    }
+    addWhitelist(data) {
+        const encoding = 'hex';
+        data = {
+            ...data,
+            expiredDate: data.expiredDate && Math.round(data.expiredDate / 1000)
+        };
+        const message = Buffer.from((0, index_2.makeDtwMsg)(data)).toString(encoding);
+        return this.client.signAndSendData(message, this.client.signer.signMessage, ({ signature }) => this._axios.post(`/wallet/whitelist`, { message, signature }), encoding);
+    }
+    deleteWhitelist(whitelistId) {
+        const data = { whitelistId };
+        return this.client.signAndSendData(data, this.client.signer.signMessage, ({ signature }) => this._axios.delete(`/wallet/whitelist`, {
+            data: { data, signature }
+        }));
+    }
+    getAllWithdrawalWallets() {
+        return this._axios.get(`/wallet/withdrawal-wallets`);
+    }
+    getWithdrawalWalletByAddress(address) {
+        return this._axios.get(`/wallet/withdrawal-wallets/${address}`);
+    }
+    createWithdrawalWallet(body) {
+        return this._axios.post(`/wallet/withdrawal-wallets`, body);
+    }
+    updateWithdrawalWallet(params) {
+        return this._axios.patch(`/wallet/withdrawal-wallets`, params);
+    }
+    deleteWithdrawalWallet(address) {
+        return this._axios.delete(`/wallet/withdrawal-wallets/${address}`);
+    }
+    //#endregion Wallet
+    //#region System
+    getVersion() {
+        return this._axios.get(`/system/version`);
+    }
+    getMaintenance() {
+        return this._axios.get(`/system/maintenance`);
+    }
+    getNotifications() {
+        return this._axios.get(`/notifications`, { withWalletCredentials: true });
+    }
+    getNotificationsUnreadCount() {
+        return this._axios.get(`/notifications/count`, { withWalletCredentials: true });
+    }
+    readNotifications(notifications) {
+        return this._axios.put(`/notifications`, { notifications }, { withWalletCredentials: true });
+    }
+    //#endregion System
+    //#region Affiliates
+    getAffiliatesStatus(companyId) {
+        return this._axios.get(`/affiliates/${companyId}/dashboardStatus`, { withWalletCredentials: true });
+    }
+    createAffiliate(companyId) {
+        return this._axios.post(`/affiliates/${companyId}`, {}, { withWalletCredentials: true });
+    }
+    getAffiliateProgress(companyId) {
+        return this._axios.get(`/affiliates/${companyId}/tradingVolumeProgress`, { withWalletCredentials: true });
+    }
+    getAffiliateInfo(companyId, range) {
+        return this._axios.get(`/affiliates/${companyId}/dashboard?range=${range}`, { withWalletCredentials: true });
+    }
+    countAffiliateDepost(companyId) {
+        return this._axios.post(`/affiliates/${companyId}/deposit `, {}, { withWalletCredentials: true });
+    }
+    countAffiliateClick(referralToken) {
+        return this._axios.post(`/affiliates/click`, { referralToken }, { withWalletCredentials: true });
+    }
+    //#endregion Affiliates
+    //#region Social
+    getSocialAccount() {
+        return this._axios.get(`/social/account`, { withWalletCredentials: true });
+    }
+    addSocialEmail(email, embeddedAppUrl) {
+        return this._axios.put(`/social/account/email`, { email, embeddedAppUrl }, { withWalletCredentials: true });
+    }
+    verifySocialEmail(email, hash) {
+        return this._axios.put(`/social/account/verifyEmail`, { email, hash }, { withWalletCredentials: true });
+    }
+    getLeaderboards() {
+        return this._axios.get(`/social/leaderboard`, { withWalletCredentials: true });
+    }
+    getUnlocks() {
+        return this._axios.get(`/social/unlocks`, { withWalletCredentials: true });
+    }
+    getSocialSettings() {
+        return this._axios.get(`/social/settings`, { withWalletCredentials: true });
+    }
+    getSeason(ultradeId) {
+        return this._axios.get(`/social/seasons/active`, {
+            withWalletCredentials: true,
+            headers: { "CompanyId": ultradeId }
+        });
+    }
+    getPastSeasons() {
+        return this._axios.get(`/social/seasons/history`, { withWalletCredentials: true });
+    }
+    //#region Telegram
+    addTelegram(data) {
+        return this._axios.post(`/social/telegram/connect`, data, { withWalletCredentials: true });
+    }
+    disconnectTelegram(data) {
+        return this._axios.put(`/social/telegram/disconnect`, data, { withWalletCredentials: true });
+    }
+    //#endregion Telegram
+    //#region Discord
+    getDiscordConnectionUrl(url) {
+        const query = url ? `?embeddedAppUrl=${encodeURIComponent(url)}` : "";
+        return this._axios.get(`/social/discord/connect${query}`, { withWalletCredentials: true })
+            .then(({ url }) => url);
+    }
+    disconnectDiscord() {
+        return this._axios.put(`/social/discord/disconnect`, {}, { withWalletCredentials: true });
+    }
+    //#endregion Discord
+    //#region Twitter
+    getTwitterConnectionUrl(appUrl, permissions) {
+        const queryURL = appUrl ? `?embeddedAppUrl=${encodeURIComponent(appUrl)}` : "";
+        const queryPermissions = permissions ? `&scopes=${permissions}` : "";
+        return this._axios.get(`/social/twitter/connect${queryURL}${queryPermissions}`, { withWalletCredentials: true })
+            .then(({ url }) => url);
+    }
+    disconnectTwitter() {
+        return this._axios.put(`/social/twitter/disconnect`, {}, { withWalletCredentials: true });
+    }
+    getTweets() {
+        return this._axios.get(`/social/twitter/tweets`, { withWalletCredentials: true });
+    }
+    actionWithTweet(data) {
+        return this._axios.post(`/social/twitter/tweet/actions`, data, { withWalletCredentials: true });
+    }
+    async getActions() {
+        return this._axios.get(`/social/actions`, { withWalletCredentials: true });
+    }
+    async getActionHistory() {
+        return this._axios.get(`/social/actions/history`, { withWalletCredentials: true });
+    }
+    getAIStyles() {
+        return this._axios.get(`/social/twitter/tweets/styles`, { withWalletCredentials: true });
+    }
+    getAIComment(styleId, tweetId) {
+        return this._axios.get(`/social/twitter/tweets/${tweetId}/generateComment?styleId=${styleId}`, { withWalletCredentials: true });
+    }
+    //#endregion Twitter
+    //#endregion Social
+    getTechnologyByProvider(provider) {
+        switch (provider) {
+            case interfaces_2.PROVIDERS.PERA:
+                return "ALGORAND";
+            case interfaces_2.PROVIDERS.METAMASK:
+                return "EVM";
+            case interfaces_2.PROVIDERS.SOLFLARE:
+            case interfaces_2.PROVIDERS.COINBASE:
+            case interfaces_2.PROVIDERS.PHANTOM:
+            case interfaces_2.PROVIDERS.BACKPACK:
+            case interfaces_2.PROVIDERS.MOBILE:
+                return "SOLANA";
+            default: throw new Error("Not implemented");
+        }
+    }
+    login({ address, provider, chain, referralToken, loginMessage }) {
+        const encoding = 'hex';
+        const signingMessage = loginMessage || DEFAULT_LOGIN_MESSAGE;
+        const data = {
+            address,
+            technology: this.getTechnologyByProvider(provider),
+        };
+        const message = Buffer.from((0, codex_helper_1.makeLoginMsg)(data, signingMessage)).toString(encoding);
+        return this.client.signAndSendData(message, this.client.signer.signMessage, ({ signature }) => this._axios.put(`/wallet/signin`, { data, message, encoding, signature, referralToken })
+            .then((token) => {
+            this.mainWallet = { address, provider, token, chain };
+            return token;
+        }), encoding);
+    }
+    addTradingKey(data) {
+        const encoding = 'hex';
+        const message = Buffer.from((0, codex_helper_1.makeTradingKeyMsg)(data, true)).toString(encoding);
+        const { device, type } = data;
+        return this.client.signAndSendData(message, this.client.signer.signMessage, ({ signature }) => this._axios.post(`/wallet/key`, {
+            data: { device, type }, encoding, message, signature
+        })
+            .then((tradingKey) => {
+            if (this.mainWallet && tradingKey.type === interfaces_1.TradingKeyType.User) {
+                this.mainWallet.tradingKey = tradingKey.address;
+            }
+            return tradingKey;
+        }), encoding);
+    }
+    revokeTradingKey(data) {
+        const encoding = 'hex';
+        const message = Buffer.from((0, codex_helper_1.makeTradingKeyMsg)(data, false)).toString(encoding);
+        const { device, type } = data;
+        return this.client.signAndSendData(message, this.client.signer.signMessage, ({ signature }) => this._axios.delete(`/wallet/key`, {
+            data: { data: { device, type }, encoding, message, signature }
+        })
+            .then(() => {
+            if (this.mainWallet && data.tkAddress === this.mainWallet.tradingKey) {
+                this.mainWallet.tradingKey = undefined;
+            }
+        }), encoding);
+    }
+    withdraw(withdrawData, prettyMsg) {
+        const encoding = 'hex';
+        const data = {
+            ...withdrawData,
+            random: (0, index_1.getRandomInt)(1, Number.MAX_SAFE_INTEGER),
+        };
+        const message = Buffer.from((0, withdraw_helper_1.makeWithdrawMsg)(data, prettyMsg)).toString(encoding);
+        return this.client.signAndSendData(message, this.client.signer.signMessage, ({ signature }) => this._axios.post(`/wallet/withdraw`, { encoding, message, signature, destinationAddress: data.recipient }), encoding);
+    }
+    transfer(transferData) {
+        const encoding = 'hex';
+        const data = {
+            ...transferData,
+            random: (0, index_1.getRandomInt)(1, Number.MAX_SAFE_INTEGER),
+        };
+        const message = Buffer.from((0, index_2.makeTransferMsg)(data)).toString(encoding);
+        return this.client.signAndSendData(message, this.client.signer.signMessage, ({ signature }) => this._axios.post(`/wallet/transfer`, { message, signature }), encoding);
+    }
+    async createOrder(order) {
+        const _daysInSec = constants_1.DEFAULT_ORDER_EXPIRATION_DAYS * 24 * 60 * 60;
+        const expiredTime = Math.floor(Date.now() / 1000) + _daysInSec;
+        const data = {
+            ...order,
+            version: constants_1.ORDER_MSG_VERSION,
+            expiredTime,
+            random: (0, index_1.getRandomInt)(1, Number.MAX_SAFE_INTEGER),
+        };
+        console.log('CreateOrderData', data);
+        const encoding = 'hex';
+        const message = Buffer.from((0, codex_helper_1.makeCreateOrderMsg)(data)).toString(encoding);
+        return await this.client.signAndSendData(message, this.client.signer.signMessageByToken, ({ signature }) => this._axios.post(`/market/order`, { encoding, message, signature }), encoding);
+    }
+    async cancelOrder(order) {
+        const data = { orderId: order.orderId };
+        const encoding = 'hex';
+        const message = Buffer.from((0, codex_helper_1.getCancelOrderDataJsonBytes)(order)).toString(encoding);
+        return this.client.signAndSendData(message, this.client.signer.signMessageByToken, ({ signature }) => this._axios.delete(`/market/order`, {
+            data: { data, message, signature }
+        }), encoding);
+    }
+    async cancelMultipleOrders({ orderIds, pairId }) {
+        const data = { orderIds, pairId };
+        return this.client.signAndSendData(data, this.client.signer.signMessageByToken, ({ signature }) => this._axios.delete(`/market/orders`, {
+            data: { data, signature }
+        }));
+    }
+    async ping() {
+        const data = this._axios.get(`/system/time`);
+        return Math.round(Date.now() - data.currentTime);
+    }
+}
+exports.Client = Client;
+
+
+/***/ })
+
+/******/ 	});
+/************************************************************************/
+/******/ 	// 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__(156);
+/******/ 	module.exports = __webpack_exports__;
+/******/ 	
+/******/ })()
+;