metaapi.cloud-sdk
Version:
SDK for MetaApi, a professional cloud forex API which includes MetaTrader REST API and MetaTrader websocket API. Supports both MetaTrader 5 (MT5) and MetaTrader 4 (MT4). CopyFactory copy trading API included. (https://metaapi.cloud)
2,360 lines • 367 kB
JavaScript
'use strict';
function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
try {
var info = gen[key](arg);
var value = info.value;
} catch (error) {
reject(error);
return;
}
if (info.done) {
resolve(value);
} else {
Promise.resolve(value).then(_next, _throw);
}
}
function _async_to_generator(fn) {
return function() {
var self = this, args = arguments;
return new Promise(function(resolve, reject) {
var gen = fn.apply(self, args);
function _next(value) {
asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value);
}
function _throw(err) {
asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err);
}
_next(undefined);
});
};
}
function _define_property(obj, key, value) {
if (key in obj) {
Object.defineProperty(obj, key, {
value: value,
enumerable: true,
configurable: true,
writable: true
});
} else {
obj[key] = value;
}
return obj;
}
function _object_spread(target) {
for(var i = 1; i < arguments.length; i++){
var source = arguments[i] != null ? arguments[i] : {};
var ownKeys = Object.keys(source);
if (typeof Object.getOwnPropertySymbols === "function") {
ownKeys = ownKeys.concat(Object.getOwnPropertySymbols(source).filter(function(sym) {
return Object.getOwnPropertyDescriptor(source, sym).enumerable;
}));
}
ownKeys.forEach(function(key) {
_define_property(target, key, source[key]);
});
}
return target;
}
import randomstring from 'randomstring';
import socketIO from 'socket.io-client';
import TimeoutError from '../timeoutError';
import { ValidationError, NotFoundError, InternalError, UnauthorizedError, TooManyRequestsError, ForbiddenError } from '../errorHandler';
import OptionsValidator from '../optionsValidator';
import NotSynchronizedError from './notSynchronizedError';
import NotConnectedError from './notConnectedError';
import TradeError from './tradeError';
import PacketOrderer from './packetOrderer';
import SynchronizationThrottler from './synchronizationThrottler';
import SubscriptionManager from './subscriptionManager';
import LoggerManager from '../../logger';
import any from 'promise.any';
import LatencyService from './latencyService';
import _ from 'lodash';
export * from './metaApiWebsocket.client.schemas';
let PacketLogger;
if (typeof window === 'undefined') {
PacketLogger = require('./packetLogger').default;
}
/**
* MetaApi websocket API client (see https://metaapi.cloud/docs/client/websocket/overview/)
*/ let MetaApiWebsocketClient = class MetaApiWebsocketClient {
/**
* Restarts the account synchronization process on an out of order packet
* @param {String} accountId account id
* @param {Number} instanceIndex instance index
* @param {Number} expectedSequenceNumber expected s/n
* @param {Number} actualSequenceNumber actual s/n
* @param {Object} packet packet data
* @param {Date} receivedAt time the packet was received at
*/ onOutOfOrderPacket(accountId, instanceIndex, expectedSequenceNumber, actualSequenceNumber, packet, receivedAt) {
const primaryAccountId = this._accountsByReplicaId[accountId];
if (this._subscriptionManager.isSubscriptionActive(accountId)) {
const level = this._latencyService.getSynchronizedAccountInstances(primaryAccountId).length ? 'debug' : 'error';
this._logger[level]('MetaApi websocket client received an out of order ' + `packet type ${packet.type} for account id ${accountId}:${instanceIndex}. Expected s/n ` + `${expectedSequenceNumber} does not match the actual of ${actualSequenceNumber}`);
this.ensureSubscribe(accountId, instanceIndex);
}
}
/**
* Patch server URL for use in unit tests
* @param {String} url patched server URL
*/ set url(url) {
this._url = url;
}
/**
* Websocket client predefined region
* @returns {String} predefined region
*/ get region() {
return this._region;
}
/**
* Returns the list of socket instance dictionaries
* @return {Object[]} list of socket instance dictionaries
*/ get socketInstances() {
return this._socketInstances;
}
/**
* Returns the dictionary of socket instances by account ids
* @return {Object} dictionary of socket instances by account ids
*/ get socketInstancesByAccounts() {
return this._socketInstancesByAccounts;
}
/**
* Returns the dictionary of account replicas by region
* @return {Object} dictionary of account replicas by region
*/ get accountReplicas() {
return this._accountReplicas;
}
/**
* Returns the dictionary of primary account ids by replica ids
* @return {Object} dictionary of primary account ids by replica ids
*/ get accountsByReplicaId() {
return this._accountsByReplicaId;
}
/**
* Returns clear account cache job. Used for tests
* @return {Function} clear account cache job
*/ get clearAccountCacheJob() {
return this._clearAccountCacheJob.bind(this);
}
/**
* Returns latency service
* @returns {LatencyService} latency service
*/ get latencyService() {
return this._latencyService;
}
/**
* Returns the list of subscribed account ids
* @param {Number} instanceNumber instance index number
* @param {String} socketInstanceIndex socket instance index
* @param {String} region server region
* @return {string[]} list of subscribed account ids
*/ subscribedAccountIds(instanceNumber, socketInstanceIndex, region) {
const connectedIds = [];
if (this._socketInstancesByAccounts[instanceNumber]) {
Object.keys(this._connectedHosts).forEach((instanceId)=>{
const accountId = instanceId.split(':')[0];
const accountRegion = this.getAccountRegion(accountId);
if (!connectedIds.includes(accountId) && this._socketInstancesByAccounts[instanceNumber][accountId] !== undefined && (this._socketInstancesByAccounts[instanceNumber][accountId] === socketInstanceIndex || socketInstanceIndex === undefined) && accountRegion === region) {
connectedIds.push(accountId);
}
});
}
return connectedIds;
}
/**
* Returns websocket client connection status
* @param {Number} instanceNumber instance index number
* @param {Number} socketInstanceIndex socket instance index
* @param {String} region server region
* @returns {Boolean} websocket client connection status
*/ connected(instanceNumber, socketInstanceIndex, region) {
const instance = this._socketInstances[region] && this._socketInstances[region][instanceNumber].length > socketInstanceIndex ? this._socketInstances[region][instanceNumber][socketInstanceIndex] : null;
return instance && instance.socket && instance.socket.connected || false;
}
/**
* Returns list of accounts assigned to instance
* @param {Number} instanceNumber instance index number
* @param {String} socketInstanceIndex socket instance index
* @param {String} region server region
* @returns
*/ _getAssignedAccounts(instanceNumber, socketInstanceIndex, region) {
const accountIds = [];
Object.keys(this._socketInstancesByAccounts[instanceNumber]).forEach((key)=>{
const accountRegion = this.getAccountRegion(key);
if (accountRegion === region && this._socketInstancesByAccounts[instanceNumber][key] === socketInstanceIndex) {
accountIds.push(key);
}
});
return accountIds;
}
/**
* Returns account region by id
* @param {String} accountId account id
* @returns {String} account region
*/ getAccountRegion(accountId) {
return this._regionsByAccounts[accountId] && this._regionsByAccounts[accountId].region;
}
/**
* Adds account cache info
* @param {String} accountId account id
* @param {Object} replicas account replicas, including primary replica
*/ addAccountCache(accountId, replicas) {
this._accountReplicas[accountId] = replicas;
Object.keys(replicas).forEach((region)=>{
const replicaId = replicas[region];
if (!this._regionsByAccounts[replicaId]) {
this._regionsByAccounts[replicaId] = {
region,
connections: 1,
lastUsed: Date.now()
};
} else {
this._regionsByAccounts[replicaId].connections++;
}
this._accountsByReplicaId[replicaId] = accountId;
});
this._logger.debug(`${accountId}: added account cache`);
}
/**
* Updates account cache info
* @param {String} accountId account id
* @param {Object} replicas account replicas
*/ updateAccountCache(accountId, replicas) {
const oldReplicas = this._accountReplicas[accountId];
if (oldReplicas) {
const connectionCount = this._regionsByAccounts[accountId].connections;
Object.keys(oldReplicas).forEach((region)=>{
const replicaId = replicas[region];
delete this._accountsByReplicaId[replicaId];
delete this._regionsByAccounts[replicaId];
});
this._accountReplicas[accountId] = replicas;
Object.keys(replicas).forEach((region)=>{
const replicaId = replicas[region];
this._regionsByAccounts[replicaId] = {
region,
connections: connectionCount,
lastUsed: Date.now()
};
this._accountsByReplicaId[replicaId] = accountId;
});
this._logger.debug(`${accountId}: updated account cache`);
}
}
/**
* Removes account region info
* @param {String} accountId account id
*/ removeAccountCache(accountId) {
var _this__regionsByAccounts_accountId;
if (((_this__regionsByAccounts_accountId = this._regionsByAccounts[accountId]) === null || _this__regionsByAccounts_accountId === void 0 ? void 0 : _this__regionsByAccounts_accountId.connections) > 0) {
this._regionsByAccounts[accountId].connections--;
}
}
/**
* Locks subscription for a socket instance based on TooManyRequestsError metadata
* @param {Number} instanceNumber instance index number
* @param {String} socketInstanceIndex socket instance index
* @param {String} region server region
* @param {Object} metadata TooManyRequestsError metadata
*/ lockSocketInstance(instanceNumber, socketInstanceIndex, region, metadata) {
var _this = this;
return _async_to_generator(function*() {
if (metadata.type === 'LIMIT_ACCOUNT_SUBSCRIPTIONS_PER_USER') {
_this._subscribeLock = {
recommendedRetryTime: metadata.recommendedRetryTime,
lockedAtAccounts: _this.subscribedAccountIds(instanceNumber, undefined, region).length,
lockedAtTime: Date.now()
};
} else {
const subscribedAccounts = _this.subscribedAccountIds(instanceNumber, socketInstanceIndex, region);
if (subscribedAccounts.length === 0) {
const socketInstance = _this.socketInstances[region][instanceNumber][socketInstanceIndex];
socketInstance.socket.close();
yield _this._reconnect(instanceNumber, socketInstanceIndex, region);
} else {
const instance = _this.socketInstances[region][instanceNumber][socketInstanceIndex];
instance.subscribeLock = {
recommendedRetryTime: metadata.recommendedRetryTime,
type: metadata.type,
lockedAtAccounts: subscribedAccounts.length
};
}
}
})();
}
/**
* Connects to MetaApi server via socket.io protocol
* @param {Number} instanceNumber instance index number
* @param {String} region server region
* @returns {Promise} promise which resolves when connection is established
*/ connect(instanceNumber, region) {
var _this = this;
return _async_to_generator(function*() {
var _this__socketInstances, _region, _this__socketInstances_region, _instanceNumber;
if (_this._region && region !== _this._region) {
throw new ValidationError(`Trying to connect to ${region} region, but configured with ${_this._region}`);
}
let clientId = Math.random();
let resolve;
let result = new Promise((res, rej)=>{
resolve = res;
});
(_this__socketInstances = _this._socketInstances)[_region = region] || (_this__socketInstances[_region] = {});
(_this__socketInstances_region = _this._socketInstances[region])[_instanceNumber = instanceNumber] || (_this__socketInstances_region[_instanceNumber] = []);
const socketInstanceIndex = _this._socketInstances[region][instanceNumber].length;
const instance = {
id: socketInstanceIndex,
reconnectWaitTime: _this._socketMinimumReconnectTimeout,
connected: false,
requestResolves: {},
resolved: false,
connectResult: result,
sessionId: randomstring.generate(32),
isReconnecting: false,
socket: null,
synchronizationThrottler: new SynchronizationThrottler(_this, socketInstanceIndex, instanceNumber, region, _this._synchronizationThrottlerOpts),
subscribeLock: null,
instanceNumber
};
instance.connected = true;
_this._socketInstances[region][instanceNumber].push(instance);
instance.synchronizationThrottler.start();
const serverUrl = yield _this._getServerUrl(instanceNumber, socketInstanceIndex, region);
const socketInstance = socketIO(serverUrl, {
path: '/ws',
reconnection: true,
reconnectionDelay: 1000,
reconnectionDelayMax: 5000,
reconnectionAttempts: Infinity,
timeout: _this._connectTimeout,
extraHeaders: {
'Client-Id': clientId
},
query: {
'auth-token': _this._token,
clientId: clientId,
protocol: 3
}
});
instance.socket = socketInstance;
socketInstance.on('connect', /*#__PURE__*/ _async_to_generator(function*() {
// eslint-disable-next-line no-console
_this._logger.info(`${region}:${instanceNumber}: MetaApi websocket client connected to the MetaApi server`);
instance.reconnectWaitTime = _this._socketMinimumReconnectTimeout;
instance.isReconnecting = false;
if (!instance.resolved) {
instance.resolved = true;
resolve();
} else {
yield _this._fireReconnected(instanceNumber, instance.id, region);
}
if (!instance.connected) {
instance.socket.close();
}
}));
socketInstance.on('reconnect', /*#__PURE__*/ _async_to_generator(function*() {
instance.isReconnecting = false;
_this._logger.info(`${region}:${instanceNumber}: MetaApi websocket client reconnected`);
yield _this._fireReconnected(instanceNumber, instance.id, region);
}));
socketInstance.on('connect_error', function() {
var _ref = _async_to_generator(function*(err) {
// eslint-disable-next-line no-console
_this._logger.error(`${region}:${instanceNumber}: MetaApi websocket client connection error`, err);
instance.isReconnecting = false;
yield _this._reconnect(instanceNumber, instance.id, region);
});
return function(err) {
return _ref.apply(this, arguments);
};
}());
socketInstance.on('connect_timeout', function() {
var _ref = _async_to_generator(function*(timeout) {
// eslint-disable-next-line no-console
_this._logger.error(`${region}:${instanceNumber}: MetaApi websocket client connection timeout`);
instance.isReconnecting = false;
if (!instance.resolved) {
yield _this._reconnect(instanceNumber, instance.id, region);
}
});
return function(timeout) {
return _ref.apply(this, arguments);
};
}());
socketInstance.on('disconnect', function() {
var _ref = _async_to_generator(function*(reason) {
instance.synchronizationThrottler.onDisconnect();
// eslint-disable-next-line no-console
_this._logger.info(`${region}:${instanceNumber}: MetaApi websocket client disconnected from the ` + `MetaApi server because of ${reason}`);
instance.isReconnecting = false;
yield _this._reconnect(instanceNumber, instance.id, region);
});
return function(reason) {
return _ref.apply(this, arguments);
};
}());
socketInstance.on('error', function() {
var _ref = _async_to_generator(function*(error) {
// eslint-disable-next-line no-console
_this._logger.error(`${region}:${instanceNumber}: MetaApi websocket client error`, error);
instance.isReconnecting = false;
yield _this._reconnect(instanceNumber, instance.id, region);
});
return function(error) {
return _ref.apply(this, arguments);
};
}());
socketInstance.on('response', (data)=>{
if (typeof data === 'string') {
data = JSON.parse(data);
}
_this._logger.debug(()=>`${data.accountId}: Response received: ${JSON.stringify({
requestId: data.requestId,
timestamps: data.timestamps
})}`);
let requestResolve = instance.requestResolves[data.requestId] || {
resolve: ()=>{},
reject: ()=>{}
};
delete instance.requestResolves[data.requestId];
_this._convertIsoTimeToDate(data);
requestResolve.resolve(data);
if (data.timestamps && requestResolve.type) {
data.timestamps.clientProcessingFinished = new Date();
for (let listener of _this._latencyListeners){
Promise.resolve().then(()=>requestResolve.type === 'trade' ? listener.onTrade(data.accountId, data.timestamps) : listener.onResponse(data.accountId, requestResolve.type, data.timestamps)).catch((error)=>_this._logger.error('Failed to process onResponse event for account ' + data.accountId + ', request type ' + requestResolve.type, error));
}
}
});
socketInstance.on('processingError', (data)=>{
let requestResolve = instance.requestResolves[data.requestId] || {
resolve: ()=>{},
reject: ()=>{}
};
delete instance.requestResolves[data.requestId];
requestResolve.reject(_this._convertError(data));
});
// eslint-disable-next-line complexity
socketInstance.on('synchronization', function() {
var _ref = _async_to_generator(function*(data) {
var _this__regionsByAccounts, _data_accountId;
if (typeof data === 'string') {
data = JSON.parse(data);
}
if (data.instanceIndex && data.instanceIndex !== instanceNumber) {
_this._logger.trace(()=>`${data.accountId}:${data.instanceNumber}: received packet with wrong instance ` + `index via a socket with instance number of ${instanceNumber}, data=${JSON.stringify({
type: data.type,
sequenceNumber: data.sequenceNumber,
sequenceTimestamp: data.sequenceTimestamp,
synchronizationId: data.synchronizationId,
application: data.application,
host: data.host,
specificationsUpdated: data.specificationsUpdated,
positionsUpdated: data.positionsUpdated,
ordersUpdated: data.ordersUpdated,
specifications: data.specifications ? (data.specifications || []).length : undefined
})}`);
return;
}
(_this__regionsByAccounts = _this._regionsByAccounts)[_data_accountId = data.accountId] || (_this__regionsByAccounts[_data_accountId] = {
region,
connections: 0,
lastUsed: Date.now()
});
_this._logger.trace(()=>`${data.accountId}:${data.instanceIndex}: Sync packet received: ${JSON.stringify({
type: data.type,
sequenceNumber: data.sequenceNumber,
sequenceTimestamp: data.sequenceTimestamp,
synchronizationId: data.synchronizationId,
application: data.application,
host: data.host,
specificationsUpdated: data.specificationsUpdated,
positionsUpdated: data.positionsUpdated,
ordersUpdated: data.ordersUpdated,
specifications: data.specifications ? (data.specifications || []).length : undefined
})}, ` + `active listeners: ${(_this._synchronizationListeners[data.accountId] || []).length}`);
let activeSynchronizationIds = instance.synchronizationThrottler.activeSynchronizationIds;
if (!data.synchronizationId || activeSynchronizationIds.includes(data.synchronizationId)) {
if (_this._packetLogger) {
yield _this._packetLogger.logPacket(data);
}
const ignoredPacketTypes = [
'disconnected',
'status',
'keepalive'
];
if (!_this._subscriptionManager.isSubscriptionActive(data.accountId) && !ignoredPacketTypes.includes(data.type)) {
_this._logger.debug(`${data.accountId}: Packet arrived to inactive connection, attempting` + ` unsubscribe, packet: ${data.type}`);
if (_this._throttleRequest('unsubscribe', data.accountId, data.instanceIndex, _this._unsubscribeThrottlingInterval)) {
_this.unsubscribe(data.accountId).catch((err)=>{
_this._logger.warn(`${data.accountId}:${data.instanceIndex || 0}: failed to unsubscribe`, err);
});
}
return;
}
_this._convertIsoTimeToDate(data);
} else {
data.type = 'noop';
}
_this.queuePacket(instance, data);
});
return function(data) {
return _ref.apply(this, arguments);
};
}());
socketInstance.on('metadata', (data)=>{
instance.clientApiHostname = data.clientApiHostname;
});
return result;
})();
}
/**
* Closes connection to MetaApi server
*/ close() {
Object.keys(this._socketInstances).forEach((region)=>{
Object.keys(this._socketInstances[region]).forEach((instanceNumber)=>{
this._socketInstances[region][instanceNumber].forEach(function() {
var _ref = _async_to_generator(function*(instance) {
if (instance.connected) {
instance.connected = false;
yield instance.socket.close();
for (let requestResolve of Object.values(instance.requestResolves)){
requestResolve.reject(new Error('MetaApi connection closed'));
}
instance.requestResolves = {};
}
});
return function(instance) {
return _ref.apply(this, arguments);
};
}());
this._socketInstancesByAccounts[instanceNumber] = {};
this._socketInstances[region][instanceNumber] = [];
});
});
this._synchronizationListeners = {};
this._latencyListeners = [];
this._packetOrderer.stop();
}
/**
* Stops the client
*/ stop() {
clearInterval(this._clearAccountCacheInterval);
clearInterval(this._clearInactiveSyncDataInterval);
this._latencyService.stop();
}
/**
* Returns account information for a specified MetaTrader account.
* @param {String} accountId id of the MetaTrader account to return information for
* @param {GetAccountInformationOptions} [options] additional request options
* @returns {Promise<MetatraderAccountInformation>} promise resolving with account information
*/ getAccountInformation(accountId, options) {
var _this = this;
return _async_to_generator(function*() {
let response = yield _this.rpcRequest(accountId, _object_spread({
application: 'RPC',
type: 'getAccountInformation'
}, options));
return response.accountInformation;
})();
}
/**
* Returns positions for a specified MetaTrader account.
* @param {String} accountId id of the MetaTrader account to return information for
* @param {GetPositionsOptions} [options] additional request options
* @returns {Promise<Array<MetatraderPosition>} promise resolving with array of open positions
*/ getPositions(accountId, options) {
var _this = this;
return _async_to_generator(function*() {
let response = yield _this.rpcRequest(accountId, _object_spread({
application: 'RPC',
type: 'getPositions'
}, options));
return response.positions;
})();
}
/**
* Returns specific position for a MetaTrader account.
* @param {String} accountId id of the MetaTrader account to return information for
* @param {String} positionId position id
* @param {GetPositionOptions} [options] additional request options
* @return {Promise<MetatraderPosition>} promise resolving with MetaTrader position found
*/ getPosition(accountId, positionId, options) {
var _this = this;
return _async_to_generator(function*() {
let response = yield _this.rpcRequest(accountId, _object_spread({
application: 'RPC',
type: 'getPosition',
positionId
}, options));
return response.position;
})();
}
/**
* Returns open orders for a specified MetaTrader account.
* @param {String} accountId id of the MetaTrader account to return information for
* @param {GetOrdersOptions} [options] additional request options
* @return {Promise<Array<MetatraderOrder>>} promise resolving with open MetaTrader orders
*/ getOrders(accountId, options) {
var _this = this;
return _async_to_generator(function*() {
let response = yield _this.rpcRequest(accountId, _object_spread({
application: 'RPC',
type: 'getOrders'
}, options));
return response.orders;
})();
}
/**
* Returns specific open order for a MetaTrader account.
* @param {String} accountId id of the MetaTrader account to return information for
* @param {String} orderId order id (ticket number)
* @param {GetOrderOptions} [options] additional request options
* @return {Promise<MetatraderOrder>} promise resolving with metatrader order found
*/ getOrder(accountId, orderId, options) {
var _this = this;
return _async_to_generator(function*() {
let response = yield _this.rpcRequest(accountId, _object_spread({
application: 'RPC',
type: 'getOrder',
orderId
}, options));
return response.order;
})();
}
/**
* MetaTrader history orders search query response
* @typedef {Object} MetatraderHistoryOrders
* @property {Array<MetatraderOrder>} historyOrders array of history orders returned
* @property {Boolean} synchronizing flag indicating that history order initial synchronization is still in progress
* and thus search results may be incomplete
*/ /**
* Returns the history of completed orders for a specific ticket number.
* @param {String} accountId id of the MetaTrader account to return information for
* @param {String} ticket ticket number (order id)
* @returns {Promise<MetatraderHistoryOrders>} promise resolving with request results containing history orders found
*/ getHistoryOrdersByTicket(accountId, ticket) {
var _this = this;
return _async_to_generator(function*() {
let response = yield _this.rpcRequest(accountId, {
application: 'RPC',
type: 'getHistoryOrdersByTicket',
ticket
});
return {
historyOrders: response.historyOrders,
synchronizing: response.synchronizing
};
})();
}
/**
* Returns the history of completed orders for a specific position id
* @param {String} accountId id of the MetaTrader account to return information for
* @param {String} positionId position id
* @returns {Promise<MetatraderHistoryOrders>} promise resolving with request results containing history orders found
*/ getHistoryOrdersByPosition(accountId, positionId) {
var _this = this;
return _async_to_generator(function*() {
let response = yield _this.rpcRequest(accountId, {
application: 'RPC',
type: 'getHistoryOrdersByPosition',
positionId
});
return {
historyOrders: response.historyOrders,
synchronizing: response.synchronizing
};
})();
}
/**
* Returns the history of completed orders for a specific time range
* @param {String} accountId id of the MetaTrader account to return information for
* @param {Date} startTime start of time range, inclusive
* @param {Date} endTime end of time range, exclusive
* @param {Number} offset pagination offset, default is 0
* @param {Number} limit pagination limit, default is 1000
* @returns {Promise<MetatraderHistoryOrders>} promise resolving with request results containing history orders found
*/ getHistoryOrdersByTimeRange(accountId, startTime, endTime, offset = 0, limit = 1000) {
var _this = this;
return _async_to_generator(function*() {
let response = yield _this.rpcRequest(accountId, {
application: 'RPC',
type: 'getHistoryOrdersByTimeRange',
startTime,
endTime,
offset,
limit
});
return {
historyOrders: response.historyOrders,
synchronizing: response.synchronizing
};
})();
}
/**
* MetaTrader history deals search query response
* @typedef {Object} MetatraderDeals
* @property {Array<MetatraderDeal>} deals array of history deals returned
* @property {Boolean} synchronizing flag indicating that deal initial synchronization is still in progress
* and thus search results may be incomplete
*/ /**
* MetaTrader deal
* @typedef {Object} MetatraderDeal
* @property {String} id deal id (ticket number)
* @property {String} type deal type (one of DEAL_TYPE_BUY, DEAL_TYPE_SELL, DEAL_TYPE_BALANCE, DEAL_TYPE_CREDIT,
* DEAL_TYPE_CHARGE, DEAL_TYPE_CORRECTION, DEAL_TYPE_BONUS, DEAL_TYPE_COMMISSION, DEAL_TYPE_COMMISSION_DAILY,
* DEAL_TYPE_COMMISSION_MONTHLY, DEAL_TYPE_COMMISSION_AGENT_DAILY, DEAL_TYPE_COMMISSION_AGENT_MONTHLY,
* DEAL_TYPE_INTEREST, DEAL_TYPE_BUY_CANCELED, DEAL_TYPE_SELL_CANCELED, DEAL_DIVIDEND, DEAL_DIVIDEND_FRANKED,
* DEAL_TAX). See https://www.mql5.com/en/docs/constants/tradingconstants/dealproperties#enum_deal_type
* @property {String} entryType deal entry type (one of DEAL_ENTRY_IN, DEAL_ENTRY_OUT, DEAL_ENTRY_INOUT,
* DEAL_ENTRY_OUT_BY). See https://www.mql5.com/en/docs/constants/tradingconstants/dealproperties#enum_deal_entry
* @property {String} [symbol] symbol deal relates to
* @property {Number} [magic] deal magic number, identifies the EA which initiated the deal
* @property {Date} time time the deal was conducted at
* @property {String} brokerTime time time the deal was conducted at, in broker timezone, YYYY-MM-DD HH:mm:ss.SSS format
* @property {Number} [volume] deal volume
* @property {Number} [price] the price the deal was conducted at
* @property {Number} [commission] deal commission
* @property {Number} [swap] deal swap
* @property {Number} profit deal profit
* @property {String} [positionId] id of position the deal relates to
* @property {String} [orderId] id of order the deal relates to
* @property {String} [comment] deal comment. The sum of the line lengths of the comment and the clientId
* must be less than or equal to 26. For more information see https://metaapi.cloud/docs/client/clientIdUsage/
* @property {String} [brokerComment] current comment value on broker side (possibly overriden by the broker)
* @property {String} [clientId] client-assigned id. The id value can be assigned when submitting a trade and
* will be present on position, history orders and history deals related to the trade. You can use this field to bind
* your trades to objects in your application and then track trade progress. The sum of the line lengths of the
* comment and the clientId must be less than or equal to 26. For more information see
* https://metaapi.cloud/docs/client/clientIdUsage/
* @property {String} platform platform id (mt4 or mt5)
* @property {String} [reason] optional deal execution reason. One of DEAL_REASON_CLIENT, DEAL_REASON_MOBILE,
* DEAL_REASON_WEB, DEAL_REASON_EXPERT, DEAL_REASON_SL, DEAL_REASON_TP, DEAL_REASON_SO, DEAL_REASON_ROLLOVER,
* DEAL_REASON_VMARGIN, DEAL_REASON_SPLIT, DEAL_REASON_UNKNOWN. See
* https://www.mql5.com/en/docs/constants/tradingconstants/dealproperties#enum_deal_reason.
* @property {Number} [accountCurrencyExchangeRate] current exchange rate of account currency into account base
* currency (USD if you did not override it)
* @property {number} [stopLoss] deal stop loss. For MT5 opening deal this is the SL of the order opening the
* position. For MT4 deals or MT5 closing deal this is the last known position SL.
* @property {number} [takeProfit] deal take profit. For MT5 opening deal this is the TP of the order opening the
* position. For MT4 deals or MT5 closing deal this is the last known position TP.
*/ /**
* Returns history deals with a specific ticket number
* @param {String} accountId id of the MetaTrader account to return information for
* @param {String} ticket ticket number (deal id for MT5 or order id for MT4)
* @returns {Promise<MetatraderDeals>} promise resolving with request results containing deals found
*/ getDealsByTicket(accountId, ticket) {
var _this = this;
return _async_to_generator(function*() {
let response = yield _this.rpcRequest(accountId, {
application: 'RPC',
type: 'getDealsByTicket',
ticket
});
return {
deals: response.deals,
synchronizing: response.synchronizing
};
})();
}
/**
* Returns history deals for a specific position id
* @param {String} accountId id of the MetaTrader account to return information for
* @param {String} positionId position id
* @returns {Promise<MetatraderDeals>} promise resolving with request results containing deals found
*/ getDealsByPosition(accountId, positionId) {
var _this = this;
return _async_to_generator(function*() {
let response = yield _this.rpcRequest(accountId, {
application: 'RPC',
type: 'getDealsByPosition',
positionId
});
return {
deals: response.deals,
synchronizing: response.synchronizing
};
})();
}
/**
* Returns history deals with for a specific time range
* @param {String} accountId id of the MetaTrader account to return information for
* @param {Date} startTime start of time range, inclusive
* @param {Date} endTime end of time range, exclusive
* @param {Number} offset pagination offset, default is 0
* @param {Number} limit pagination limit, default is 1000
* @returns {Promise<MetatraderDeals>} promise resolving with request results containing deals found
*/ getDealsByTimeRange(accountId, startTime, endTime, offset = 0, limit = 1000) {
var _this = this;
return _async_to_generator(function*() {
let response = yield _this.rpcRequest(accountId, {
application: 'RPC',
type: 'getDealsByTimeRange',
startTime,
endTime,
offset,
limit
});
return {
deals: response.deals,
synchronizing: response.synchronizing
};
})();
}
/**
* Clears the order and transaction history of a specified application and removes the application
* @param {String} accountId id of the MetaTrader account to remove history and application for
* @return {Promise} promise resolving when the history is cleared
*/ removeApplication(accountId) {
return this.rpcRequest(accountId, {
type: 'removeApplication'
});
}
/**
* MetaTrader trade response
* @typedef {Object} MetatraderTradeResponse
* @property {Number} numericCode numeric response code, see
* https://www.mql5.com/en/docs/constants/errorswarnings/enum_trade_return_codes and
* https://book.mql4.com/appendix/errors. Response codes which indicate success are 0, 10008-10010, 10025. The rest
* codes are errors
* @property {String} stringCode string response code, see
* https://www.mql5.com/en/docs/constants/errorswarnings/enum_trade_return_codes and
* https://book.mql4.com/appendix/errors. Response codes which indicate success are ERR_NO_ERROR,
* TRADE_RETCODE_PLACED, TRADE_RETCODE_DONE, TRADE_RETCODE_DONE_PARTIAL, TRADE_RETCODE_NO_CHANGES. The rest codes are
* errors.
* @property {String} message human-readable response message
* @property {String} orderId order id which was created/modified during the trade
* @property {String} positionId position id which was modified during the trade
*/ /**
* Execute a trade on a connected MetaTrader account
* @param {String} accountId id of the MetaTrader account to execute trade for
* @param {MetatraderTrade} trade trade to execute (see docs for possible trade types)
* @param {String} [application] application to use
* @param {String} [reliability] account reliability
* @returns {Promise<MetatraderTradeResponse>} promise resolving with trade result
* @throws {TradeError} on trade error, check error properties for error code details
*/ // eslint-disable-next-line complexity
trade(accountId, trade, application, reliability) {
var _this = this;
return _async_to_generator(function*() {
let response;
if (application === 'RPC') {
response = yield _this.rpcRequest(accountId, {
type: 'trade',
trade,
application
});
} else {
response = yield _this.rpcRequestAllInstances(accountId, {
type: 'trade',
trade,
application: application || _this._application,
requestId: randomstring.generate(32)
}, reliability);
}
response.response = response.response || {};
response.response.stringCode = response.response.stringCode || response.response.description;
response.response.numericCode = response.response.numericCode !== undefined ? response.response.numericCode : response.response.error;
if ([
'ERR_NO_ERROR',
'TRADE_RETCODE_PLACED',
'TRADE_RETCODE_DONE',
'TRADE_RETCODE_DONE_PARTIAL',
'TRADE_RETCODE_NO_CHANGES'
].includes(response.response.stringCode || response.response.description)) {
return response.response;
} else {
throw new TradeError(response.response.message, response.response.numericCode, response.response.stringCode);
}
})();
}
/**
* Creates a task that ensures the account gets subscribed to the server
* @param {String} accountId account id to subscribe
* @param {Number} instanceNumber instance index number
*/ ensureSubscribe(accountId, instanceNumber) {
this._subscriptionManager.scheduleSubscribe(accountId, instanceNumber);
}
/**
* Subscribes to the Metatrader terminal events
* @param {String} accountId id of the MetaTrader account to subscribe to
* @param {Number} instanceNumber instance index number
* @returns {Promise} promise which resolves when subscription started
*/ subscribe(accountId, instanceNumber) {
return this._subscriptionManager.subscribe(accountId, instanceNumber);
}
/**
* Requests the terminal to start synchronization process
* @param {String} accountId id of the MetaTrader account to synchronize
* @param {Number} instanceIndex instance index
* @param {String} host name of host to synchronize with
* @param {String} synchronizationId synchronization request id
* @param {Date} startingHistoryOrderTime from what date to start synchronizing history orders from. If not specified,
* the entire order history will be downloaded.
* @param {Date} startingDealTime from what date to start deal synchronization from. If not specified, then all
* history deals will be downloaded.
* @param {Function} getHashes function to get terminal state hashes
* @returns {Promise} promise which resolves when synchronization started
*/ synchronize(accountId, instanceIndex, host, synchronizationId, startingHistoryOrderTime, startingDealTime, hashes) {
var _this = this;
return _async_to_generator(function*() {
if (_this._getSocketInstanceByAccount(accountId, instanceIndex) === undefined) {
_this._logger.debug(`${accountId}:${instanceIndex}: creating socket instance on synchronize`);
yield _this._createSocketInstanceByAccount(accountId, instanceIndex);
}
const syncThrottler = _this._getSocketInstanceByAccount(accountId, instanceIndex).synchronizationThrottler;
_this._synchronizationHashes[synchronizationId] = hashes;
_this._synchronizationHashes[synchronizationId].lastUpdated = Date.now();
return syncThrottler.scheduleSynchronize(accountId, {
requestId: synchronizationId,
version: 2,
type: 'synchronize',
startingHistoryOrderTime,
startingDealTime,
instanceIndex,
host
}, hashes);
})();
}
/**
* Waits for server-side terminal state synchronization to complete
* @param {String} accountId id of the MetaTrader account to synchronize
* @param {Number} [instanceNumber] instance index number
* @param {String} applicationPattern MetaApi application regular expression pattern, default is .*
* @param {Number} timeoutInSeconds timeout in seconds, default is 300 seconds
* @param {String} [application] application to synchronize with
* @returns {Promise} promise which resolves when synchronization started
*/ waitSynchronized(accountId, instanceNumber, applicationPattern, timeoutInSeconds, application) {
return this.rpcRequest(accountId, {
type: 'waitSynchronized',
applicationPattern,
timeoutInSeconds,
instanceIndex: instanceNumber,
application: application || this._application
}, timeoutInSeconds + 1);
}
/**
* Market data subscription
* @typedef {Object} MarketDataSubscription
* @property {string} type subscription type, one of quotes, candles, ticks, or marketDepth
* @property {string} [timeframe] when subscription type is candles, defines the timeframe according to which the
* candles must be generated. Allowed values for MT5 are 1m, 2m, 3m, 4m, 5m, 6m, 10m, 12m, 15m, 20m, 30m, 1h, 2h, 3h,
* 4h, 6h, 8h, 12h, 1d, 1w, 1mn. Allowed values for MT4 are 1m, 5m, 15m 30m, 1h, 4h, 1d, 1w, 1mn
* @property {number} [intervalInMilliseconds] defines how frequently the terminal will stream data to client. If not
* set, then the value configured in account will be used
*/ /**
* Subscribes on market data of specified symbol
* @param {String} accountId id of the MetaTrader account
* @param {String} symbol symbol (e.g. currency pair or an index)
* @param {Array<MarketDataSubscription>} subscriptions array of market data subscription to create or update
* @param {String} [reliability] account reliability
* @returns {Promise} promise which resolves when subscription request was processed
*/ subscribeToMarketData(accountId, symbol, subscriptions, reliability) {
return this.rpcRequestAllInstances(accountId, {
type: 'subscribeToMarketData',
symbol,
subscriptions
}, reliability);
}
/**
* Refreshes market data subscriptions on the server to prevent them from expiring
* @param {String} accountId id of the MetaTrader account
* @param {Number} instanceNumber instance index number
* @param {Array} subscriptions array of subscriptions to refresh
*/ refreshMarketDataSubscriptions(accountId, instanceNumber, subscriptions) {
return this.rpcRequest(accountId, {
type: 'refreshMarketDataSubscriptions',
subscriptions,
instanceIndex: instanceNumber
});
}
/**
* Market data unsubscription
* @typedef {Object} MarketDataUnsubscription
* @property {string} type subscription type, one of quotes, candles, ticks, or marketDepth
*/ /**
* Unsubscribes from market data of specified symbol
* @param {String} accountId id of the MetaTrader account
* @param {String} symbol symbol (e.g. currency pair or an index)
* @param {Array<MarketDataUnsubscription>} subscriptions array of subscriptions to cancel
* @param {String} [reliability] account reliability
* @returns {Promise} promise which resolves when unsubscription request was processed
*/ unsubscribeFromMarketData(accountId, symbol, subscriptions, reliability) {
return this.rpcRequestAllInstances(accountId, {
type: 'unsubscribeFromMarketData',
symbol,
subscriptions
}, reliability);
}
/**
* Retrieves symbols available on an account
* @param {String} accountId id of the MetaTrader account to retrieve symbols for
* @returns {Promise<Array<string>>} promise which resolves when symbols are retrieved
*/ getSymbols(accountId) {
var _this = this;
return _async_to_generator(function*() {
let response = yield _this.rpcRequest(accountId, {
application: 'RPC',
type: 'getSymbols'
});
return response.symbols;
})();
}
/**
* Retrieves specification for a symbol
* @param {String} accountId id of the MetaTrader account to retrieve symbol specification for
* @param {String} symbol symbol to retrieve specification for
* @returns {Promise<MetatraderSymbolSpecification>} promise which resolves when specification is retrieved
*/ getSymbolSpecification(accountId, symbol) {
var _this = this;
return _async_to_generator(function*() {
let response = yield _this.rpcRequest(accountId, {
application: 'RPC',
type: 'getSymbolSpecification',
symbol
});
return response.specification;
})();
}
/**
* Retrieves price for a symbol
* @param {String} accountId id of the MetaTrader account to retrieve symbol price for
* @param {String} symbol symbol to retrieve price for
* @param {boolean} keepSubscription if set to true, the account will get a long-term subscription to symbol market
* data. Long-term subscription means that on subsequent calls you will get updated value faster. If set to false or
* not set, the subscription will be set to expire in 12 minutes.
* @returns {Promise<MetatraderSymbolPrice>} promise which resolves when price is retrieved
*/ getSymbolPrice(accountId, symbol, keepSubscription = false) {
var _this = this;
return _async_to_generator(function*() {
let response = yield _this.rpcRequest(accountId, {
application: 'RPC',
type: 'getSymbolPrice',
symbol,
keepSubscription
});
return response.price;
})();
}
/**
* Retrieves price for a symbol
* @param {string} accountId id of the MetaTrader account to retrieve candle for
* @param {string} symbol symbol to retrieve candle for
* @param {string} timeframe defines the timeframe according to which the candle must be generated. Allowed values for
* MT5 are 1m, 2m, 3m, 4m, 5m, 6m, 10m, 12m, 15m, 20m, 30m, 1h, 2h, 3h, 4h, 6h, 8h, 12h, 1d, 1w, 1mn. Allowed values
* for MT4 are 1m, 5m, 15m 30m, 1h, 4h, 1d, 1w, 1mn
* @param {boolean} keepSubscription if set to true, the account will get a long-term subscription to symbol market
* data. Long-term subscription means that on subsequent calls you will get updated value faster. If set to false or
* not set, the subscription will be set to expire in 12 minutes.
* @returns {Promise<MetatraderCandle>} promise which resolves when candle is retrieved
*/ getCandle(accountId, symbol, timeframe, keepSubscription = false) {
var _this = this;
return _async_to_generator(function*() {
let response = yield _this.rpcRequest(accountId, {
application: 'RPC',
type: 'getCandle',
symbol,
timeframe,
keepSubscription
});
return response.candle;
})();
}
/**
* Retrieves latest tick for a symbol. MT4 G1 accounts do not support this API
* @param {string} accountId id of the MetaTrader account to retrieve symbol tick for
* @param {string} symbol symbol to retrieve tick for
* @param {boolean} keepSubscription if set to true, the account will get a long-term subscription to symbol market
* data. Long-term subscription means that on subsequent calls you will get updated value faster. If set to false or
* not set, the subscription will be set to expire in 12 minutes.
* @returns {Promise<MetatraderTick>} promise which resolves when tick is retrieved
*/ getTick(accountId, symbol, keepSubscription = false) {
var _this = this;
return _async_to_generator(function*() {
let response = yield _this.rpcRequest(accountId, {
application: 'RPC',
type: 'getTick',
symbol,
keepSubscription
});
return response.tick;
})();
}
/**
* Retrieves latest order book for a symbol. MT4 accounts do not support this API
* @param {string} accountId id of the MetaTrader account to retrieve symbol order book for
* @param {string} symbol symbol to retrieve order book for
* @param {boolean} keepSubscription if set to true, the account will get a long-term subscription to symbol market
* data. Long-term subscription means that on subsequent calls you will get updated value faster. If set to false or
* not set, the subscription will be set to expire in 12 minutes.
* @returns {Promise<MetatraderBook>} promise which resolves when order book is retrieved
*/ getBook(accountId, symbol, keepSubscription = false) {
var _this = this;
return _async_to_generator(function*() {
let response = yield _this.rpcRequest(accountId, {
application: 'RPC',
type: 'getBook',
symbol,
keepSubscription
});
return response.book;
})();
}
/**
* Forces refresh of most recent quote updates for symbols subscribed to by the terminal
* @param {string} accountId id of the MetaTrader account
* @returns {Promise<string[]>} promise which resolves with recent quote symbols that was initiated to process
*/ refreshTerminalState(accountId) {
var _this = this;
return _async_to_generator(function*() {
let response = yield _this.rpcRequest(accountId, {
application: 'RPC',
type: 'refreshTerminalState'
});
return response.symbols;
})();
}
/**
* Forces refresh and retrieves latest quotes for a subset of symbols the terminal is subscribed to
* @param {string} accountId id of the MetaTrader account
* @param {string[]} symbols quote symbols to refresh
* @returns {Promise<RefreshedQuotes>} refreshed quotes and basic account information info
*/ refreshSymbolQuotes(accountId, symbols) {
var _this = this;
return _async_to_generator(function*() {
let response = yield _this.rpcRequest(accountId, {
application: 'RPC',
type: 'refreshSymbolQuotes',
symbols
});
return response.refreshedQuotes;
})();
}
/**
* Sends client uptime stats to the server.
* @param {String} accountId id of the MetaTrader account to save uptime
* @param {Object} uptime uptime statistics to send to the server
* @returns {Promise} promise which resolves when uptime statistics is submitted
*/ saveUptime(accountId, uptime) {
return this.rpcRequest(accountId, {
type: 'saveUptime',
uptime
});
}
/**
* Unsubscribe from account
* @param {String} accountId id of the MetaTrader account to unsubscribe
* @returns {Promise} promise which resolves when socket unsubscribed
*/ unsubscribe(accountId) {
var _this = this;
return _async_to_generator(function*() {
const region = _this.getAccountRegion(accountId);
_this._latencyService.onUnsubscribe(accountId);
Object.keys(_this._updateEvents).filter((key)=>key.startsWith(accountId)).forEach((key)=>delete _this._updateEvents[key]);
if (_this._socketInstances[region]) {
yield Promise.all(Object.keys(_this._socketInstances[region]).map(function() {
var _ref = _async_to_generator(function*(instanceNumber) {
try {
yield _this._subscriptionManager.unsubscribe(accountId, Number(instanceNumber));
delete _this._socketInstancesByAccounts[instanceNumber][accountId];
} catch (err) {
if (![
'TimeoutError',
'NotFoundError'
].includes(err.name)) {
_this._logger.warn(`${accountId}:${instanceNumber}: failed to unsubscribe`, err);
}
}
});
return function(instanceNumber) {
return _ref.apply(this, arguments);
};
}()));
}
})();
}
/**
* Current server time (see https://metaapi.cloud/docs/client/models/serverTime/)
* @typedef {Object} ServerTime
* @property {Date} time current server time
* @property {String} brokerTime current broker time, in broker timezone, YYYY-MM-DD HH:mm:ss.SSS format
* @property {Date} [lastQuoteTime] last quote time
* @property {String} [lastQuoteBrokerTime] last quote time, in broker timezone, YYYY-MM-DD HH:mm:ss.SSS format
*/ /**
* Returns server time for a specified MetaTrader account
* @param {string} accountId id of the MetaTrader account to return server time for
* @returns {Promise<ServerTime>} promise resolving with server time
*/ getServerTime(accountId) {
var _this = this;
return _async_to_generator(function*() {
let response = yield _this.rpcRequest(accountId, {
application: 'RPC',
type: 'getServerTime'
});
return response.serverTime;
})();
}
/**
* Margin required to open a trade (see https://metaapi.cloud/docs/client/models/margin/)
* @typedef {Object} Margin
* @property {number} [margin] margin required to open a trade. If margin can not be calculated, then this field is
* not defined
*/ /**
* Contains order to calculate margin for (see https://metaapi.cloud/docs/client/models/marginOrder/)
* @typedef {Object} MarginOrder
* @property {string} symbol order symbol
* @property {string} type order type, one of ORDER_TYPE_BUY or ORDER_TYPE_SELL
* @property {number} volume order volume, must be greater than 0
* @property {number} openPrice order open price, must be greater than 0
*/ /**
* Calculates margin required to open a trade on the specified trading account
* @param {string} accountId id of the trading account to calculate margin for
* @param {string} application application to send the request to
* @param {string} reliability account reliability
* @param {MarginOrder} order order to calculate margin for
* @returns {Promise<Margin>} promise resolving with margin calculation result
*/ calculateMargin(accountId, application, reliability, order) {
var _this = this;
return _async_to_generator(function*() {
let response;
if (application === 'RPC') {
response = yield _this.rpcRequest(accountId, {
application,
type: 'calculateMargin',
order
});
} else {
response = yield _this.rpcRequestAllInstances(accountId, {
application,
type: 'calculateMargin',
order
}, reliability);
}
return response.margin;
})();
}
/**
* Calls onUnsubscribeRegion listener event
* @param {String} accountId account id
* @param {String} region account region to unsubscribe
*/ unsubscribeAccountRegion(accountId, region) {
var _this = this;
return _async_to_generator(function*() {
const unsubscribePromises = [];
for (let listener of _this._synchronizationListeners[accountId] || []){
unsubscribePromises.push(_this._processEvent(()=>listener.onUnsubscribeRegion(region), `${accountId}:${region}:onUnsubscribeRegion`, true).catch((err)=>_this._logger.error(`${accountId}:${region}: Failed to notify listener about onUnsubscribeRegion event`, err)));
}
yield Promise.all(unsubscribePromises);
})();
}
/**
* Adds synchronization listener for specific account
* @param {String} accountId account id
* @param {SynchronizationListener} listener synchronization listener to add
*/ addSynchronizationListener(accountId, listener) {
this._logger.trace(`${accountId}: Added synchronization listener`);
let listeners = this._synchronizationListeners[accountId];
if (!listeners) {
listeners = [];
this._synchronizationListeners[accountId] = listeners;
}
listeners.push(listener);
}
/**
* Removes synchronization listener for specific account
* @param {String} accountId account id
* @param {SynchronizationListener} listener synchronization listener to remove
*/ removeSynchronizationListener(accountId, listener) {
this._logger.trace(`${accountId}: Removed synchronization listener`);
let listeners = this._synchronizationListeners[accountId];
if (!listeners) {
listeners = [];
}
listeners = listeners.filter((l)=>l !== listener);
this._synchronizationListeners[accountId] = listeners;
}
/**
* Adds latency listener
* @param {LatencyListener} listener latency listener to add
*/ addLatencyListener(listener) {
this._latencyListeners.push(listener);
}
/**
* Removes latency listener
* @param {LatencyListener} listener latency listener to remove
*/ removeLatencyListener(listener) {
this._latencyListeners = this._latencyListeners.filter((l)=>l !== listener);
}
/**
* Adds reconnect listener
* @param {ReconnectListener} listener reconnect listener to add
* @param {String} accountId account id of listener
*/ addReconnectListener(listener, accountId) {
this._reconnectListeners.push({
accountId,
listener
});
}
/**
* Removes reconnect listener
* @param {ReconnectListener} listener listener to remove
*/ removeReconnectListener(listener) {
this._reconnectListeners = this._reconnectListeners.filter((l)=>l.listener !== listener);
}
/**
* Removes all listeners. Intended for use in unit tests.
*/ removeAllListeners() {
this._synchronizationListeners = {};
this._reconnectListeners = [];
}
/**
* Clears account or replica data from client records and unsubscribes
* @param {string} accountId account id to process the removal of
*/ onAccountDeleted(accountId) {
this._subscriptionManager.cancelAccount(accountId);
this._latencyService.onUnsubscribe(accountId);
const masterAccountId = this._accountsByReplicaId[accountId];
if (masterAccountId) {
if (masterAccountId === accountId) {
const regionData = this._accountReplicas[masterAccountId];
const replicas = Object.values(regionData);
Object.keys(this._synchronizationIdByInstance).filter((instance)=>instance.startsWith(`${masterAccountId}`)).forEach((instance)=>delete this._synchronizationIdByInstance[instance]);
replicas.forEach((replica)=>{
Object.values(this._socketInstancesByAccounts).forEach((instance)=>delete instance[replica]);
delete this._accountsByReplicaId[replica];
delete this._regionsByAccounts[replica];
});
delete this._accountReplicas[masterAccountId];
this._logger.debug(`${masterAccountId}: processed primary account removal`);
} else {
Object.values(this._socketInstancesByAccounts).forEach((instance)=>delete instance[accountId]);
const regionData = this._regionsByAccounts[accountId];
if (regionData) {
const region = regionData.region;
Object.keys(this._synchronizationIdByInstance).filter((instance)=>instance.startsWith(`${masterAccountId}:${region}`)).forEach((instance)=>delete this._synchronizationIdByInstance[instance]);
delete this._accountReplicas[masterAccountId][region];
this._logger.debug(`${masterAccountId}: processed removal of replica ${accountId}`);
}
delete this._accountsByReplicaId[accountId];
delete this._regionsByAccounts[accountId];
}
}
}
/**
* Queues an account packet for processing
* @param {Object} packet packet to process
*/ queuePacket(socket, packet) {
const accountId = packet.accountId;
const packets = this._packetOrderer.restoreOrder({
accountId: packet.accountId,
host: packet.host,
instanceIndex: packet.instanceIndex,
sequenceNumber: packet.sequenceNumber,
sequenceTimestamp: packet.sequenceTimestamp,
synchronizationId: packet.synchronizationId,
type: packet.type,
socket,
packet
}).filter((p)=>p.type !== 'noop');
if (this._sequentialEventProcessing && packet.sequenceNumber !== undefined) {
const events = packets.map((item)=>()=>this._processSynchronizationPacket(item.socket, item.packet));
if (!this._eventQueues[accountId]) {
this._eventQueues[accountId] = events;
this._callAccountEvents(accountId);
} else {
this._eventQueues[accountId] = this._eventQueues[accountId].concat(events);
}
} else {
packets.forEach((item)=>this._processSynchronizationPacket(item.socket, item.packet));
}
}
/**
* Queues account event for processing
* @param {String} accountId account id
* @param {String} name event label name
* @param {Function} callable async or regular function to execute
*/ queueEvent(accountId, name, callable) {
let event = ()=>this._processEvent(callable, `${accountId}:${name}`);
if (this._sequentialEventProcessing) {
if (!this._eventQueues[accountId]) {
this._eventQueues[accountId] = [
event
];
this._callAccountEvents(accountId);
} else {
this._eventQueues[accountId].push(event);
}
} else {
event();
}
}
_callAccountEvents(accountId) {
var _this = this;
return _async_to_generator(function*() {
if (_this._eventQueues[accountId]) {
while(_this._eventQueues[accountId].length){
yield _this._eventQueues[accountId][0]();
_this._eventQueues[accountId].shift();
}
delete _this._eventQueues[accountId];
}
})();
}
_reconnect(instanceNumber, socketInstanceIndex, region) {
var _this = this;
return _async_to_generator(function*() {
const instance = _this.socketInstances[region][instanceNumber][socketInstanceIndex];
if (instance) {
while(!instance.socket.connected && !instance.isReconnecting && instance.connected){
yield _this._tryReconnect(instanceNumber, socketInstanceIndex, region);
}
}
})();
}
_tryReconnect(instanceNumber, socketInstanceIndex, region) {
const instance = this.socketInstances[region][instanceNumber][socketInstanceIndex];
instance.reconnectWaitTime = Math.min(instance.reconnectWaitTime * 2, 30000);
var _this = this;
return new Promise((resolve)=>setTimeout(/*#__PURE__*/ _async_to_generator(function*() {
if (!instance.socket.connected && !instance.isReconnecting && instance.connected) {
try {
instance.sessionId = randomstring.generate(32);
const clientId = Math.random();
instance.socket.close();
instance.socket.io.opts.extraHeaders['Client-Id'] = clientId;
instance.socket.io.opts.query.clientId = clientId;
instance.isReconnecting = true;
instance.socket.io.uri = yield _this._getServerUrl(instanceNumber, socketInstanceIndex, region);
instance.socket.connect();
} catch (error) {
instance.isReconnecting = false;
}
}
resolve();
}), instance.reconnectWaitTime));
}
/**
* Simulataneously sends RPC requests to all synchronized instances
* @param {String} accountId metatrader account id
* @param {Object} request base request data
* @param {String} [reliability] account reliability
* @param {Number} [timeoutInSeconds] request timeout in seconds
*/ rpcRequestAllInstances(accountId, request, reliability, timeoutInSeconds) {
var _this = this;
return _async_to_generator(function*() {
if (reliability === 'high') {
try {
return yield any([
0,
1
].map((instanceNumber)=>{
return _this.rpcRequest(accountId, Object.assign({}, request, {
instanceIndex: instanceNumber
}), timeoutInSeconds);
}));
} catch (error) {
throw error.errors[0];
}
} else {
return yield _this.rpcRequest(accountId, request, timeoutInSeconds);
}
})();
}
/**
* Makes a RPC request
* @param {String} accountId replica account id
* @param {Object} request base request data
* @param {Number} [timeoutInSeconds] request timeout in seconds
*/ //eslint-disable-next-line complexity, max-statements
rpcRequest(accountId, request, timeoutInSeconds) {
var _this = this;
return _async_to_generator(function*() {
var _this__socketInstancesByAccounts, _instanceNumber, _this__socketInstances, _region, _this__socketInstances_region, _instanceNumber1;
const ignoredRequestTypes = [
'subscribe',
'synchronize',
'refreshMarketDataSubscriptions',
'unsubscribe'
];
const primaryAccountId = _this._accountsByReplicaId[accountId];
let connectedInstance = _this._latencyService.getActiveAccountInstances(primaryAccountId)[0];
if (!ignoredRequestTypes.includes(request.type)) {
connectedInstance || (connectedInstance = yield _this._latencyService.waitConnectedInstance(accountId));
const activeRegion = connectedInstance.split(':')[1];
accountId = _this._accountReplicas[primaryAccountId][activeRegion];
}
let socketInstanceIndex = null;
let instanceNumber = 0;
const region = _this.getAccountRegion(accountId);
_this._refreshAccountRegion(accountId);
if (request.instanceIndex !== undefined) {
instanceNumber = request.instanceIndex;
} else {
if (connectedInstance) {
instanceNumber = Number(connectedInstance.split(':')[2]);
}
if (request.application !== 'RPC') {
request = Object.assign({}, request, {
instanceIndex: instanceNumber
});
}
}
(_this__socketInstancesByAccounts = _this._socketInstancesByAccounts)[_instanceNumber = instanceNumber] || (_this__socketInstancesByAccounts[_instanceNumber] = {});
(_this__socketInstances = _this._socketInstances)[_region = region] || (_this__socketInstances[_region] = {});
(_this__socketInstances_region = _this._socketInstances[region])[_instanceNumber1 = instanceNumber] || (_this__socketInstances_region[_instanceNumber1] = []);
if (_this._socketInstancesByAccounts[instanceNumber][accountId] !== undefined) {
socketInstanceIndex = _this._socketInstancesByAccounts[instanceNumber][accountId];
} else {
_this._logger.debug(`${accountId}:${instanceNumber}: creating socket instance on RPC request`);
yield _this._createSocketInstanceByAccount(accountId, instanceNumber);
socketInstanceIndex = _this._socketInstancesByAccounts[instanceNumber][accountId];
}
const instance = _this._socketInstances[region][instanceNumber][socketInstanceIndex];
if (!instance.connected) {
_this._logger.debug(`${accountId}:${instanceNumber}: connecting socket instance on RPC request`);
yield _this.connect(instanceNumber, region);
} else if (!_this.connected(instanceNumber, socketInstanceIndex, region)) {
yield instance.connectResult;
}
if (request.type === 'subscribe') {
request.sessionId = instance.sessionId;
}
if ([
'trade',
'subscribe'
].includes(request.type)) {
return _this._makeRequest(accountId, instanceNumber, request, timeoutInSeconds);
}
let retryCounter = 0;
while(true){
try {
return yield _this._makeRequest(accountId, instanceNumber, request, timeoutInSeconds);
} catch (err) {
if (err.name === 'TooManyRequestsError') {
let calcRetryCounter = retryCounter;
let calcRequestTime = 0;
while(calcRetryCounter < _this._retries){
calcRetryCounter++;
calcRequestTime += Math.min(Math.pow(2, calcRetryCounter) * _this._minRetryDelayInSeconds, _this._maxRetryDelayInSeconds) * 1000;
}
const retryTime = new Date(err.metadata.recommendedRetryTime).getTime();
if (Date.now() + calcRequestTime > retryTime && retryCounter < _this._retries) {
if (Date.now() < retryTime) {
yield new Promise((res)=>setTimeout(res, retryTime - Date.now()));
}
retryCounter++;
} else {
throw err;
}
} else if ([
'NotSynchronizedError',
'TimeoutError',
'NotAuthenticatedError',
'InternalError'
].includes(err.name) && retryCounter < _this._retries) {
yield new Promise((res)=>setTimeout(res, Math.min(Math.pow(2, retryCounter) * _this._minRetryDelayInSeconds, _this._maxRetryDelayInSeconds) * 1000));
retryCounter++;
} else {
throw err;
}
if (_this._socketInstancesByAccounts[instanceNumber][accountId] === undefined) {
throw err;
}
}
}
})();
}
_makeRequest(accountId, instanceNumber, request, timeoutInSeconds) {
const socketInstance = this._getSocketInstanceByAccount(accountId, instanceNumber);
let requestId = request.requestId || randomstring.generate(32);
request.timestamps = {
clientProcessingStarted: new Date()
};
let result = Promise.race([
new Promise((resolve, reject)=>socketInstance.requestResolves[requestId] = {
resolve,
reject,
type: request.type
}),
new Promise((resolve, reject)=>setTimeout(()=>{
reject(new TimeoutError(`MetaApi websocket client request ${request.requestId} of type ${request.type} ` + 'timed out. Please make sure your account is connected to broker before retrying your request.'));
delete socketInstance.requestResolves[requestId];
}, timeoutInSeconds * 1000 || this._requestTimeout))
]);
request.accountId = accountId;
request.application = request.application || this._application;
if (!request.requestId) {
request.requestId = requestId;
}
if (request.type === 'unsubscribe' || request.application === 'RPC' || request.instanceIndex === socketInstance.instanceNumber) {
this._logger.debug(()=>`${accountId}: Sending request: ${JSON.stringify(request)}`);
socketInstance.socket.emit('request', request);
return result;
} else {
this._logger.trace(()=>`${accountId}:${request.instanceIndex}: skipping request because it is being sent to ` + `the socket of the wrong instance index, request=${JSON.stringify(request)}`);
return result;
}
}
// eslint-disable-next-line complexity
_convertError(data) {
if (data.error === 'ValidationError') {
return new ValidationError(data.message, data.details);
} else if (data.error === 'NotFoundError') {
return new NotFoundError(data.message);
} else if (data.error === 'NotSynchronizedError') {
return new NotSynchronizedError(data.message);
} else if (data.error === 'TimeoutError') {
return new TimeoutError(data.message);
} else if (data.error === 'NotAuthenticatedError') {
return new NotConnectedError(data.message);
} else if (data.error === 'ForbiddenError') {
return new ForbiddenError(data.message);
} else if (data.error === 'TradeError') {
return new TradeError(data.message, data.numericCode, data.stringCode);
} else if (data.error === 'UnauthorizedError') {
this.close();
return new UnauthorizedError(data.message);
} else if (data.error === 'TooManyRequestsError') {
return new TooManyRequestsError(data.message, data.metadata);
} else {
return new InternalError(data.message);
}
}
// eslint-disable-next-line complexity
_convertIsoTimeToDate(packet) {
// eslint-disable-next-line guard-for-in
for(let field in packet){
let value = packet[field];
if (typeof value === 'string' && field.match(/time$|Time$/) && !field.match(/brokerTime$|BrokerTime$|timeframe$/)) {
packet[field] = new Date(value);
}
if (Array.isArray(value)) {
for (let item of value){
this._convertIsoTimeToDate(item);
}
}
if (typeof value === 'object') {
this._convertIsoTimeToDate(value);
}
}
if (packet && packet.timestamps) {
// eslint-disable-next-line guard-for-in
for(let field in packet.timestamps){
packet.timestamps[field] = new Date(packet.timestamps[field]);
}
}
if (packet && packet.type === 'prices') {
for (let price of packet.prices || []){
if (price.timestamps) {
// eslint-disable-next-line guard-for-in
for(let field in price.timestamps){
price.timestamps[field] = new Date(price.timestamps[field]);
}
}
}
}
}
/**
* MetaTrader symbol price. Contains current price for a symbol (see
* https://metaapi.cloud/docs/client/models/metatraderSymbolPrice/)
* @typedef {Object} MetatraderSymbolPrice
* @property {String} symbol symbol (e.g. a currency pair or an index)
* @property {Number} bid bid price
* @property {Number} ask ask price
* @property {Number} profitTickValue tick value for a profitable position
* @property {Number} lossTickValue tick value for a losing position
* @property {Number} [accountCurrencyExchangeRate] current exchange rate of account currency into account base
* currency (USD if you did not override it)
* @property {Date} time quote time, in ISO format
* @property {String} brokerTime time quote time, in broker timezone, YYYY-MM-DD HH:mm:ss.SSS format
*/ /**
* MetaTrader candle
* @typedef {Object} MetatraderCandle
* @property {string} symbol symbol (e.g. currency pair or an index)
* @property {string} timeframe timeframe candle was generated for, e.g. 1h. One of 1m, 2m, 3m, 4m, 5m, 6m, 10m, 12m,
* 15m, 20m, 30m, 1h, 2h, 3h, 4h, 6h, 8h, 12h, 1d, 1w, 1mn
* @property {Date} time candle opening time
* @property {string} brokerTime candle opening time, in broker timezone, YYYY-MM-DD HH:mm:ss.SSS format
* @property {number} open open price
* @property {number} high high price
* @property {number} low low price
* @property {number} close close price
* @property {number} tickVolume tick volume, i.e. number of ticks inside the candle
* @property {number} spread spread in points
* @property {number} volume trade volume
*/ /**
* MetaTrader tick data
* @typedef {Object} MetatraderTick
* @property {string} symbol symbol (e.g. a currency pair or an index)
* @property {Date} time time
* @property {string} brokerTime time, in broker timezone, YYYY-MM-DD HH:mm:ss.SSS format
* @property {number} [bid] bid price
* @property {number} [ask] ask price
* @property {number} [last] last deal price
* @property {number} [volume] volume for the current last deal price
* @property {string} side is tick a result of buy or sell deal, one of buy or sell
*/ /**
* MetaTrader order book
* @typedef {Object} MetatraderBook
* @property {string} symbol symbol (e.g. a currency pair or an index)
* @property {Date} time time
* @property {string} brokerTime time, in broker timezone, YYYY-MM-DD HH:mm:ss.SSS format
* @property {Array<MetatraderBookEntry>} book list of order book entries
*/ /**
* MetaTrader order book entry
* @typedef {Object} MetatraderBookEntry
* @property {string} type entry type, one of BOOK_TYPE_SELL, BOOK_TYPE_BUY, BOOK_TYPE_SELL_MARKET,
* BOOK_TYPE_BUY_MARKET
* @property {number} price price
* @property {number} volume volume
*/ // eslint-disable-next-line complexity,max-statements
_processSynchronizationPacket(socket, data) {
var _this = this;
return _async_to_generator(function*() {
try {
const instanceNumber = data.instanceIndex || 0;
const socketInstance = _this._getSocketInstanceByAccount(data.accountId, instanceNumber);
if (data.synchronizationId && socketInstance) {
socketInstance.synchronizationThrottler.updateSynchronizationId(data.synchronizationId);
}
const region = _this.getAccountRegion(data.accountId);
const primaryAccountId = _this._accountsByReplicaId[data.accountId];
let instanceId = primaryAccountId + ':' + region + ':' + instanceNumber + ':' + (data.host || 0);
let instanceIndex = region + ':' + instanceNumber + ':' + (data.host || 0);
let sourceLabel = _.compact([
instanceIndex,
socket.clientApiHostname
]).join(':');
const isOnlyActiveInstance = ()=>{
const activeInstanceIds = Object.keys(_this._connectedHosts).filter((instance)=>instance.startsWith(primaryAccountId + ':' + region + ':' + instanceNumber));
return !activeInstanceIds.length || activeInstanceIds.length === 1 && activeInstanceIds[0] === instanceId;
};
const cancelDisconnectTimer = ()=>{
if (_this._statusTimers[instanceId]) {
clearTimeout(_this._statusTimers[instanceId]);
}
};
const resetDisconnectTimer = ()=>{
cancelDisconnectTimer();
_this._statusTimers[instanceId] = setTimeout(()=>{
_this._logger.warn(`${data.accountId}:${sourceLabel}: timed out waiting for connection status`);
if (isOnlyActiveInstance()) {
_this._subscriptionManager.onTimeout(data.accountId, 0);
_this._subscriptionManager.onTimeout(data.accountId, 1);
}
_this.queueEvent(primaryAccountId, `${instanceIndex}:onDisconnected`, ()=>onDisconnected(true));
clearTimeout(_this._statusTimers[instanceId]);
}, 60000);
};
// eslint-disable-next-line complexity
const onDisconnected = function() {
var _ref = _async_to_generator(function*(isTimeout = false) {
if (_this._connectedHosts[instanceId]) {
_this._latencyService.onDisconnected(instanceId);
if (isOnlyActiveInstance()) {
for (let listener of _this._synchronizationListeners[primaryAccountId] || []){
yield _this._processEvent(()=>listener.onDisconnected(instanceIndex), `${primaryAccountId}:${sourceLabel}:onDisconnected`);
}
}
_this._packetOrderer.onStreamClosed(instanceId);
socketInstance === null || socketInstance === void 0 ? void 0 : socketInstance.synchronizationThrottler.removeIdByParameters(data.accountId, instanceNumber, data.host);
for (let listener of _this._synchronizationListeners[primaryAccountId] || []){
yield _this._processEvent(()=>listener.onStreamClosed(instanceIndex), `${primaryAccountId}:${sourceLabel}:onStreamClosed`);
}
delete _this._connectedHosts[instanceId];
if (isOnlyActiveInstance() && !isTimeout) {
yield _this._subscriptionManager.onDisconnected(data.accountId, 0);
yield _this._subscriptionManager.onDisconnected(data.accountId, 1);
}
}
});
return function onDisconnected() {
return _ref.apply(this, arguments);
};
}();
if (data.type === 'authenticated') {
resetDisconnectTimer();
if (!data.sessionId || socketInstance && data.sessionId === socketInstance.sessionId) {
_this._latencyService.onConnected(instanceId);
_this._connectedHosts[instanceId] = data.host;
for (let listener of _this._synchronizationListeners[primaryAccountId] || []){
yield _this._processEvent(()=>listener.onConnected(instanceIndex, data.replicas), `${primaryAccountId}:${sourceLabel}:onConnected`);
}
_this._subscriptionManager.cancelSubscribe(data.accountId + ':' + instanceNumber);
if (data.replicas === 1) {
_this._subscriptionManager.cancelAccount(data.accountId);
} else {
_this._subscriptionManager.cancelSubscribe(data.accountId + ':' + instanceNumber);
}
}
} else if (data.type === 'disconnected') {
cancelDisconnectTimer();
yield onDisconnected();
} else if (data.type === 'synchronizationStarted') {
_this._updateEvents[instanceId] = [];
_this._synchronizationFlags[data.synchronizationId] = {
accountId: data.accountId,
instanceNumber,
specificationsUpdated: data.specificationsHashIndex === undefined,
positionsUpdated: data.positionsHashIndex === undefined,
ordersUpdated: data.ordersHashIndex === undefined
};
_this._synchronizationIdByInstance[instanceId] = data.synchronizationId;
const specificationsHash = data.specificationsHashIndex !== undefined ? _this._synchronizationHashes[data.synchronizationId] && _this._synchronizationHashes[data.synchronizationId].specificationsHashes[data.specificationsHashIndex] : undefined;
const positionsHash = data.positionsHashIndex !== undefined ? _this._synchronizationHashes[data.synchronizationId] && _this._synchronizationHashes[data.synchronizationId].positionsHashes[data.positionsHashIndex] : undefined;
const ordersHash = data.ordersHashIndex !== undefined ? _this._synchronizationHashes[data.synchronizationId] && _this._synchronizationHashes[data.synchronizationId].ordersHashes[data.ordersHashIndex] : undefined;
delete _this._synchronizationHashes[data.synchronizationId];
for (let listener of _this._synchronizationListeners[primaryAccountId] || []){
yield _this._processEvent(()=>listener.onSynchronizationStarted(instanceIndex, specificationsHash, positionsHash, ordersHash, data.synchronizationId), `${primaryAccountId}:${sourceLabel}:onSynchronizationStarted`);
}
} else if (data.type === 'accountInformation') {
if (data.synchronizationId && data.synchronizationId !== _this._synchronizationIdByInstance[instanceId]) {
return;
}
if (data.accountInformation) {
for (let listener of _this._synchronizationListeners[primaryAccountId] || []){
try {
yield _this._processEvent(()=>listener.onAccountInformationUpdated(instanceIndex, data.accountInformation), `${primaryAccountId}:${sourceLabel}:onAccountInformationUpdated`, true);
// eslint-disable-next-line max-depth
if (_this._synchronizationFlags[data.synchronizationId] && !_this._synchronizationFlags[data.synchronizationId].positionsUpdated) {
yield _this._processEvent(()=>listener.onPositionsSynchronized(instanceIndex, data.synchronizationId), `${primaryAccountId}:${sourceLabel}:onPositionsSynchronized`, true);
// eslint-disable-next-line max-depth
if (!_this._synchronizationFlags[data.synchronizationId].ordersUpdated) {
yield _this._processEvent(()=>listener.onPendingOrdersSynchronized(instanceIndex, data.synchronizationId), `${primaryAccountId}:${sourceLabel}:onPendingOrdersSynchronized`, true);
}
}
} catch (err) {
_this._logger.error(`${primaryAccountId}:${sourceLabel}: Failed to notify listener ` + 'about accountInformation event', err);
}
}
if (_this._synchronizationFlags[data.synchronizationId] && !_this._synchronizationFlags[data.synchronizationId].positionsUpdated && !_this._synchronizationFlags[data.synchronizationId].ordersUpdated) {
delete _this._synchronizationFlags[data.synchronizationId];
}
}
} else if (data.type === 'deals') {
if (data.synchronizationId && data.synchronizationId !== _this._synchronizationIdByInstance[instanceId]) {
return;
}
for (let deal of data.deals || []){
for (let listener of _this._synchronizationListeners[primaryAccountId] || []){
yield _this._processEvent(()=>listener.onDealAdded(instanceIndex, deal), `${primaryAccountId}:${sourceLabel}:onDealAdded`);
}
}
} else if (data.type === 'orders') {
if (data.synchronizationId && data.synchronizationId !== _this._synchronizationIdByInstance[instanceId]) {
return;
}
for (let listener of _this._synchronizationListeners[primaryAccountId] || []){
try {
yield _this._processEvent(()=>listener.onPendingOrdersReplaced(instanceIndex, data.orders || []), `${primaryAccountId}:${sourceLabel}:onPendingOrdersReplaced`, true);
yield _this._processEvent(()=>listener.onPendingOrdersSynchronized(instanceIndex, data.synchronizationId), `${primaryAccountId}:${sourceLabel}:onPendingOrdersSynchronized`, true);
} catch (err) {
_this._logger.error(`${primaryAccountId}:${sourceLabel}: Failed to notify listener ` + 'about orders event', err);
}
}
if (_this._synchronizationFlags[data.synchronizationId]) {
delete _this._synchronizationFlags[data.synchronizationId];
}
} else if (data.type === 'historyOrders') {
if (data.synchronizationId && data.synchronizationId !== _this._synchronizationIdByInstance[instanceId]) {
return;
}
for (let historyOrder of data.historyOrders || []){
for (let listener of _this._synchronizationListeners[primaryAccountId] || []){
yield _this._processEvent(()=>listener.onHistoryOrderAdded(instanceIndex, historyOrder), `${primaryAccountId}:${sourceLabel}:onHistoryOrderAdded`);
}
}
} else if (data.type === 'positions') {
if (data.synchronizationId && data.synchronizationId !== _this._synchronizationIdByInstance[instanceId]) {
return;
}
for (let listener of _this._synchronizationListeners[primaryAccountId] || []){
try {
yield _this._processEvent(()=>listener.onPositionsReplaced(instanceIndex, data.positions || []), `${primaryAccountId}:${sourceLabel}:onPositionsReplaced`, true);
yield _this._processEvent(()=>listener.onPositionsSynchronized(instanceIndex, data.synchronizationId), `${primaryAccountId}:${sourceLabel}:onPositionsSynchronized`, true);
if (_this._synchronizationFlags[data.synchronizationId] && !_this._synchronizationFlags[data.synchronizationId].ordersUpdated) {
yield _this._processEvent(()=>listener.onPendingOrdersSynchronized(instanceIndex, data.synchronizationId), `${primaryAccountId}:${sourceLabel}:onPendingOrdersSynchronized`, true);
}
} catch (err) {
_this._logger.error(`${primaryAccountId}:${sourceLabel}: Failed to notify listener ` + 'about positions event', err);
}
}
if (_this._synchronizationFlags[data.synchronizationId] && !_this._synchronizationFlags[data.synchronizationId].ordersUpdated) {
delete _this._synchronizationFlags[data.synchronizationId];
}
} else if (data.type === 'update') {
var _this__updateEvents_instanceId;
(_this__updateEvents_instanceId = _this._updateEvents[instanceId]) === null || _this__updateEvents_instanceId === void 0 ? void 0 : _this__updateEvents_instanceId.push({
socket,
data
});
if (data.accountInformation) {
for (let listener of _this._synchronizationListeners[primaryAccountId] || []){
yield _this._processEvent(()=>listener.onAccountInformationUpdated(instanceIndex, data.accountInformation), `${primaryAccountId}:${sourceLabel}:onAccountInformationUpdated`);
}
}
const updatedPositions = data.updatedPositions || [];
const removedPositionIds = data.removedPositionIds || [];
if (updatedPositions.length || removedPositionIds.length) {
for (let listener of _this._synchronizationListeners[primaryAccountId] || []){
yield _this._processEvent(()=>listener.onPositionsUpdated(instanceIndex, updatedPositions, removedPositionIds), `${primaryAccountId}:${sourceLabel}:onPositionsUpdated`);
}
}
for (let position of updatedPositions){
for (let listener of _this._synchronizationListeners[primaryAccountId] || []){
yield _this._processEvent(()=>listener.onPositionUpdated(instanceIndex, position), `${primaryAccountId}:${sourceLabel}:onPositionUpdated`);
}
}
for (let positionId of removedPositionIds){
for (let listener of _this._synchronizationListeners[primaryAccountId] || []){
yield _this._processEvent(()=>listener.onPositionRemoved(instanceIndex, positionId), `${primaryAccountId}:${sourceLabel}:onPositionRemoved`);
}
}
const updatedOrders = data.updatedOrders || [];
const completedOrderIds = data.completedOrderIds || [];
if (updatedOrders.length || completedOrderIds.length) {
for (let listener of _this._synchronizationListeners[primaryAccountId] || []){
yield _this._processEvent(()=>listener.onPendingOrdersUpdated(instanceIndex, updatedOrders, completedOrderIds), `${primaryAccountId}:${sourceLabel}:onPendingOrdersUpdated`);
}
}
for (let order of updatedOrders){
for (let listener of _this._synchronizationListeners[primaryAccountId] || []){
yield _this._processEvent(()=>listener.onPendingOrderUpdated(instanceIndex, order), `${primaryAccountId}:${sourceLabel}:onPendingOrderUpdated`);
}
}
for (let orderId of completedOrderIds){
for (let listener of _this._synchronizationListeners[primaryAccountId] || []){
yield _this._processEvent(()=>listener.onPendingOrderCompleted(instanceIndex, orderId), `${primaryAccountId}:${sourceLabel}:onPendingOrderCompleted`);
}
}
for (let historyOrder of data.historyOrders || []){
for (let listener of _this._synchronizationListeners[primaryAccountId] || []){
yield _this._processEvent(()=>listener.onHistoryOrderAdded(instanceIndex, historyOrder), `${primaryAccountId}:${sourceLabel}:onHistoryOrderAdded`);
}
}
for (let deal of data.deals || []){
for (let listener of _this._synchronizationListeners[primaryAccountId] || []){
yield _this._processEvent(()=>listener.onDealAdded(instanceIndex, deal), `${primaryAccountId}:${sourceLabel}:onDealAdded`);
}
}
if (data.timestamps) {
data.timestamps.clientProcessingFinished = new Date();
// eslint-disable-next-line max-depth
for (let listener of _this._latencyListeners || []){
yield _this._processEvent(()=>listener.onUpdate(data.accountId, data.timestamps), `${primaryAccountId}:${sourceLabel}:onUpdate`);
}
}
} else if (data.type === 'dealSynchronizationFinished') {
if (data.synchronizationId && data.synchronizationId !== _this._synchronizationIdByInstance[instanceId]) {
delete _this._synchronizationIdByInstance[instanceId];
return;
}
_this._latencyService.onDealsSynchronized(instanceId);
for (let listener of _this._synchronizationListeners[primaryAccountId] || []){
socketInstance === null || socketInstance === void 0 ? void 0 : socketInstance.synchronizationThrottler.removeSynchronizationId(data.synchronizationId);
yield _this._processEvent(()=>listener.onDealsSynchronized(instanceIndex, data.synchronizationId), `${primaryAccountId}:${sourceLabel}:onDealsSynchronized`);
}
if (_this._updateEvents[instanceId]) {
let eventCalls = _this._updateEvents[instanceId].map((event)=>()=>_this._processSynchronizationPacket(event.socket, event.data));
if (_this._eventQueues[primaryAccountId]) {
_this._eventQueues[primaryAccountId] = eventCalls.concat(_this._eventQueues[primaryAccountId]);
delete _this._updateEvents[instanceId];
} else {
_this._eventQueues[primaryAccountId] = eventCalls;
delete _this._updateEvents[instanceId];
_this._callAccountEvents(primaryAccountId);
}
}
} else if (data.type === 'orderSynchronizationFinished') {
if (data.synchronizationId && data.synchronizationId !== _this._synchronizationIdByInstance[instanceId]) {
return;
}
for (let listener of _this._synchronizationListeners[primaryAccountId] || []){
yield _this._processEvent(()=>listener.onHistoryOrdersSynchronized(instanceIndex, data.synchronizationId), `${primaryAccountId}:${sourceLabel}:onHistoryOrdersSynchronized`);
}
} else if (data.type === 'status') {
if (!_this._connectedHosts[instanceId]) {
if (_this._statusTimers[instanceId] && data.authenticated && (_this._subscriptionManager.isDisconnectedRetryMode(data.accountId, instanceNumber) || !_this._subscriptionManager.isAccountSubscribing(data.accountId, instanceNumber))) {
_this._subscriptionManager.cancelSubscribe(data.accountId + ':' + instanceNumber);
yield new Promise((res)=>setTimeout(res, 10));
// eslint-disable-next-line no-console
_this._logger.info('it seems like we are not connected to a running API server yet, retrying subscription for account' + _.compact([
instanceId,
socket.clientApiHostname
]).join(':'));
_this.ensureSubscribe(data.accountId, instanceNumber);
}
} else {
resetDisconnectTimer();
for (let listener of _this._synchronizationListeners[primaryAccountId] || []){
yield _this._processEvent(()=>listener.onBrokerConnectionStatusChanged(instanceIndex, !!data.connected), `${primaryAccountId}:${sourceLabel}:onBrokerConnectionStatusChanged`);
}
if (data.healthStatus) {
// eslint-disable-next-line max-depth
for (let listener of _this._synchronizationListeners[primaryAccountId] || []){
yield _this._processEvent(()=>listener.onHealthStatus(instanceIndex, data.healthStatus), `${primaryAccountId}:${sourceLabel}:onHealthStatus`);
}
}
}
} else if (data.type === 'downgradeSubscription') {
_this._logger.info(`${primaryAccountId}:${sourceLabel}: Market data subscriptions for symbol ` + `${data.symbol} were downgraded by the server due to rate limits. Updated subscriptions: ` + `${JSON.stringify(data.updates)}, removed subscriptions: ${JSON.stringify(data.unsubscriptions)}. ` + 'Please read https://metaapi.cloud/docs/client/rateLimiting/ for more details.');
for (let listener of _this._synchronizationListeners[primaryAccountId] || []){
yield _this._processEvent(()=>listener.onSubscriptionDowngraded(instanceIndex, data.symbol, data.updates, data.unsubscriptions), `${primaryAccountId}:${sourceLabel}:onSubscriptionDowngraded`);
}
} else if (data.type === 'specifications') {
if (data.synchronizationId && data.synchronizationId !== _this._synchronizationIdByInstance[instanceId]) {
return;
}
for (let listener of _this._synchronizationListeners[primaryAccountId] || []){
yield _this._processEvent(()=>listener.onSymbolSpecificationsUpdated(instanceIndex, data.specifications || [], data.removedSymbols || []), `${primaryAccountId}:${sourceLabel}:onSymbolSpecificationsUpdated`);
}
for (let specification of data.specifications || []){
for (let listener of _this._synchronizationListeners[primaryAccountId] || []){
yield _this._processEvent(()=>listener.onSymbolSpecificationUpdated(instanceIndex, specification), `${primaryAccountId}:${sourceLabel}:onSymbolSpecificationUpdated`);
}
}
for (let removedSymbol of data.removedSymbols || []){
for (let listener of _this._synchronizationListeners[primaryAccountId] || []){
yield _this._processEvent(()=>listener.onSymbolSpecificationRemoved(instanceIndex, removedSymbol), `${primaryAccountId}:${sourceLabel}:onSymbolSpecificationRemoved`);
}
}
} else if (data.type === 'prices') {
if (data.synchronizationId && data.synchronizationId !== _this._synchronizationIdByInstance[instanceId]) {
return;
}
let prices = data.prices || [];
let candles = data.candles || [];
let ticks = data.ticks || [];
let books = data.books || [];
for (let listener of _this._synchronizationListeners[primaryAccountId] || []){
if (prices.length) {
yield _this._processEvent(()=>listener.onSymbolPricesUpdated(instanceIndex, prices, data.equity, data.margin, data.freeMargin, data.marginLevel, data.accountCurrencyExchangeRate), `${primaryAccountId}:${sourceLabel}:onSymbolPricesUpdated`);
}
if (candles.length) {
yield _this._processEvent(()=>listener.onCandlesUpdated(instanceIndex, candles, data.equity, data.margin, data.freeMargin, data.marginLevel, data.accountCurrencyExchangeRate), `${primaryAccountId}:${sourceLabel}:onCandlesUpdated`);
}
if (ticks.length) {
yield _this._processEvent(()=>listener.onTicksUpdated(instanceIndex, ticks, data.equity, data.margin, data.freeMargin, data.marginLevel, data.accountCurrencyExchangeRate), `${primaryAccountId}:${sourceLabel}:onTicksUpdated`);
}
if (books.length) {
yield _this._processEvent(()=>listener.onBooksUpdated(instanceIndex, books, data.equity, data.margin, data.freeMargin, data.marginLevel, data.accountCurrencyExchangeRate), `${primaryAccountId}:${sourceLabel}:onBooksUpdated`);
}
}
for (let price of prices){
for (let listener of _this._synchronizationListeners[primaryAccountId] || []){
yield _this._processEvent(()=>listener.onSymbolPriceUpdated(instanceIndex, price), `${primaryAccountId}:${sourceLabel}:onSymbolPriceUpdated`);
}
}
for (let price of prices){
if (price.timestamps) {
price.timestamps.clientProcessingFinished = new Date();
// eslint-disable-next-line max-depth
for (let listener of _this._latencyListeners || []){
yield _this._processEvent(()=>listener.onSymbolPrice(data.accountId, price.symbol, price.timestamps), `${primaryAccountId}:${sourceLabel}:onSymbolPrice`);
}
}
}
}
} catch (err) {
_this._logger.error('Failed to process incoming synchronization packet', err);
}
})();
}
_processEvent(callable, label, throwError) {
var _this = this;
return _async_to_generator(function*() {
const startTime = Date.now();
let isLongEvent = false;
let isEventDone = false;
const checkLongEvent = function() {
var _ref = _async_to_generator(function*() {
yield new Promise((res)=>setTimeout(res, 1000));
if (!isEventDone) {
isLongEvent = true;
_this._logger.warn(`${label}: event is taking more than 1 second to process`);
}
});
return function checkLongEvent() {
return _ref.apply(this, arguments);
};
}();
checkLongEvent();
try {
yield callable();
} catch (err) {
if (throwError) {
throw err;
}
_this._logger.error(`${label}: event failed with error`, err);
}
isEventDone = true;
if (isLongEvent) {
_this._logger.warn(`${label}: finished in ${Math.floor((Date.now() - startTime) / 1000)} seconds`);
}
})();
}
_fireReconnected(instanceNumber, socketInstanceIndex, region) {
var _this = this;
return _async_to_generator(function*() {
try {
const reconnectListeners = [];
for (let listener of _this._reconnectListeners){
if (_this._socketInstancesByAccounts[instanceNumber][listener.accountId] === socketInstanceIndex && _this.getAccountRegion(listener.accountId) === region) {
reconnectListeners.push(listener);
}
}
Object.keys(_this._synchronizationFlags).forEach((synchronizationId)=>{
const accountId = _this._synchronizationFlags[synchronizationId].accountId;
if (_this._socketInstancesByAccounts[instanceNumber][accountId] === socketInstanceIndex && _this._synchronizationFlags[synchronizationId].instanceNumber === instanceNumber && _this._regionsByAccounts[accountId] && _this._regionsByAccounts[accountId].region === region) {
delete _this._synchronizationFlags[synchronizationId];
}
});
const reconnectAccountIds = reconnectListeners.map((listener)=>listener.accountId);
_this._subscriptionManager.onReconnected(instanceNumber, socketInstanceIndex, reconnectAccountIds);
_this._packetOrderer.onReconnected(reconnectAccountIds);
for (let listener of reconnectListeners){
Promise.resolve(listener.listener.onReconnected(region, instanceNumber)).catch((err)=>_this._logger.error('Failed to notify reconnect listener', err));
}
} catch (err) {
_this._logger.error('Failed to process reconnected event', err);
}
})();
}
_getSocketInstanceByAccount(accountId, instanceNumber) {
const region = this.getAccountRegion(accountId);
return this._socketInstances[region][instanceNumber][this._socketInstancesByAccounts[instanceNumber][accountId]];
}
getUrlSettings(instanceNumber, region) {
var _this = this;
return _async_to_generator(function*() {
if (_this._url) {
return {
url: _this._url,
isSharedClientApi: true
};
}
const urlSettings = yield _this._domainClient.getSettings();
const getUrl = (hostname)=>`https://${hostname}.${region}-${String.fromCharCode(97 + Number(instanceNumber))}.${urlSettings.domain}`;
let url;
if (_this._useSharedClientApi) {
url = getUrl(_this._hostname);
} else {
url = getUrl(urlSettings.hostname);
}
const isSharedClientApi = url === getUrl(_this._hostname);
return {
url,
isSharedClientApi
};
})();
}
// eslint-disable-next-line complexity
_getServerUrl(instanceNumber, socketInstanceIndex, region) {
var _this = this;
return _async_to_generator(function*() {
if (_this._url) {
return _this._url;
}
while(_this.socketInstances[region][instanceNumber][socketInstanceIndex].connected){
try {
const urlSettings = yield _this.getUrlSettings(instanceNumber, region);
const url = urlSettings.url;
const isSharedClientApi = urlSettings.isSharedClientApi;
let logMessage = 'Connecting MetaApi websocket client to the MetaApi server ' + `via ${url} ${isSharedClientApi ? 'shared' : 'dedicated'} server.`;
if (_this._firstConnect && !isSharedClientApi) {
logMessage += ' Please note that it can take up to 3 minutes for your dedicated server to start for the ' + 'first time. During this time it is OK if you see some connection errors.';
_this._firstConnect = false;
}
_this._logger.info(logMessage);
return url;
} catch (err) {
_this._logger.error('Failed to retrieve server URL', err);
yield new Promise((res)=>setTimeout(res, 1000));
}
}
})();
}
_throttleRequest(type, accountId, instanceNumber, timeInMs) {
this._lastRequestsTime[instanceNumber] = this._lastRequestsTime[instanceNumber] || {};
this._lastRequestsTime[instanceNumber][type] = this._lastRequestsTime[instanceNumber][type] || {};
let lastTime = this._lastRequestsTime[instanceNumber][type][accountId];
if (!lastTime || lastTime < Date.now() - timeInMs) {
this._lastRequestsTime[instanceNumber][type][accountId] = Date.now();
return !!lastTime;
}
return false;
}
_refreshAccountRegion(accountId) {
if (this._regionsByAccounts[accountId]) {
this._regionsByAccounts[accountId].lastUsed = Date.now();
}
}
//eslint-disable-next-line complexity
_createSocketInstanceByAccount(accountId, instanceNumber) {
var _this = this;
return _async_to_generator(function*() {
const region = _this.getAccountRegion(accountId);
if (_this._socketInstancesByAccounts[instanceNumber][accountId] === undefined) {
let socketInstanceIndex = null;
while(_this._subscribeLock && (new Date(_this._subscribeLock.recommendedRetryTime).getTime() > Date.now() && _this.subscribedAccountIds(instanceNumber, undefined, region).length < _this._subscribeLock.lockedAtAccounts || new Date(_this._subscribeLock.lockedAtTime).getTime() + _this._subscribeCooldownInSeconds * 1000 > Date.now() && _this.subscribedAccountIds(instanceNumber, undefined, region).length >= _this._subscribeLock.lockedAtAccounts)){
yield new Promise((res)=>setTimeout(res, 1000));
}
for(let index = 0; index < _this._socketInstances[region][instanceNumber].length; index++){
const accountCounter = _this._getAssignedAccounts(instanceNumber, index, region).length;
const instance = _this.socketInstances[region][instanceNumber][index];
if (instance.subscribeLock) {
if (instance.subscribeLock.type === 'LIMIT_ACCOUNT_SUBSCRIPTIONS_PER_USER_PER_SERVER' && (new Date(instance.subscribeLock.recommendedRetryTime).getTime() > Date.now() || _this.subscribedAccountIds(instanceNumber, index, region).length >= instance.subscribeLock.lockedAtAccounts)) {
continue;
}
if (instance.subscribeLock.type === 'LIMIT_ACCOUNT_SUBSCRIPTIONS_PER_SERVER' && new Date(instance.subscribeLock.recommendedRetryTime).getTime() > Date.now() && _this.subscribedAccountIds(instanceNumber, index, region).length >= instance.subscribeLock.lockedAtAccounts) {
continue;
}
}
if (accountCounter < _this._maxAccountsPerInstance) {
socketInstanceIndex = index;
break;
}
}
if (socketInstanceIndex === null) {
socketInstanceIndex = _this._socketInstances[region][instanceNumber].length;
yield _this.connect(instanceNumber, region);
}
_this._socketInstancesByAccounts[instanceNumber][accountId] = socketInstanceIndex;
}
})();
}
_clearAccountCacheJob() {
const date = Date.now();
Object.keys(this._regionsByAccounts).forEach((replicaId)=>{
const data = this._regionsByAccounts[replicaId];
if (data && data.connections === 0 && date - data.lastUsed > 2 * 60 * 60 * 1000) {
const primaryAccountId = this._accountsByReplicaId[replicaId];
const replicas = Object.values(this._accountReplicas[primaryAccountId] || {});
replicas.forEach((replica)=>{
delete this._accountsByReplicaId[replica];
delete this._regionsByAccounts[replica];
});
delete this._accountReplicas[primaryAccountId];
this._logger.debug(`${primaryAccountId}: removed expired account replicas data`);
}
});
}
_clearInactiveSyncDataJob() {
const date = Date.now();
Object.keys(this._synchronizationHashes).forEach((synchronizationId)=>{
if (this._synchronizationHashes[synchronizationId].lastUpdated < date - 30 * 60 * 1000) {
delete this._synchronizationHashes[synchronizationId];
}
});
}
/**
* @typedef MetaApiWebsocketClientOptions MetaApi websocket client options
* @property {string} [region] region to connect
* @property {Boolean} [disableInternalJobs] whether to not run internal interval jobs. Used for tests only
*/ /**
* Constructs MetaApi websocket API client instance
* @param {MetaApi} metaApi metaApi instance
* @param {DomainClient} domainClient domain client
* @param {String} token authorization token
* @param {MetaApiWebsocketClientOptions} opts websocket client options
*/ // eslint-disable-next-line complexity,max-statements
constructor(metaApi, domainClient, token, opts){
_define_property(this, "_domainClient", void 0);
_define_property(this, "_application", void 0);
_define_property(this, "_domain", void 0);
_define_property(this, "_region", void 0);
_define_property(this, "_hostname", void 0);
_define_property(this, "_metaApi", void 0);
_define_property(this, "_url", void 0);
_define_property(this, "_requestTimeout", void 0);
_define_property(this, "_connectTimeout", void 0);
_define_property(this, "_retries", void 0);
_define_property(this, "_minRetryDelayInSeconds", void 0);
_define_property(this, "_maxRetryDelayInSeconds", void 0);
_define_property(this, "_maxAccountsPerInstance", void 0);
_define_property(this, "_subscribeCooldownInSeconds", void 0);
_define_property(this, "_sequentialEventProcessing", void 0);
_define_property(this, "_useSharedClientApi", void 0);
_define_property(this, "_unsubscribeThrottlingInterval", void 0);
_define_property(this, "_socketMinimumReconnectTimeout", void 0);
_define_property(this, "_latencyService", void 0);
_define_property(this, "_token", void 0);
_define_property(this, "_synchronizationListeners", void 0);
_define_property(this, "_latencyListeners", void 0);
_define_property(this, "_reconnectListeners", void 0);
_define_property(this, "_connectedHosts", void 0);
_define_property(this, "_socketInstances", {});
_define_property(this, "_socketInstancesByAccounts", {});
_define_property(this, "_regionsByAccounts", {});
_define_property(this, "_accountsByReplicaId", {});
_define_property(this, "_accountReplicas", {});
_define_property(this, "_synchronizationThrottlerOpts", void 0);
_define_property(this, "_subscriptionManager", void 0);
_define_property(this, "_statusTimers", void 0);
_define_property(this, "_eventQueues", {});
_define_property(this, "_synchronizationFlags", {});
_define_property(this, "_synchronizationIdByInstance", void 0);
_define_property(this, "_subscribeLock", void 0);
_define_property(this, "_firstConnect", void 0);
_define_property(this, "_lastRequestsTime", void 0);
_define_property(this, "_packetOrderer", void 0);
_define_property(this, "_synchronizationHashes", void 0);
_define_property(this, "_updateEvents", {});
_define_property(this, "_packetLogger", void 0);
_define_property(this, "_logger", void 0);
_define_property(this, "_clearAccountCacheInterval", void 0);
_define_property(this, "_clearInactiveSyncDataInterval", void 0);
const validator = new OptionsValidator();
opts = opts || {};
opts.packetOrderingTimeout = validator.validateNonZero(opts.packetOrderingTimeout, 60, 'packetOrderingTimeout');
opts.synchronizationThrottler = opts.synchronizationThrottler || {};
this._domainClient = domainClient;
this._application = opts.application || 'MetaApi';
this._domain = opts.domain || 'agiliumtrade.agiliumtrade.ai';
this._region = opts.region;
this._hostname = 'mt-client-api-v1';
this._metaApi = metaApi;
this._url = null;
this._requestTimeout = validator.validateNonZero(opts.requestTimeout, 60, 'requestTimeout') * 1000;
this._connectTimeout = validator.validateNonZero(opts.connectTimeout, 60, 'connectTimeout') * 1000;
const retryOpts = opts.retryOpts || {};
this._retries = validator.validateNumber(retryOpts.retries, 5, 'retryOpts.retries');
this._minRetryDelayInSeconds = validator.validateNonZero(retryOpts.minDelayInSeconds, 1, 'retryOpts.minDelayInSeconds');
this._maxRetryDelayInSeconds = validator.validateNonZero(retryOpts.maxDelayInSeconds, 30, 'retryOpts.maxDelayInSeconds');
this._maxAccountsPerInstance = 100;
this._subscribeCooldownInSeconds = validator.validateNonZero(retryOpts.subscribeCooldownInSeconds, 600, 'retryOpts.subscribeCooldownInSeconds');
this._sequentialEventProcessing = true;
this._useSharedClientApi = validator.validateBoolean(opts.useSharedClientApi, false, 'useSharedClientApi');
this._unsubscribeThrottlingInterval = validator.validateNonZero(opts.unsubscribeThrottlingIntervalInSeconds, 10, 'unsubscribeThrottlingIntervalInSeconds') * 1000;
this._socketMinimumReconnectTimeout = 500;
this._latencyService = new LatencyService(this, token, this._connectTimeout);
this._token = token;
this._synchronizationListeners = {};
this._latencyListeners = [];
this._reconnectListeners = [];
this._connectedHosts = {};
this._synchronizationThrottlerOpts = opts.synchronizationThrottler;
this._subscriptionManager = new SubscriptionManager(this, metaApi);
this._statusTimers = {};
this._synchronizationIdByInstance = {};
this._subscribeLock = null;
this._firstConnect = true;
this._lastRequestsTime = {};
this._packetOrderer = new PacketOrderer(this, opts.packetOrderingTimeout);
this._packetOrderer.start();
this._synchronizationHashes = {};
if (opts.packetLogger && opts.packetLogger.enabled) {
this._packetLogger = new PacketLogger(opts.packetLogger);
this._packetLogger.start();
}
this._logger = LoggerManager.getLogger('MetaApiWebsocketClient');
if (!opts.disableInternalJobs) {
this._clearAccountCacheInterval = setInterval(this._clearAccountCacheJob.bind(this), 30 * 60 * 1000);
this._clearInactiveSyncDataInterval = setInterval(this._clearInactiveSyncDataJob.bind(this), 5 * 60 * 1000);
}
}
};
export default MetaApiWebsocketClient;
//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["<anon>"],"sourcesContent":["'use strict';\n\nimport randomstring from 'randomstring';\nimport socketIO from 'socket.io-client';\nimport TimeoutError from '../timeoutError';\nimport {ValidationError, NotFoundError, InternalError, UnauthorizedError, TooManyRequestsError, ForbiddenError}\n  from '../errorHandler';\nimport OptionsValidator from '../optionsValidator';\nimport NotSynchronizedError from './notSynchronizedError';\nimport NotConnectedError from './notConnectedError';\nimport TradeError from './tradeError';\nimport PacketOrderer from './packetOrderer';\nimport SynchronizationThrottler from './synchronizationThrottler';\nimport SubscriptionManager from './subscriptionManager';\nimport LoggerManager from '../../logger';\nimport any from 'promise.any';\nimport LatencyService from './latencyService';\nimport {MetatraderSymbolSpecification} from './metaApiWebsocket.client.schemas';\nimport MetatraderAccount from '../../metaApi/metatraderAccount';\nimport DomainClient from '../domain.client';\nimport _ from 'lodash';\n\nexport * from './metaApiWebsocket.client.schemas';\n\nlet PacketLogger;\nif (typeof window === 'undefined') { // don't import PacketLogger for browser version\n  PacketLogger = require('./packetLogger').default;\n}\n\n/**\n * MetaApi websocket API client (see https://metaapi.cloud/docs/client/websocket/overview/)\n */\nclass MetaApiWebsocketClient {\n  \n  private _domainClient: DomainClient;\n  private _application: any;\n  private _domain: any;\n  private _region: any;\n  private _hostname: string;\n  private _metaApi: any;\n  private _url: null;\n  private _requestTimeout: number;\n  private _connectTimeout: number;\n  private _retries: any;\n  private _minRetryDelayInSeconds: any;\n  private _maxRetryDelayInSeconds: any;\n  private _maxAccountsPerInstance: number;\n  private _subscribeCooldownInSeconds: any;\n  private _sequentialEventProcessing: boolean;\n  private _useSharedClientApi: any;\n  private _unsubscribeThrottlingInterval: number;\n  private _socketMinimumReconnectTimeout: number;\n  private _latencyService: LatencyService;\n  private _token: any;\n  private _synchronizationListeners: {};\n  private _latencyListeners: any[];\n  private _reconnectListeners: any[];\n  private _connectedHosts: {};\n  private _socketInstances: SocketInstances = {};\n  private _socketInstancesByAccounts: {[instanceNumber: number]: {[accountId: string]: number}} = {};\n  private _regionsByAccounts: RegionsByAccounts = {};\n  private _accountsByReplicaId: MetaApiWebsocketClient.AccountsByReplica = {};\n  private _accountReplicas: MetaApiWebsocketClient.AccountReplicas = {};\n  private _synchronizationThrottlerOpts: any;\n  private _subscriptionManager: any;\n  private _statusTimers: {};\n  private _eventQueues: {[accountId: string]: Array<() => Promise<any>>} = {};\n  private _synchronizationFlags: {[synchronizationId: string]: SynchronizationFlag} = {};\n  private _synchronizationIdByInstance: {};\n  private _subscribeLock: any;\n  private _firstConnect: boolean;\n  private _lastRequestsTime: {};\n  private _packetOrderer: PacketOrderer;\n  private _synchronizationHashes: {};\n  private _updateEvents: {[instanceId: string]: Packet[]} = {};\n  private _packetLogger: any;\n  private _logger: any;\n  private _clearAccountCacheInterval: NodeJS.Timeout;\n  private _clearInactiveSyncDataInterval: NodeJS.Timeout;\n\n  /**\n   * @typedef MetaApiWebsocketClientOptions MetaApi websocket client options\n   * @property {string} [region] region to connect\n   * @property {Boolean} [disableInternalJobs] whether to not run internal interval jobs. Used for tests only\n   */\n\n  /**\n   * Constructs MetaApi websocket API client instance\n   * @param {MetaApi} metaApi metaApi instance\n   * @param {DomainClient} domainClient domain client\n   * @param {String} token authorization token\n   * @param {MetaApiWebsocketClientOptions} opts websocket client options\n   */\n  // eslint-disable-next-line complexity,max-statements\n  constructor(metaApi, domainClient, token, opts) {\n    const validator = new OptionsValidator();\n    opts = opts || {};\n    opts.packetOrderingTimeout = validator.validateNonZero(opts.packetOrderingTimeout, 60, 'packetOrderingTimeout');\n    opts.synchronizationThrottler = opts.synchronizationThrottler || {};\n    this._domainClient = domainClient;\n    this._application = opts.application || 'MetaApi';\n    this._domain = opts.domain || 'agiliumtrade.agiliumtrade.ai';\n    this._region = opts.region;\n    this._hostname = 'mt-client-api-v1';\n    this._metaApi = metaApi;\n    this._url = null;\n    this._requestTimeout = validator.validateNonZero(opts.requestTimeout, 60, 'requestTimeout') * 1000;\n    this._connectTimeout = validator.validateNonZero(opts.connectTimeout, 60, 'connectTimeout') * 1000;\n    const retryOpts = opts.retryOpts || {};\n    this._retries = validator.validateNumber(retryOpts.retries, 5, 'retryOpts.retries');\n    this._minRetryDelayInSeconds = validator.validateNonZero(retryOpts.minDelayInSeconds, 1,\n      'retryOpts.minDelayInSeconds');\n    this._maxRetryDelayInSeconds = validator.validateNonZero(retryOpts.maxDelayInSeconds, 30,\n      'retryOpts.maxDelayInSeconds');\n    this._maxAccountsPerInstance = 100;\n    this._subscribeCooldownInSeconds = validator.validateNonZero(retryOpts.subscribeCooldownInSeconds, 600, \n      'retryOpts.subscribeCooldownInSeconds');\n    this._sequentialEventProcessing = true;\n    this._useSharedClientApi = validator.validateBoolean(opts.useSharedClientApi, false, 'useSharedClientApi');\n    this._unsubscribeThrottlingInterval = validator.validateNonZero(opts.unsubscribeThrottlingIntervalInSeconds, 10,\n      'unsubscribeThrottlingIntervalInSeconds') * 1000;\n    this._socketMinimumReconnectTimeout = 500;\n    this._latencyService = new LatencyService(this, token, this._connectTimeout);\n    this._token = token;\n    this._synchronizationListeners = {};\n    this._latencyListeners = [];\n    this._reconnectListeners = [];\n    this._connectedHosts = {};\n    this._synchronizationThrottlerOpts = opts.synchronizationThrottler;\n    this._subscriptionManager = new SubscriptionManager(this, metaApi);\n    this._statusTimers = {};\n    this._synchronizationIdByInstance = {};\n    this._subscribeLock = null;\n    this._firstConnect = true;\n    this._lastRequestsTime = {};\n    this._packetOrderer = new PacketOrderer(this, opts.packetOrderingTimeout);\n    this._packetOrderer.start();\n    this._synchronizationHashes = {};\n    if (opts.packetLogger && opts.packetLogger.enabled) {\n      this._packetLogger = new PacketLogger(opts.packetLogger);\n      this._packetLogger.start();\n    }\n    this._logger = LoggerManager.getLogger('MetaApiWebsocketClient');\n    if (!opts.disableInternalJobs) {\n      this._clearAccountCacheInterval = setInterval(this._clearAccountCacheJob.bind(this), 30 * 60 * 1000);\n      this._clearInactiveSyncDataInterval = setInterval(this._clearInactiveSyncDataJob.bind(this), 5 * 60 * 1000);\n    }\n  }\n\n  /**\n   * Restarts the account synchronization process on an out of order packet\n   * @param {String} accountId account id\n   * @param {Number} instanceIndex instance index\n   * @param {Number} expectedSequenceNumber expected s/n\n   * @param {Number} actualSequenceNumber actual s/n\n   * @param {Object} packet packet data\n   * @param {Date} receivedAt time the packet was received at\n   */\n  onOutOfOrderPacket(accountId, instanceIndex, expectedSequenceNumber, actualSequenceNumber, packet, receivedAt) {\n    const primaryAccountId = this._accountsByReplicaId[accountId];\n    if (this._subscriptionManager.isSubscriptionActive(accountId)) {\n      const level = this._latencyService.getSynchronizedAccountInstances(primaryAccountId).length ? 'debug' : 'error';\n      this._logger[level]('MetaApi websocket client received an out of order ' +\n        `packet type ${packet.type} for account id ${accountId}:${instanceIndex}. Expected s/n ` +\n        `${expectedSequenceNumber} does not match the actual of ${actualSequenceNumber}`);\n      this.ensureSubscribe(accountId, instanceIndex);\n    }\n  }\n\n  /**\n   * Patch server URL for use in unit tests\n   * @param {String} url patched server URL\n   */\n  set url(url) {\n    this._url = url;\n  }\n\n  /**\n   * Websocket client predefined region\n   * @returns {String} predefined region\n   */\n  get region() {\n    return this._region;\n  }\n\n  /**\n   * Returns the list of socket instance dictionaries\n   * @return {Object[]} list of socket instance dictionaries\n   */\n  get socketInstances() {\n    return this._socketInstances;\n  }\n\n  /**\n   * Returns the dictionary of socket instances by account ids\n   * @return {Object} dictionary of socket instances by account ids\n   */\n  get socketInstancesByAccounts() {\n    return this._socketInstancesByAccounts;\n  }\n\n  /**\n   * Returns the dictionary of account replicas by region\n   * @return {Object} dictionary of account replicas by region\n   */\n  get accountReplicas(): MetaApiWebsocketClient.AccountReplicas {\n    return this._accountReplicas;\n  }\n\n  /**\n   * Returns the dictionary of primary account ids by replica ids\n   * @return {Object} dictionary of primary account ids by replica ids\n   */\n  get accountsByReplicaId(): MetaApiWebsocketClient.AccountsByReplica {\n    return this._accountsByReplicaId;\n  }\n\n  /**\n   * Returns clear account cache job. Used for tests\n   * @return {Function} clear account cache job\n   */\n  get clearAccountCacheJob() {\n    return this._clearAccountCacheJob.bind(this);\n  }\n\n  /**\n   * Returns latency service\n   * @returns {LatencyService} latency service\n   */\n  get latencyService() {\n    return this._latencyService;\n  }\n\n  /**\n   * Returns the list of subscribed account ids\n   * @param {Number} instanceNumber instance index number\n   * @param {String} socketInstanceIndex socket instance index\n   * @param {String} region server region\n   * @return {string[]} list of subscribed account ids\n   */\n  subscribedAccountIds(instanceNumber, socketInstanceIndex, region) {\n    const connectedIds = [];\n    if (this._socketInstancesByAccounts[instanceNumber]) {\n      Object.keys(this._connectedHosts).forEach(instanceId => {\n        const accountId = instanceId.split(':')[0];\n        const accountRegion = this.getAccountRegion(accountId);\n        if (!connectedIds.includes(accountId) && \n        this._socketInstancesByAccounts[instanceNumber][accountId] !== undefined && (\n          this._socketInstancesByAccounts[instanceNumber][accountId] === socketInstanceIndex || \n        socketInstanceIndex === undefined) && accountRegion === region) {\n          connectedIds.push(accountId);\n        }\n      });\n    }\n    return connectedIds;\n  }\n\n  /**\n   * Returns websocket client connection status\n   * @param {Number} instanceNumber instance index number\n   * @param {Number} socketInstanceIndex socket instance index\n   * @param {String} region server region\n   * @returns {Boolean} websocket client connection status\n   */\n  connected(instanceNumber, socketInstanceIndex, region) {\n    const instance = this._socketInstances[region] && \n      this._socketInstances[region][instanceNumber].length > socketInstanceIndex ? \n      this._socketInstances[region][instanceNumber][socketInstanceIndex] : null;\n    return (instance && instance.socket && instance.socket.connected) || false;\n  }\n\n  /**\n   * Returns list of accounts assigned to instance\n   * @param {Number} instanceNumber instance index number\n   * @param {String} socketInstanceIndex socket instance index\n   * @param {String} region server region\n   * @returns \n   */\n  private _getAssignedAccounts(instanceNumber, socketInstanceIndex, region) {\n    const accountIds = [];\n    Object.keys(this._socketInstancesByAccounts[instanceNumber]).forEach(key => {\n      const accountRegion = this.getAccountRegion(key);\n      if (accountRegion === region &&\n        this._socketInstancesByAccounts[instanceNumber][key] === socketInstanceIndex) {\n        accountIds.push(key);\n      }\n    });\n    return accountIds;\n  }\n\n  /**\n   * Returns account region by id\n   * @param {String} accountId account id\n   * @returns {String} account region\n   */\n  getAccountRegion(accountId) {\n    return this._regionsByAccounts[accountId] && this._regionsByAccounts[accountId].region;\n  }\n\n  /**\n   * Adds account cache info\n   * @param {String} accountId account id\n   * @param {Object} replicas account replicas, including primary replica\n   */\n  addAccountCache(accountId: string, replicas: MetatraderAccount.AccountsByRegion) {\n    this._accountReplicas[accountId] = replicas;\n    Object.keys(replicas).forEach(region => {\n      const replicaId = replicas[region];\n      if (!this._regionsByAccounts[replicaId]) {\n        this._regionsByAccounts[replicaId] = {\n          region,\n          connections: 1,\n          lastUsed: Date.now()\n        };\n      } else {\n        this._regionsByAccounts[replicaId].connections++;\n      }\n      this._accountsByReplicaId[replicaId] = accountId;\n    });\n    this._logger.debug(`${accountId}: added account cache`);\n  }\n\n  /**\n   * Updates account cache info\n   * @param {String} accountId account id\n   * @param {Object} replicas account replicas\n   */\n  updateAccountCache(accountId: string, replicas: MetatraderAccount.AccountsByRegion) {\n    const oldReplicas = this._accountReplicas[accountId];\n    if (oldReplicas) {\n      const connectionCount = this._regionsByAccounts[accountId].connections;\n      Object.keys(oldReplicas).forEach(region => {\n        const replicaId = replicas[region];\n        delete this._accountsByReplicaId[replicaId];\n        delete this._regionsByAccounts[replicaId];\n      });\n      this._accountReplicas[accountId] = replicas;\n      Object.keys(replicas).forEach(region => {\n        const replicaId = replicas[region];\n        this._regionsByAccounts[replicaId] = {\n          region,\n          connections: connectionCount,\n          lastUsed: Date.now()\n        };\n        this._accountsByReplicaId[replicaId] = accountId;\n      });\n      this._logger.debug(`${accountId}: updated account cache`);\n    }\n  }\n\n  /**\n   * Removes account region info\n   * @param {String} accountId account id\n   */\n  removeAccountCache(accountId: string) {\n    if (this._regionsByAccounts[accountId]?.connections > 0) {\n      this._regionsByAccounts[accountId].connections--; \n    }\n  }\n\n  /**\n   * Locks subscription for a socket instance based on TooManyRequestsError metadata\n   * @param {Number} instanceNumber instance index number\n   * @param {String} socketInstanceIndex socket instance index\n   * @param {String} region server region\n   * @param {Object} metadata TooManyRequestsError metadata\n   */\n  async lockSocketInstance(instanceNumber, socketInstanceIndex, region, metadata) {\n    if (metadata.type === 'LIMIT_ACCOUNT_SUBSCRIPTIONS_PER_USER') {\n      this._subscribeLock = {\n        recommendedRetryTime: metadata.recommendedRetryTime,\n        lockedAtAccounts: this.subscribedAccountIds(instanceNumber, undefined, region).length,\n        lockedAtTime: Date.now()\n      };\n    } else {\n      const subscribedAccounts = this.subscribedAccountIds(instanceNumber, socketInstanceIndex, region);\n      if (subscribedAccounts.length === 0) {\n        const socketInstance = this.socketInstances[region][instanceNumber][socketInstanceIndex];\n        socketInstance.socket.close();\n        await this._reconnect(instanceNumber, socketInstanceIndex, region);\n      } else {\n        const instance = this.socketInstances[region][instanceNumber][socketInstanceIndex];\n        instance.subscribeLock = {\n          recommendedRetryTime: metadata.recommendedRetryTime,\n          type: metadata.type,\n          lockedAtAccounts: subscribedAccounts.length\n        };\n      }\n    }\n  }\n\n  /**\n   * Connects to MetaApi server via socket.io protocol\n   * @param {Number} instanceNumber instance index number\n   * @param {String} region server region\n   * @returns {Promise} promise which resolves when connection is established\n   */\n  async connect(instanceNumber, region) {\n    if (this._region && region !== this._region) {\n      throw new ValidationError(`Trying to connect to ${region} region, but configured with ${this._region}`);\n    }\n    let clientId = Math.random();\n    let resolve;\n    let result = new Promise((res, rej) => {\n      resolve = res;\n    });\n    this._socketInstances[region] ||= {};\n    this._socketInstances[region][instanceNumber] ||= [];\n    const socketInstanceIndex = this._socketInstances[region][instanceNumber].length;\n    const instance: MetaApiWebsocketClient.SocketInstance = {\n      id: socketInstanceIndex,\n      reconnectWaitTime: this._socketMinimumReconnectTimeout,\n      connected: false,\n      requestResolves: {},\n      resolved: false,\n      connectResult: result,\n      sessionId: randomstring.generate(32),\n      isReconnecting: false,\n      socket: null,\n      synchronizationThrottler: new SynchronizationThrottler(this, socketInstanceIndex, instanceNumber, region,\n        this._synchronizationThrottlerOpts),\n      subscribeLock: null,\n      instanceNumber\n    };\n    instance.connected = true;\n    this._socketInstances[region][instanceNumber].push(instance);\n    instance.synchronizationThrottler.start();\n    const serverUrl = await this._getServerUrl(instanceNumber, socketInstanceIndex, region);\n    const socketInstance = socketIO(serverUrl, {\n      path: '/ws',\n      reconnection: true,\n      reconnectionDelay: 1000,\n      reconnectionDelayMax: 5000,\n      reconnectionAttempts: Infinity,\n      timeout: this._connectTimeout,\n      extraHeaders: {\n        'Client-Id': clientId\n      },\n      query: {\n        'auth-token': this._token,\n        clientId: clientId,\n        protocol: 3\n      }\n    });\n    instance.socket = socketInstance;\n    socketInstance.on('connect', async () => {\n      // eslint-disable-next-line no-console\n      this._logger.info(`${region}:${instanceNumber}: MetaApi websocket client connected to the MetaApi server`);\n      instance.reconnectWaitTime = this._socketMinimumReconnectTimeout;\n      instance.isReconnecting = false;\n      if (!instance.resolved) {\n        instance.resolved = true;\n        resolve();\n      } else {\n        await this._fireReconnected(instanceNumber, instance.id, region);\n      }\n      if (!instance.connected) {\n        instance.socket.close();\n      }\n    });\n    socketInstance.on('reconnect', async () => {\n      instance.isReconnecting = false;\n      this._logger.info(`${region}:${instanceNumber}: MetaApi websocket client reconnected`);\n      await this._fireReconnected(instanceNumber, instance.id, region);\n    });\n    socketInstance.on('connect_error', async (err) => {\n      // eslint-disable-next-line no-console\n      this._logger.error(`${region}:${instanceNumber}: MetaApi websocket client connection error`, err);\n      instance.isReconnecting = false;\n      await this._reconnect(instanceNumber, instance.id, region);\n    });\n    socketInstance.on('connect_timeout', async (timeout) => {\n      // eslint-disable-next-line no-console\n      this._logger.error(`${region}:${instanceNumber}: MetaApi websocket client connection timeout`);\n      instance.isReconnecting = false;\n      if (!instance.resolved) {\n        await this._reconnect(instanceNumber, instance.id, region);\n      }\n    });\n    socketInstance.on('disconnect', async (reason) => {\n      instance.synchronizationThrottler.onDisconnect();\n      // eslint-disable-next-line no-console\n      this._logger.info(`${region}:${instanceNumber}: MetaApi websocket client disconnected from the ` +\n        `MetaApi server because of ${reason}`);\n      instance.isReconnecting = false;\n      await this._reconnect(instanceNumber, instance.id, region);\n    });\n    socketInstance.on('error', async (error) => {\n      // eslint-disable-next-line no-console\n      this._logger.error(`${region}:${instanceNumber}: MetaApi websocket client error`, error);\n      instance.isReconnecting = false;\n      await this._reconnect(instanceNumber, instance.id, region);\n    });\n    socketInstance.on('response', data => {\n      if (typeof data === 'string') {\n        data = JSON.parse(data);\n      }\n      this._logger.debug(() => `${data.accountId}: Response received: ${JSON.stringify({\n        requestId: data.requestId, timestamps: data.timestamps})}`);\n      let requestResolve = (instance.requestResolves[data.requestId] || {resolve: () => {}, reject: () => {}});\n      delete instance.requestResolves[data.requestId];\n      this._convertIsoTimeToDate(data);\n      requestResolve.resolve(data);\n      if (data.timestamps && requestResolve.type) {\n        data.timestamps.clientProcessingFinished = new Date();\n        for (let listener of this._latencyListeners) {\n          Promise.resolve()\n            .then(() => requestResolve.type === 'trade' ?\n              listener.onTrade(data.accountId, data.timestamps) :\n              listener.onResponse(data.accountId, requestResolve.type, data.timestamps))\n            .catch(error => this._logger.error('Failed to process onResponse event for account ' +\n              data.accountId + ', request type ' + requestResolve.type, error));\n        }\n      }\n    });\n    socketInstance.on('processingError', data => {\n      let requestResolve = (instance.requestResolves[data.requestId] || {resolve: () => {}, reject: () => {}});\n      delete instance.requestResolves[data.requestId];\n      requestResolve.reject(this._convertError(data));\n    });\n    // eslint-disable-next-line complexity\n    socketInstance.on('synchronization', async data => {\n      if (typeof data === 'string') {\n        data = JSON.parse(data);\n      }\n      if (data.instanceIndex && data.instanceIndex !== instanceNumber) {\n        this._logger.trace(() => `${data.accountId}:${data.instanceNumber}: received packet with wrong instance ` +\n          `index via a socket with instance number of ${instanceNumber}, data=${JSON.stringify({\n            type: data.type, sequenceNumber: data.sequenceNumber, sequenceTimestamp: data.sequenceTimestamp,\n            synchronizationId: data.synchronizationId, application: data.application, host: data.host,\n            specificationsUpdated: data.specificationsUpdated, positionsUpdated: data.positionsUpdated,\n            ordersUpdated: data.ordersUpdated,\n            specifications: data.specifications ? (data.specifications || []).length : undefined})}`);\n        return;\n      }\n      this._regionsByAccounts[data.accountId] ||= {region, connections: 0, lastUsed: Date.now()};\n      this._logger.trace(() => `${data.accountId}:${data.instanceIndex}: Sync packet received: ${JSON.stringify({\n        type: data.type, sequenceNumber: data.sequenceNumber, sequenceTimestamp: data.sequenceTimestamp,\n        synchronizationId: data.synchronizationId, application: data.application, host: data.host, \n        specificationsUpdated: data.specificationsUpdated, positionsUpdated: data.positionsUpdated,\n        ordersUpdated: data.ordersUpdated, \n        specifications: data.specifications ? (data.specifications || []).length : undefined})}, ` +\n        `active listeners: ${(this._synchronizationListeners[data.accountId] || []).length}`);\n      let activeSynchronizationIds = instance.synchronizationThrottler.activeSynchronizationIds; \n      if (!data.synchronizationId || activeSynchronizationIds.includes(data.synchronizationId)) {\n        if (this._packetLogger) {\n          await this._packetLogger.logPacket(data);\n        }\n        const ignoredPacketTypes = ['disconnected', 'status', 'keepalive'];\n        if (!this._subscriptionManager.isSubscriptionActive(data.accountId) && \n          !ignoredPacketTypes.includes(data.type)) {\n          this._logger.debug(`${data.accountId}: Packet arrived to inactive connection, attempting` +\n            ` unsubscribe, packet: ${data.type}`);\n          if (this._throttleRequest('unsubscribe', data.accountId, data.instanceIndex, \n            this._unsubscribeThrottlingInterval)) {\n            this.unsubscribe(data.accountId).catch(err => {\n              this._logger.warn(`${data.accountId}:${data.instanceIndex || 0}: failed to unsubscribe`, err);\n            });\n          }\n          return;\n        }\n        this._convertIsoTimeToDate(data);\n      } else {\n        data.type = 'noop';\n      }\n      this.queuePacket(instance, data);\n    });\n    socketInstance.on('metadata', (data: MetadataPacket) => {\n      instance.clientApiHostname = data.clientApiHostname;\n    });\n    return result;\n  }\n\n  /**\n   * Closes connection to MetaApi server\n   */\n  close() {\n    Object.keys(this._socketInstances).forEach(region => {\n      Object.keys(this._socketInstances[region]).forEach(instanceNumber => {\n        this._socketInstances[region][instanceNumber].forEach(async (instance) => {\n          if (instance.connected) {\n            instance.connected = false;\n            await instance.socket.close();\n            for (let requestResolve of Object.values<any>(instance.requestResolves)) {\n              requestResolve.reject(new Error('MetaApi connection closed'));\n            }\n            instance.requestResolves = {};\n          }\n        });\n        this._socketInstancesByAccounts[instanceNumber] = {};\n        this._socketInstances[region][instanceNumber] = [];\n      });\n    });\n    this._synchronizationListeners = {};\n    this._latencyListeners = [];\n    this._packetOrderer.stop();\n  }\n\n  /**\n   * Stops the client\n   */\n  stop() {\n    clearInterval(this._clearAccountCacheInterval);\n    clearInterval(this._clearInactiveSyncDataInterval);\n    this._latencyService.stop();\n  }\n\n  /**\n   * Returns account information for a specified MetaTrader account.\n   * @param {String} accountId id of the MetaTrader account to return information for\n   * @param {GetAccountInformationOptions} [options] additional request options\n   * @returns {Promise<MetatraderAccountInformation>} promise resolving with account information\n   */\n  async getAccountInformation(accountId, options) {\n    let response = await this.rpcRequest(accountId, {application: 'RPC', type: 'getAccountInformation', ...options});\n    return response.accountInformation;\n  }\n\n  /**\n   * Returns positions for a specified MetaTrader account.\n   * @param {String} accountId id of the MetaTrader account to return information for\n   * @param {GetPositionsOptions} [options] additional request options\n   * @returns {Promise<Array<MetatraderPosition>} promise resolving with array of open positions\n   */\n  async getPositions(accountId, options) {\n    let response = await this.rpcRequest(accountId, {application: 'RPC', type: 'getPositions', ...options});\n    return response.positions;\n  }\n\n  /**\n   * Returns specific position for a MetaTrader account.\n   * @param {String} accountId id of the MetaTrader account to return information for\n   * @param {String} positionId position id\n   * @param {GetPositionOptions} [options] additional request options\n   * @return {Promise<MetatraderPosition>} promise resolving with MetaTrader position found\n   */\n  async getPosition(accountId, positionId, options) {\n    let response = await this.rpcRequest(accountId, {application: 'RPC', type: 'getPosition', positionId, ...options});\n    return response.position;\n  }\n\n  /**\n   * Returns open orders for a specified MetaTrader account.\n   * @param {String} accountId id of the MetaTrader account to return information for\n   * @param {GetOrdersOptions} [options] additional request options\n   * @return {Promise<Array<MetatraderOrder>>} promise resolving with open MetaTrader orders\n   */\n  async getOrders(accountId, options) {\n    let response = await this.rpcRequest(accountId, {application: 'RPC', type: 'getOrders', ...options});\n    return response.orders;\n  }\n\n  /**\n   * Returns specific open order for a MetaTrader account.\n   * @param {String} accountId id of the MetaTrader account to return information for\n   * @param {String} orderId order id (ticket number)\n   * @param {GetOrderOptions} [options] additional request options\n   * @return {Promise<MetatraderOrder>} promise resolving with metatrader order found\n   */\n  async getOrder(accountId, orderId, options) {\n    let response = await this.rpcRequest(accountId, {application: 'RPC', type: 'getOrder', orderId, ...options});\n    return response.order;\n  }\n\n  /**\n   * MetaTrader history orders search query response\n   * @typedef {Object} MetatraderHistoryOrders\n   * @property {Array<MetatraderOrder>} historyOrders array of history orders returned\n   * @property {Boolean} synchronizing flag indicating that history order initial synchronization is still in progress\n   * and thus search results may be incomplete\n   */\n\n  /**\n   * Returns the history of completed orders for a specific ticket number.\n   * @param {String} accountId id of the MetaTrader account to return information for\n   * @param {String} ticket ticket number (order id)\n   * @returns {Promise<MetatraderHistoryOrders>} promise resolving with request results containing history orders found\n   */\n  async getHistoryOrdersByTicket(accountId, ticket) {\n    let response = await this.rpcRequest(accountId, {application: 'RPC', type: 'getHistoryOrdersByTicket', ticket});\n    return {\n      historyOrders: response.historyOrders,\n      synchronizing: response.synchronizing\n    };\n  }\n\n  /**\n   * Returns the history of completed orders for a specific position id\n   * @param {String} accountId id of the MetaTrader account to return information for\n   * @param {String} positionId position id\n   * @returns {Promise<MetatraderHistoryOrders>} promise resolving with request results containing history orders found\n   */\n  async getHistoryOrdersByPosition(accountId, positionId) {\n    let response = await this.rpcRequest(accountId, {application: 'RPC', type: 'getHistoryOrdersByPosition',\n      positionId});\n    return {\n      historyOrders: response.historyOrders,\n      synchronizing: response.synchronizing\n    };\n  }\n\n  /**\n   * Returns the history of completed orders for a specific time range\n   * @param {String} accountId id of the MetaTrader account to return information for\n   * @param {Date} startTime start of time range, inclusive\n   * @param {Date} endTime end of time range, exclusive\n   * @param {Number} offset pagination offset, default is 0\n   * @param {Number} limit pagination limit, default is 1000\n   * @returns {Promise<MetatraderHistoryOrders>} promise resolving with request results containing history orders found\n   */\n  async getHistoryOrdersByTimeRange(accountId, startTime, endTime, offset = 0, limit = 1000) {\n    let response = await this.rpcRequest(accountId, {application: 'RPC', type: 'getHistoryOrdersByTimeRange',\n      startTime, endTime, offset, limit});\n    return {\n      historyOrders: response.historyOrders,\n      synchronizing: response.synchronizing\n    };\n  }\n\n  /**\n   * MetaTrader history deals search query response\n   * @typedef {Object} MetatraderDeals\n   * @property {Array<MetatraderDeal>} deals array of history deals returned\n   * @property {Boolean} synchronizing flag indicating that deal initial synchronization is still in progress\n   * and thus search results may be incomplete\n   */\n\n  /**\n   * MetaTrader deal\n   * @typedef {Object} MetatraderDeal\n   * @property {String} id deal id (ticket number)\n   * @property {String} type deal type (one of DEAL_TYPE_BUY, DEAL_TYPE_SELL, DEAL_TYPE_BALANCE, DEAL_TYPE_CREDIT,\n   * DEAL_TYPE_CHARGE, DEAL_TYPE_CORRECTION, DEAL_TYPE_BONUS, DEAL_TYPE_COMMISSION, DEAL_TYPE_COMMISSION_DAILY,\n   * DEAL_TYPE_COMMISSION_MONTHLY, DEAL_TYPE_COMMISSION_AGENT_DAILY, DEAL_TYPE_COMMISSION_AGENT_MONTHLY,\n   * DEAL_TYPE_INTEREST, DEAL_TYPE_BUY_CANCELED, DEAL_TYPE_SELL_CANCELED, DEAL_DIVIDEND, DEAL_DIVIDEND_FRANKED,\n   * DEAL_TAX). See https://www.mql5.com/en/docs/constants/tradingconstants/dealproperties#enum_deal_type\n   * @property {String} entryType deal entry type (one of DEAL_ENTRY_IN, DEAL_ENTRY_OUT, DEAL_ENTRY_INOUT,\n   * DEAL_ENTRY_OUT_BY). See https://www.mql5.com/en/docs/constants/tradingconstants/dealproperties#enum_deal_entry\n   * @property {String} [symbol] symbol deal relates to\n   * @property {Number} [magic] deal magic number, identifies the EA which initiated the deal\n   * @property {Date} time time the deal was conducted at\n   * @property {String} brokerTime time time the deal was conducted at, in broker timezone, YYYY-MM-DD HH:mm:ss.SSS format\n   * @property {Number} [volume] deal volume\n   * @property {Number} [price] the price the deal was conducted at\n   * @property {Number} [commission] deal commission\n   * @property {Number} [swap] deal swap\n   * @property {Number} profit deal profit\n   * @property {String} [positionId] id of position the deal relates to\n   * @property {String} [orderId] id of order the deal relates to\n   * @property {String} [comment] deal comment. The sum of the line lengths of the comment and the clientId\n   * must be less than or equal to 26. For more information see https://metaapi.cloud/docs/client/clientIdUsage/\n   * @property {String} [brokerComment] current comment value on broker side (possibly overriden by the broker)\n   * @property {String} [clientId] client-assigned id. The id value can be assigned when submitting a trade and\n   * will be present on position, history orders and history deals related to the trade. You can use this field to bind\n   * your trades to objects in your application and then track trade progress. The sum of the line lengths of the\n   * comment and the clientId must be less than or equal to 26. For more information see\n   * https://metaapi.cloud/docs/client/clientIdUsage/\n   * @property {String} platform platform id (mt4 or mt5)\n   * @property {String} [reason] optional deal execution reason. One of DEAL_REASON_CLIENT, DEAL_REASON_MOBILE,\n   * DEAL_REASON_WEB, DEAL_REASON_EXPERT, DEAL_REASON_SL, DEAL_REASON_TP, DEAL_REASON_SO, DEAL_REASON_ROLLOVER,\n   * DEAL_REASON_VMARGIN, DEAL_REASON_SPLIT, DEAL_REASON_UNKNOWN. See\n   * https://www.mql5.com/en/docs/constants/tradingconstants/dealproperties#enum_deal_reason.\n   * @property {Number} [accountCurrencyExchangeRate] current exchange rate of account currency into account base\n   * currency (USD if you did not override it)\n   * @property {number} [stopLoss] deal stop loss. For MT5 opening deal this is the SL of the order opening the \n   * position. For MT4 deals or MT5 closing deal this is the last known position SL.\n   * @property {number} [takeProfit] deal take profit. For MT5 opening deal this is the TP of the order opening the \n   * position. For MT4 deals or MT5 closing deal this is the last known position TP.\n   */\n\n  /**\n   * Returns history deals with a specific ticket number\n   * @param {String} accountId id of the MetaTrader account to return information for\n   * @param {String} ticket ticket number (deal id for MT5 or order id for MT4)\n   * @returns {Promise<MetatraderDeals>} promise resolving with request results containing deals found\n   */\n  async getDealsByTicket(accountId, ticket) {\n    let response = await this.rpcRequest(accountId, {application: 'RPC', type: 'getDealsByTicket', ticket});\n    return {\n      deals: response.deals,\n      synchronizing: response.synchronizing\n    };\n  }\n\n  /**\n   * Returns history deals for a specific position id\n   * @param {String} accountId id of the MetaTrader account to return information for\n   * @param {String} positionId position id\n   * @returns {Promise<MetatraderDeals>} promise resolving with request results containing deals found\n   */\n  async getDealsByPosition(accountId, positionId) {\n    let response = await this.rpcRequest(accountId, {application: 'RPC', type: 'getDealsByPosition', positionId});\n    return {\n      deals: response.deals,\n      synchronizing: response.synchronizing\n    };\n  }\n\n  /**\n   * Returns history deals with for a specific time range\n   * @param {String} accountId id of the MetaTrader account to return information for\n   * @param {Date} startTime start of time range, inclusive\n   * @param {Date} endTime end of time range, exclusive\n   * @param {Number} offset pagination offset, default is 0\n   * @param {Number} limit pagination limit, default is 1000\n   * @returns {Promise<MetatraderDeals>} promise resolving with request results containing deals found\n   */\n  async getDealsByTimeRange(accountId, startTime, endTime, offset = 0, limit = 1000) {\n    let response = await this.rpcRequest(accountId, {application: 'RPC', type: 'getDealsByTimeRange', startTime,\n      endTime, offset, limit});\n    return {\n      deals: response.deals,\n      synchronizing: response.synchronizing\n    };\n  }\n\n  /**\n   * Clears the order and transaction history of a specified application and removes the application\n   * @param {String} accountId id of the MetaTrader account to remove history and application for\n   * @return {Promise} promise resolving when the history is cleared\n   */\n  removeApplication(accountId) {\n    return this.rpcRequest(accountId, {type: 'removeApplication'});\n  }\n\n  /**\n   * MetaTrader trade response\n   * @typedef {Object} MetatraderTradeResponse\n   * @property {Number} numericCode numeric response code, see\n   * https://www.mql5.com/en/docs/constants/errorswarnings/enum_trade_return_codes and\n   * https://book.mql4.com/appendix/errors. Response codes which indicate success are 0, 10008-10010, 10025. The rest\n   * codes are errors\n   * @property {String} stringCode string response code, see\n   * https://www.mql5.com/en/docs/constants/errorswarnings/enum_trade_return_codes and\n   * https://book.mql4.com/appendix/errors. Response codes which indicate success are ERR_NO_ERROR,\n   * TRADE_RETCODE_PLACED, TRADE_RETCODE_DONE, TRADE_RETCODE_DONE_PARTIAL, TRADE_RETCODE_NO_CHANGES. The rest codes are\n   * errors.\n   * @property {String} message human-readable response message\n   * @property {String} orderId order id which was created/modified during the trade\n   * @property {String} positionId position id which was modified during the trade\n   */\n\n  /**\n   * Execute a trade on a connected MetaTrader account\n   * @param {String} accountId id of the MetaTrader account to execute trade for\n   * @param {MetatraderTrade} trade trade to execute (see docs for possible trade types)\n   * @param {String} [application] application to use\n   * @param {String} [reliability] account reliability\n   * @returns {Promise<MetatraderTradeResponse>} promise resolving with trade result\n   * @throws {TradeError} on trade error, check error properties for error code details\n   */\n  // eslint-disable-next-line complexity\n  async trade(accountId, trade, application, reliability) {\n    let response;\n    if (application === 'RPC') {\n      response = await this.rpcRequest(accountId, {type: 'trade', trade, application});\n    } else {\n      response = await this.rpcRequestAllInstances(accountId, {type: 'trade', trade,\n        application: application || this._application, requestId: randomstring.generate(32)}, reliability);\n    }\n    response.response = response.response || {};\n    response.response.stringCode = response.response.stringCode || response.response.description;\n    response.response.numericCode = response.response.numericCode !== undefined ? response.response.numericCode :\n      response.response.error;\n    if (['ERR_NO_ERROR', 'TRADE_RETCODE_PLACED', 'TRADE_RETCODE_DONE', 'TRADE_RETCODE_DONE_PARTIAL',\n      'TRADE_RETCODE_NO_CHANGES'].includes(response.response.stringCode || response.response.description)) {\n      return response.response;\n    } else {\n      throw new TradeError(response.response.message, response.response.numericCode, response.response.stringCode);\n    }\n  }\n\n  /**\n   * Creates a task that ensures the account gets subscribed to the server\n   * @param {String} accountId account id to subscribe\n   * @param {Number} instanceNumber instance index number\n   */\n  ensureSubscribe(accountId, instanceNumber) {\n    this._subscriptionManager.scheduleSubscribe(accountId, instanceNumber);\n  }\n\n  /**\n   * Subscribes to the Metatrader terminal events\n   * @param {String} accountId id of the MetaTrader account to subscribe to\n   * @param {Number} instanceNumber instance index number\n   * @returns {Promise} promise which resolves when subscription started\n   */\n  subscribe(accountId, instanceNumber) {\n    return this._subscriptionManager.subscribe(accountId, instanceNumber);\n  }\n\n  /**\n   * Requests the terminal to start synchronization process\n   * @param {String} accountId id of the MetaTrader account to synchronize\n   * @param {Number} instanceIndex instance index\n   * @param {String} host name of host to synchronize with\n   * @param {String} synchronizationId synchronization request id\n   * @param {Date} startingHistoryOrderTime from what date to start synchronizing history orders from. If not specified,\n   * the entire order history will be downloaded.\n   * @param {Date} startingDealTime from what date to start deal synchronization from. If not specified, then all\n   * history deals will be downloaded.\n   * @param {Function} getHashes function to get terminal state hashes\n   * @returns {Promise} promise which resolves when synchronization started\n   */\n  async synchronize(\n    accountId, instanceIndex, host, synchronizationId, startingHistoryOrderTime, startingDealTime, hashes\n  ) {\n    if (this._getSocketInstanceByAccount(accountId, instanceIndex) === undefined) {\n      this._logger.debug(`${accountId}:${instanceIndex}: creating socket instance on synchronize`);\n      await this._createSocketInstanceByAccount(accountId, instanceIndex);\n    }\n    const syncThrottler = this._getSocketInstanceByAccount(accountId, instanceIndex).synchronizationThrottler;\n    this._synchronizationHashes[synchronizationId] = hashes;\n    this._synchronizationHashes[synchronizationId].lastUpdated = Date.now();\n    return syncThrottler.scheduleSynchronize(accountId, {requestId: synchronizationId, version: 2,\n      type: 'synchronize', startingHistoryOrderTime, startingDealTime, instanceIndex, host}, hashes);\n  }\n\n  /**\n   * Waits for server-side terminal state synchronization to complete\n   * @param {String} accountId id of the MetaTrader account to synchronize\n   * @param {Number} [instanceNumber] instance index number\n   * @param {String} applicationPattern MetaApi application regular expression pattern, default is .*\n   * @param {Number} timeoutInSeconds timeout in seconds, default is 300 seconds\n   * @param {String} [application] application to synchronize with\n   * @returns {Promise} promise which resolves when synchronization started\n   */\n  waitSynchronized(accountId, instanceNumber, applicationPattern, timeoutInSeconds, application?) {\n    return this.rpcRequest(accountId, {type: 'waitSynchronized', applicationPattern, timeoutInSeconds,\n      instanceIndex: instanceNumber, application: application || this._application},\n    timeoutInSeconds + 1);\n  }\n\n  /**\n   * Market data subscription\n   * @typedef {Object} MarketDataSubscription\n   * @property {string} type subscription type, one of quotes, candles, ticks, or marketDepth\n   * @property {string} [timeframe] when subscription type is candles, defines the timeframe according to which the\n   * candles must be generated. Allowed values for MT5 are 1m, 2m, 3m, 4m, 5m, 6m, 10m, 12m, 15m, 20m, 30m, 1h, 2h, 3h,\n   * 4h, 6h, 8h, 12h, 1d, 1w, 1mn. Allowed values for MT4 are 1m, 5m, 15m 30m, 1h, 4h, 1d, 1w, 1mn\n   * @property {number} [intervalInMilliseconds] defines how frequently the terminal will stream data to client. If not\n   * set, then the value configured in account will be used\n   */\n\n  /**\n   * Subscribes on market data of specified symbol\n   * @param {String} accountId id of the MetaTrader account\n   * @param {String} symbol symbol (e.g. currency pair or an index)\n   * @param {Array<MarketDataSubscription>} subscriptions array of market data subscription to create or update\n   * @param {String} [reliability] account reliability\n   * @returns {Promise} promise which resolves when subscription request was processed\n   */\n  subscribeToMarketData(accountId, symbol, subscriptions, reliability) {\n    return this.rpcRequestAllInstances(accountId,\n      {type: 'subscribeToMarketData', symbol, subscriptions}, reliability);\n  }\n\n  /**\n   * Refreshes market data subscriptions on the server to prevent them from expiring\n   * @param {String} accountId id of the MetaTrader account\n   * @param {Number} instanceNumber instance index number\n   * @param {Array} subscriptions array of subscriptions to refresh\n   */\n  refreshMarketDataSubscriptions(accountId, instanceNumber, subscriptions) {\n    return this.rpcRequest(accountId, {type: 'refreshMarketDataSubscriptions', subscriptions,\n      instanceIndex: instanceNumber});\n  }\n\n  /**\n   * Market data unsubscription\n   * @typedef {Object} MarketDataUnsubscription\n   * @property {string} type subscription type, one of quotes, candles, ticks, or marketDepth\n   */\n\n  /**\n   * Unsubscribes from market data of specified symbol\n   * @param {String} accountId id of the MetaTrader account\n   * @param {String} symbol symbol (e.g. currency pair or an index)\n   * @param {Array<MarketDataUnsubscription>} subscriptions array of subscriptions to cancel\n   * @param {String} [reliability] account reliability\n   * @returns {Promise} promise which resolves when unsubscription request was processed\n   */\n  unsubscribeFromMarketData(accountId, symbol, subscriptions, reliability) {\n    return this.rpcRequestAllInstances(accountId, {type: 'unsubscribeFromMarketData', symbol, subscriptions},\n      reliability);\n  }\n\n  /**\n   * Retrieves symbols available on an account\n   * @param {String} accountId id of the MetaTrader account to retrieve symbols for\n   * @returns {Promise<Array<string>>} promise which resolves when symbols are retrieved\n   */\n  async getSymbols(accountId) {\n    let response = await this.rpcRequest(accountId, {application: 'RPC', type: 'getSymbols'});\n    return response.symbols;\n  }\n\n  /**\n   * Retrieves specification for a symbol\n   * @param {String} accountId id of the MetaTrader account to retrieve symbol specification for\n   * @param {String} symbol symbol to retrieve specification for\n   * @returns {Promise<MetatraderSymbolSpecification>} promise which resolves when specification is retrieved\n   */\n  async getSymbolSpecification(accountId, symbol) {\n    let response = await this.rpcRequest(accountId, {application: 'RPC', type: 'getSymbolSpecification', symbol});\n    return response.specification;\n  }\n\n  /**\n   * Retrieves price for a symbol\n   * @param {String} accountId id of the MetaTrader account to retrieve symbol price for\n   * @param {String} symbol symbol to retrieve price for\n   * @param {boolean} keepSubscription if set to true, the account will get a long-term subscription to symbol market\n   * data. Long-term subscription means that on subsequent calls you will get updated value faster. If set to false or\n   * not set, the subscription will be set to expire in 12 minutes.\n   * @returns {Promise<MetatraderSymbolPrice>} promise which resolves when price is retrieved\n   */\n  async getSymbolPrice(accountId, symbol, keepSubscription = false) {\n    let response = await this.rpcRequest(accountId, {application: 'RPC', type: 'getSymbolPrice', symbol,\n      keepSubscription});\n    return response.price;\n  }\n\n  /**\n   * Retrieves price for a symbol\n   * @param {string} accountId id of the MetaTrader account to retrieve candle for\n   * @param {string} symbol symbol to retrieve candle for\n   * @param {string} timeframe defines the timeframe according to which the candle must be generated. Allowed values for\n   * MT5 are 1m, 2m, 3m, 4m, 5m, 6m, 10m, 12m, 15m, 20m, 30m, 1h, 2h, 3h, 4h, 6h, 8h, 12h, 1d, 1w, 1mn. Allowed values\n   * for MT4 are 1m, 5m, 15m 30m, 1h, 4h, 1d, 1w, 1mn\n   * @param {boolean} keepSubscription if set to true, the account will get a long-term subscription to symbol market\n   * data. Long-term subscription means that on subsequent calls you will get updated value faster. If set to false or\n   * not set, the subscription will be set to expire in 12 minutes.\n   * @returns {Promise<MetatraderCandle>} promise which resolves when candle is retrieved\n   */\n  async getCandle(accountId, symbol, timeframe, keepSubscription = false) {\n    let response = await this.rpcRequest(accountId, {application: 'RPC', type: 'getCandle', symbol, timeframe,\n      keepSubscription});\n    return response.candle;\n  }\n\n  /**\n   * Retrieves latest tick for a symbol. MT4 G1 accounts do not support this API\n   * @param {string} accountId id of the MetaTrader account to retrieve symbol tick for\n   * @param {string} symbol symbol to retrieve tick for\n   * @param {boolean} keepSubscription if set to true, the account will get a long-term subscription to symbol market\n   * data. Long-term subscription means that on subsequent calls you will get updated value faster. If set to false or\n   * not set, the subscription will be set to expire in 12 minutes.\n   * @returns {Promise<MetatraderTick>} promise which resolves when tick is retrieved\n   */\n  async getTick(accountId, symbol, keepSubscription = false) {\n    let response = await this.rpcRequest(accountId, {application: 'RPC', type: 'getTick', symbol, keepSubscription});\n    return response.tick;\n  }\n\n  /**\n   * Retrieves latest order book for a symbol. MT4 accounts do not support this API\n   * @param {string} accountId id of the MetaTrader account to retrieve symbol order book for\n   * @param {string} symbol symbol to retrieve order book for\n   * @param {boolean} keepSubscription if set to true, the account will get a long-term subscription to symbol market\n   * data. Long-term subscription means that on subsequent calls you will get updated value faster. If set to false or\n   * not set, the subscription will be set to expire in 12 minutes.\n   * @returns {Promise<MetatraderBook>} promise which resolves when order book is retrieved\n   */\n  async getBook(accountId, symbol, keepSubscription = false) {\n    let response = await this.rpcRequest(accountId, {application: 'RPC', type: 'getBook', symbol, keepSubscription});\n    return response.book;\n  }\n\n  /**\n   * Forces refresh of most recent quote updates for symbols subscribed to by the terminal\n   * @param {string} accountId id of the MetaTrader account\n   * @returns {Promise<string[]>} promise which resolves with recent quote symbols that was initiated to process\n   */\n  async refreshTerminalState(accountId) {\n    let response = await this.rpcRequest(accountId, {application: 'RPC', type: 'refreshTerminalState'});\n    return response.symbols;\n  }\n\n  /**\n   * Forces refresh and retrieves latest quotes for a subset of symbols the terminal is subscribed to\n   * @param {string} accountId id of the MetaTrader account\n   * @param {string[]} symbols quote symbols to refresh\n   * @returns {Promise<RefreshedQuotes>} refreshed quotes and basic account information info\n   */\n  async refreshSymbolQuotes(accountId, symbols) {\n    let response = await this.rpcRequest(accountId, {application: 'RPC', type: 'refreshSymbolQuotes', symbols});\n    return response.refreshedQuotes;\n  }\n\n  /**\n   * Sends client uptime stats to the server.\n   * @param {String} accountId id of the MetaTrader account to save uptime\n   * @param {Object} uptime uptime statistics to send to the server\n   * @returns {Promise} promise which resolves when uptime statistics is submitted\n   */\n  saveUptime(accountId, uptime) {\n    return this.rpcRequest(accountId, {type: 'saveUptime', uptime});\n  }\n\n  /**\n   * Unsubscribe from account\n   * @param {String} accountId id of the MetaTrader account to unsubscribe\n   * @returns {Promise} promise which resolves when socket unsubscribed\n   */\n  async unsubscribe(accountId) {\n    const region = this.getAccountRegion(accountId);\n    this._latencyService.onUnsubscribe(accountId);\n    Object.keys(this._updateEvents)\n      .filter(key => key.startsWith(accountId))\n      .forEach(key => delete this._updateEvents[key]);\n    if (this._socketInstances[region]) {\n      await Promise.all(Object.keys(this._socketInstances[region]).map(async instanceNumber => {\n        try {\n          await this._subscriptionManager.unsubscribe(accountId, Number(instanceNumber));\n          delete this._socketInstancesByAccounts[instanceNumber][accountId];\n        } catch (err) {\n          if (!(['TimeoutError', 'NotFoundError'].includes(err.name))) {\n            this._logger.warn(`${accountId}:${instanceNumber}: failed to unsubscribe`, err);\n          }\n        }\n      }));\n    }\n  }\n\n  /**\n   * Current server time (see https://metaapi.cloud/docs/client/models/serverTime/)\n   * @typedef {Object} ServerTime\n   * @property {Date} time current server time\n   * @property {String} brokerTime current broker time, in broker timezone, YYYY-MM-DD HH:mm:ss.SSS format\n   * @property {Date} [lastQuoteTime] last quote time\n   * @property {String} [lastQuoteBrokerTime] last quote time, in broker timezone, YYYY-MM-DD HH:mm:ss.SSS format\n   */\n\n  /**\n   * Returns server time for a specified MetaTrader account\n   * @param {string} accountId id of the MetaTrader account to return server time for\n   * @returns {Promise<ServerTime>} promise resolving with server time\n   */\n  async getServerTime(accountId) {\n    let response = await this.rpcRequest(accountId, {application: 'RPC', type: 'getServerTime'});\n    return response.serverTime;\n  }\n\n  /**\n   * Margin required to open a trade (see https://metaapi.cloud/docs/client/models/margin/)\n   * @typedef {Object} Margin\n   * @property {number} [margin] margin required to open a trade. If margin can not be calculated, then this field is\n   * not defined\n   */\n\n  /**\n   * Contains order to calculate margin for (see https://metaapi.cloud/docs/client/models/marginOrder/)\n   * @typedef {Object} MarginOrder\n   * @property {string} symbol order symbol\n   * @property {string} type order type, one of ORDER_TYPE_BUY or ORDER_TYPE_SELL\n   * @property {number} volume order volume, must be greater than 0\n   * @property {number} openPrice order open price, must be greater than 0\n   */\n\n  /**\n   * Calculates margin required to open a trade on the specified trading account\n   * @param {string} accountId id of the trading account to calculate margin for\n   * @param {string} application application to send the request to\n   * @param {string} reliability account reliability\n   * @param {MarginOrder} order order to calculate margin for\n   * @returns {Promise<Margin>} promise resolving with margin calculation result\n   */\n  async calculateMargin(accountId, application, reliability, order) {\n    let response;\n    if (application === 'RPC') {\n      response = await this.rpcRequest(accountId, {application, type: 'calculateMargin', order});\n    } else {\n      response = await this.rpcRequestAllInstances(accountId, {application, type: 'calculateMargin', order},\n        reliability);\n    }\n    return response.margin;\n  }\n\n  /**\n   * Calls onUnsubscribeRegion listener event \n   * @param {String} accountId account id\n   * @param {String} region account region to unsubscribe\n   */\n  async unsubscribeAccountRegion(accountId, region) {\n    const unsubscribePromises = [];\n    for (let listener of this._synchronizationListeners[accountId] || []) {\n      unsubscribePromises.push(this\n        ._processEvent(() => listener.onUnsubscribeRegion(region), `${accountId}:${region}:onUnsubscribeRegion`, true)\n        .catch(err => this._logger.error(\n          `${accountId}:${region}: Failed to notify listener about onUnsubscribeRegion event`, err\n        ))\n      );\n    }\n    await Promise.all(unsubscribePromises);\n  }\n\n  /**\n   * Adds synchronization listener for specific account\n   * @param {String} accountId account id\n   * @param {SynchronizationListener} listener synchronization listener to add\n   */\n  addSynchronizationListener(accountId, listener) {\n    this._logger.trace(`${accountId}: Added synchronization listener`);\n    let listeners = this._synchronizationListeners[accountId];\n    if (!listeners) {\n      listeners = [];\n      this._synchronizationListeners[accountId] = listeners;\n    }\n    listeners.push(listener);\n  }\n\n  /**\n   * Removes synchronization listener for specific account\n   * @param {String} accountId account id\n   * @param {SynchronizationListener} listener synchronization listener to remove\n   */\n  removeSynchronizationListener(accountId, listener) {\n    this._logger.trace(`${accountId}: Removed synchronization listener`);\n    let listeners = this._synchronizationListeners[accountId];\n    if (!listeners) {\n      listeners = [];\n    }\n    listeners = listeners.filter(l => l !== listener);\n    this._synchronizationListeners[accountId] = listeners;\n  }\n\n  /**\n   * Adds latency listener\n   * @param {LatencyListener} listener latency listener to add\n   */\n  addLatencyListener(listener) {\n    this._latencyListeners.push(listener);\n  }\n\n  /**\n   * Removes latency listener\n   * @param {LatencyListener} listener latency listener to remove\n   */\n  removeLatencyListener(listener) {\n    this._latencyListeners = this._latencyListeners.filter(l => l !== listener);\n  }\n\n  /**\n   * Adds reconnect listener\n   * @param {ReconnectListener} listener reconnect listener to add\n   * @param {String} accountId account id of listener\n   */\n  addReconnectListener(listener, accountId) {\n    this._reconnectListeners.push({accountId, listener});\n  }\n\n  /**\n   * Removes reconnect listener\n   * @param {ReconnectListener} listener listener to remove\n   */\n  removeReconnectListener(listener) {\n    this._reconnectListeners = this._reconnectListeners.filter(l => l.listener !== listener);\n  }\n\n  /**\n   * Removes all listeners. Intended for use in unit tests.\n   */\n  removeAllListeners() {\n    this._synchronizationListeners = {};\n    this._reconnectListeners = [];\n  }\n\n  /**\n   * Clears account or replica data from client records and unsubscribes\n   * @param {string} accountId account id to process the removal of\n   */\n  onAccountDeleted(accountId) {\n    this._subscriptionManager.cancelAccount(accountId);\n    this._latencyService.onUnsubscribe(accountId);\n    const masterAccountId = this._accountsByReplicaId[accountId];\n    if (masterAccountId) {\n      if (masterAccountId === accountId) {\n        const regionData = this._accountReplicas[masterAccountId];\n        const replicas = Object.values<any>(regionData);\n        Object.keys(this._synchronizationIdByInstance)\n          .filter(instance => instance.startsWith(`${masterAccountId}`))\n          .forEach(instance => delete this._synchronizationIdByInstance[instance]);\n        replicas.forEach(replica => {\n          Object.values(this._socketInstancesByAccounts).forEach(instance => delete instance[replica]);\n          delete this._accountsByReplicaId[replica];\n          delete this._regionsByAccounts[replica];\n        });\n        delete this._accountReplicas[masterAccountId];\n        this._logger.debug(`${masterAccountId}: processed primary account removal`);\n      } else {\n        Object.values(this._socketInstancesByAccounts).forEach(instance => delete instance[accountId]);\n        const regionData = this._regionsByAccounts[accountId];\n        if (regionData) {\n          const region = regionData.region;\n          Object.keys(this._synchronizationIdByInstance)\n            .filter(instance => instance.startsWith(`${masterAccountId}:${region}`))\n            .forEach(instance => delete this._synchronizationIdByInstance[instance]);\n          delete this._accountReplicas[masterAccountId][region];\n          this._logger.debug(`${masterAccountId}: processed removal of replica ${accountId}`);\n        }\n        delete this._accountsByReplicaId[accountId];\n        delete this._regionsByAccounts[accountId];\n      }\n    }\n  }\n  \n  /**\n   * Queues an account packet for processing\n   * @param {Object} packet packet to process\n   */\n  queuePacket(socket: MetaApiWebsocketClient.SocketInstance, packet) {\n    const accountId = packet.accountId;\n    const packets = this._packetOrderer.restoreOrder<RestoredOrderPacket>({\n      accountId: packet.accountId,\n      host: packet.host,\n      instanceIndex: packet.instanceIndex,\n      sequenceNumber: packet.sequenceNumber,\n      sequenceTimestamp: packet.sequenceTimestamp,\n      synchronizationId: packet.synchronizationId,\n      type: packet.type,\n      socket, packet\n    }).filter(p => p.type !== 'noop');\n    if (this._sequentialEventProcessing && packet.sequenceNumber !== undefined) {\n      const events = packets.map((item: RestoredOrderPacket) => () => (\n        this._processSynchronizationPacket(item.socket, item.packet)\n      ));\n      if (!this._eventQueues[accountId]) {\n        this._eventQueues[accountId] = events;\n        this._callAccountEvents(accountId);\n      } else {\n        this._eventQueues[accountId] = this._eventQueues[accountId].concat(events);\n      }\n    } else {\n      packets.forEach((item: RestoredOrderPacket) => this._processSynchronizationPacket(item.socket, item.packet));\n    }\n  }\n\n  /**\n   * Queues account event for processing\n   * @param {String} accountId account id\n   * @param {String} name event label name\n   * @param {Function} callable async or regular function to execute\n   */\n  queueEvent(accountId, name, callable) {\n    let event = () => this._processEvent(callable, `${accountId}:${name}`);\n    if (this._sequentialEventProcessing) {\n      if (!this._eventQueues[accountId]) { \n        this._eventQueues[accountId] = [event];\n        this._callAccountEvents(accountId);\n      } else {\n        this._eventQueues[accountId].push(event);\n      }\n    } else {\n      event();\n    }\n  }\n\n  async _callAccountEvents(accountId) {\n    if (this._eventQueues[accountId]) {\n      while(this._eventQueues[accountId].length) {\n        await this._eventQueues[accountId][0]();\n        this._eventQueues[accountId].shift();\n      }\n      delete this._eventQueues[accountId];\n    }\n  }\n\n  async _reconnect(instanceNumber, socketInstanceIndex, region) {\n    const instance = this.socketInstances[region][instanceNumber][socketInstanceIndex];\n    if (instance) {\n      while (!instance.socket.connected && !instance.isReconnecting && instance.connected) {\n        await this._tryReconnect(instanceNumber, socketInstanceIndex, region);\n      }\n    }\n  }\n\n  _tryReconnect(instanceNumber, socketInstanceIndex, region) {\n    const instance = this.socketInstances[region][instanceNumber][socketInstanceIndex];\n    instance.reconnectWaitTime = Math.min(instance.reconnectWaitTime * 2, 30000);\n    return new Promise<void>((resolve) => setTimeout(async () => {\n      if (!instance.socket.connected && !instance.isReconnecting && instance.connected) {\n        try {\n          instance.sessionId = randomstring.generate(32);\n          const clientId = Math.random();\n          instance.socket.close();\n          instance.socket.io.opts.extraHeaders['Client-Id'] = clientId;\n          instance.socket.io.opts.query.clientId = clientId;\n          instance.isReconnecting = true;\n          instance.socket.io.uri = await this._getServerUrl(instanceNumber, socketInstanceIndex, region);\n          instance.socket.connect();\n        } catch (error) {\n          instance.isReconnecting = false;\n        }\n      }\n      resolve();\n    }, instance.reconnectWaitTime));\n  }\n\n  /**\n   * Simulataneously sends RPC requests to all synchronized instances\n   * @param {String} accountId metatrader account id\n   * @param {Object} request base request data\n   * @param {String} [reliability] account reliability\n   * @param {Number} [timeoutInSeconds] request timeout in seconds\n   */\n  async rpcRequestAllInstances(accountId, request, reliability?, timeoutInSeconds?) {\n    if (reliability === 'high') {\n      try {\n        return await any([0, 1].map(instanceNumber => {\n          return this.rpcRequest(accountId, Object.assign({}, request, \n            {instanceIndex: instanceNumber}), timeoutInSeconds);\n        }));\n      } catch (error) {\n        throw error.errors[0]; \n      }\n    } else {\n      return await this.rpcRequest(accountId, request, timeoutInSeconds);\n    }\n  }\n\n  /**\n   * Makes a RPC request\n   * @param {String} accountId replica account id\n   * @param {Object} request base request data\n   * @param {Number} [timeoutInSeconds] request timeout in seconds\n   */\n  //eslint-disable-next-line complexity, max-statements\n  async rpcRequest(accountId: string, request, timeoutInSeconds?): Promise<any> {\n    const ignoredRequestTypes = ['subscribe', 'synchronize', 'refreshMarketDataSubscriptions', 'unsubscribe'];\n    const primaryAccountId = this._accountsByReplicaId[accountId];\n    let connectedInstance = this._latencyService.getActiveAccountInstances(primaryAccountId)[0];\n    if (!ignoredRequestTypes.includes(request.type)) {\n      connectedInstance ||= await this._latencyService.waitConnectedInstance(accountId);\n      const activeRegion = connectedInstance.split(':')[1];\n      accountId = this._accountReplicas[primaryAccountId][activeRegion];\n    }\n    let socketInstanceIndex = null;\n    let instanceNumber = 0;\n    const region = this.getAccountRegion(accountId);\n    this._refreshAccountRegion(accountId);\n    if (request.instanceIndex !== undefined) {\n      instanceNumber = request.instanceIndex;\n    } else {\n      if (connectedInstance) {\n        instanceNumber = Number(connectedInstance.split(':')[2]);\n      }\n      if (request.application !== 'RPC') {\n        request = Object.assign({}, request, {instanceIndex: instanceNumber});\n      }\n    }\n    this._socketInstancesByAccounts[instanceNumber] ||= {};\n    this._socketInstances[region] ||= {};\n    this._socketInstances[region][instanceNumber] ||= [];\n    if (this._socketInstancesByAccounts[instanceNumber][accountId] !== undefined) {\n      socketInstanceIndex = this._socketInstancesByAccounts[instanceNumber][accountId];\n    } else {\n      this._logger.debug(`${accountId}:${instanceNumber}: creating socket instance on RPC request`);\n      await this._createSocketInstanceByAccount(accountId, instanceNumber);\n      socketInstanceIndex = this._socketInstancesByAccounts[instanceNumber][accountId];\n    }\n    const instance = this._socketInstances[region][instanceNumber][socketInstanceIndex];\n    if (!instance.connected) {\n      this._logger.debug(`${accountId}:${instanceNumber}: connecting socket instance on RPC request`);\n      await this.connect(instanceNumber, region);\n    } else if (!this.connected(instanceNumber, socketInstanceIndex, region)) {\n      await instance.connectResult;\n    }\n    if (request.type === 'subscribe') {\n      request.sessionId = instance.sessionId;\n    }\n    if (['trade', 'subscribe'].includes(request.type)) {\n      return this._makeRequest(accountId, instanceNumber, request, timeoutInSeconds);\n    }\n    let retryCounter = 0;\n    while (true) { //eslint-disable-line no-constant-condition\n      try {\n        return await this._makeRequest(accountId, instanceNumber, request, timeoutInSeconds);\n      } catch (err) {\n        if (err.name === 'TooManyRequestsError') {\n          let calcRetryCounter = retryCounter;\n          let calcRequestTime = 0;\n          while (calcRetryCounter < this._retries) {\n            calcRetryCounter++;\n            calcRequestTime += Math.min(Math.pow(2, calcRetryCounter) * this._minRetryDelayInSeconds,\n              this._maxRetryDelayInSeconds) * 1000;\n          }\n          const retryTime = new Date(err.metadata.recommendedRetryTime).getTime();\n          if (Date.now() + calcRequestTime > retryTime && retryCounter < this._retries) {\n            if (Date.now() < retryTime) {\n              await new Promise(res => setTimeout(res, retryTime - Date.now()));\n            }\n            retryCounter++;\n          } else {\n            throw err;\n          }\n        } else if (['NotSynchronizedError', 'TimeoutError', 'NotAuthenticatedError',\n          'InternalError'].includes(err.name) && \n          retryCounter < this._retries) {\n          await new Promise(res => setTimeout(res, Math.min(Math.pow(2, retryCounter) * \n            this._minRetryDelayInSeconds, this._maxRetryDelayInSeconds) * 1000));\n          retryCounter++;\n        } else {\n          throw err;\n        }\n        if (this._socketInstancesByAccounts[instanceNumber][accountId] === undefined) {\n          throw err;\n        }\n      }\n    }\n  }\n\n  private _makeRequest(accountId, instanceNumber, request, timeoutInSeconds) {\n    const socketInstance = this._getSocketInstanceByAccount(accountId, instanceNumber);\n    let requestId = request.requestId || randomstring.generate(32);\n    request.timestamps = {clientProcessingStarted: new Date()};\n    let result = Promise.race([\n      new Promise((resolve, reject) => socketInstance.requestResolves[requestId] = \n        {resolve, reject, type: request.type}),\n      new Promise((resolve, reject) => setTimeout(() => {\n        reject(new TimeoutError(`MetaApi websocket client request ${request.requestId} of type ${request.type} ` +\n          'timed out. Please make sure your account is connected to broker before retrying your request.'));\n        delete socketInstance.requestResolves[requestId];\n      }, (timeoutInSeconds * 1000) || this._requestTimeout))\n    ]);\n    request.accountId = accountId;\n    request.application = request.application || this._application;\n    if (!request.requestId) {\n      request.requestId = requestId;\n    }\n    if (request.type === 'unsubscribe' || request.application === 'RPC' ||\n      request.instanceIndex === socketInstance.instanceNumber) {\n      this._logger.debug(() => `${accountId}: Sending request: ${JSON.stringify(request)}`);\n      socketInstance.socket.emit('request', request);\n      return result;\n    } else {\n      this._logger.trace(() => `${accountId}:${request.instanceIndex}: skipping request because it is being sent to ` +\n        `the socket of the wrong instance index, request=${JSON.stringify(request)}`);\n      return result;\n    }\n  }\n\n  // eslint-disable-next-line complexity\n  _convertError(data) {\n    if (data.error === 'ValidationError') {\n      return new ValidationError(data.message, data.details);\n    } else if (data.error === 'NotFoundError') {\n      return new NotFoundError(data.message);\n    } else if (data.error === 'NotSynchronizedError') {\n      return new NotSynchronizedError(data.message);\n    } else if (data.error === 'TimeoutError') {\n      return new TimeoutError(data.message);\n    } else if (data.error === 'NotAuthenticatedError') {\n      return new NotConnectedError(data.message);\n    } else if (data.error === 'ForbiddenError') {\n      return new ForbiddenError(data.message);\n    } else if (data.error === 'TradeError') {\n      return new TradeError(data.message, data.numericCode, data.stringCode);\n    } else if (data.error === 'UnauthorizedError') {\n      this.close();\n      return new UnauthorizedError(data.message);\n    } else if (data.error === 'TooManyRequestsError') {\n      return new TooManyRequestsError(data.message, data.metadata);\n    } else {\n      return new InternalError(data.message);\n    }\n  }\n\n  // eslint-disable-next-line complexity\n  _convertIsoTimeToDate(packet) {\n    // eslint-disable-next-line guard-for-in\n    for (let field in packet) {\n      let value = packet[field];\n      if (typeof value === 'string' && field.match(/time$|Time$/) && \n        !field.match(/brokerTime$|BrokerTime$|timeframe$/)) {\n        packet[field] = new Date(value);\n      }\n      if (Array.isArray(value)) {\n        for (let item of value) {\n          this._convertIsoTimeToDate(item);\n        }\n      }\n      if (typeof value === 'object') {\n        this._convertIsoTimeToDate(value);\n      }\n    }\n    if (packet && packet.timestamps) {\n      // eslint-disable-next-line guard-for-in\n      for (let field in packet.timestamps) {\n        packet.timestamps[field] = new Date(packet.timestamps[field]);\n      }\n    }\n    if (packet && packet.type === 'prices') {\n      for (let price of packet.prices || []) {\n        if (price.timestamps) {\n          // eslint-disable-next-line guard-for-in\n          for (let field in price.timestamps) {\n            price.timestamps[field] = new Date(price.timestamps[field]);\n          }\n        }\n      }\n    }\n  }\n\n  /**\n   * MetaTrader symbol price. Contains current price for a symbol (see\n   * https://metaapi.cloud/docs/client/models/metatraderSymbolPrice/)\n   * @typedef {Object} MetatraderSymbolPrice\n   * @property {String} symbol symbol (e.g. a currency pair or an index)\n   * @property {Number} bid bid price\n   * @property {Number} ask ask price\n   * @property {Number} profitTickValue tick value for a profitable position\n   * @property {Number} lossTickValue tick value for a losing position\n   * @property {Number} [accountCurrencyExchangeRate] current exchange rate of account currency into account base\n   * currency (USD if you did not override it)\n   * @property {Date} time quote time, in ISO format\n   * @property {String} brokerTime time quote time, in broker timezone, YYYY-MM-DD HH:mm:ss.SSS format\n   */\n\n  /**\n   * MetaTrader candle\n   * @typedef {Object} MetatraderCandle\n   * @property {string} symbol symbol (e.g. currency pair or an index)\n   * @property {string} timeframe timeframe candle was generated for, e.g. 1h. One of 1m, 2m, 3m, 4m, 5m, 6m, 10m, 12m,\n   * 15m, 20m, 30m, 1h, 2h, 3h, 4h, 6h, 8h, 12h, 1d, 1w, 1mn\n   * @property {Date} time candle opening time\n   * @property {string} brokerTime candle opening time, in broker timezone, YYYY-MM-DD HH:mm:ss.SSS format\n   * @property {number} open open price\n   * @property {number} high high price\n   * @property {number} low low price\n   * @property {number} close close price\n   * @property {number} tickVolume tick volume, i.e. number of ticks inside the candle\n   * @property {number} spread spread in points\n   * @property {number} volume trade volume\n   */\n\n  /**\n   * MetaTrader tick data\n   * @typedef {Object} MetatraderTick\n   * @property {string} symbol symbol (e.g. a currency pair or an index)\n   * @property {Date} time time\n   * @property {string} brokerTime time, in broker timezone, YYYY-MM-DD HH:mm:ss.SSS format\n   * @property {number} [bid] bid price\n   * @property {number} [ask] ask price\n   * @property {number} [last] last deal price\n   * @property {number} [volume] volume for the current last deal price\n   * @property {string} side is tick a result of buy or sell deal, one of buy or sell\n   */\n\n  /**\n   * MetaTrader order book\n   * @typedef {Object} MetatraderBook\n   * @property {string} symbol symbol (e.g. a currency pair or an index)\n   * @property {Date} time time\n   * @property {string} brokerTime time, in broker timezone, YYYY-MM-DD HH:mm:ss.SSS format\n   * @property {Array<MetatraderBookEntry>} book list of order book entries\n   */\n\n  /**\n   * MetaTrader order book entry\n   * @typedef {Object} MetatraderBookEntry\n   * @property {string} type entry type, one of BOOK_TYPE_SELL, BOOK_TYPE_BUY, BOOK_TYPE_SELL_MARKET,\n   * BOOK_TYPE_BUY_MARKET\n   * @property {number} price price\n   * @property {number} volume volume\n   */\n\n  // eslint-disable-next-line complexity,max-statements\n  private async _processSynchronizationPacket(socket: MetaApiWebsocketClient.SocketInstance, data) {\n    try {\n      const instanceNumber = data.instanceIndex || 0;\n      const socketInstance = this._getSocketInstanceByAccount(data.accountId, instanceNumber);\n      if (data.synchronizationId && socketInstance) {\n        socketInstance.synchronizationThrottler.updateSynchronizationId(data.synchronizationId);\n      }\n      const region = this.getAccountRegion(data.accountId);\n      const primaryAccountId = this._accountsByReplicaId[data.accountId];\n      let instanceId = primaryAccountId + ':' + region + ':' + instanceNumber + ':' + (data.host || 0);\n      let instanceIndex = region + ':' + instanceNumber + ':' + (data.host || 0);\n      let sourceLabel = _.compact([instanceIndex, socket.clientApiHostname]).join(':');\n\n      const isOnlyActiveInstance = () => {\n        const activeInstanceIds = Object.keys(this._connectedHosts).filter(instance => \n          instance.startsWith(primaryAccountId + ':' + region + ':' + instanceNumber));\n        return !activeInstanceIds.length || activeInstanceIds.length === 1 && activeInstanceIds[0] === instanceId;\n      };\n\n      const cancelDisconnectTimer = () => {\n        if (this._statusTimers[instanceId]) {\n          clearTimeout(this._statusTimers[instanceId]);\n        }\n      };\n\n      const resetDisconnectTimer = () => {\n        cancelDisconnectTimer();\n        this._statusTimers[instanceId] = setTimeout(() => {\n          this._logger.warn(`${data.accountId}:${sourceLabel}: timed out waiting for connection status`);\n          if (isOnlyActiveInstance()) {\n            this._subscriptionManager.onTimeout(data.accountId, 0);\n            this._subscriptionManager.onTimeout(data.accountId, 1);\n          }\n          this.queueEvent(primaryAccountId, `${instanceIndex}:onDisconnected`, () => onDisconnected(true));\n          clearTimeout(this._statusTimers[instanceId]);\n        }, 60000);\n      };\n\n      // eslint-disable-next-line complexity\n      const onDisconnected = async (isTimeout = false) => { \n        if (this._connectedHosts[instanceId]) {\n          this._latencyService.onDisconnected(instanceId);\n          if (isOnlyActiveInstance()) {\n            for (let listener of this._synchronizationListeners[primaryAccountId] || []) {\n              await this._processEvent(\n                () => listener.onDisconnected(instanceIndex),\n                `${primaryAccountId}:${sourceLabel}:onDisconnected`);\n            }\n          }\n          this._packetOrderer.onStreamClosed(instanceId);\n          socketInstance?.synchronizationThrottler.removeIdByParameters(data.accountId, instanceNumber, data.host);\n          for (let listener of this._synchronizationListeners[primaryAccountId] || []) {\n            await this._processEvent(\n              () => listener.onStreamClosed(instanceIndex),\n              `${primaryAccountId}:${sourceLabel}:onStreamClosed`);\n          }\n          delete this._connectedHosts[instanceId];\n          if (isOnlyActiveInstance() && !isTimeout) {\n            await this._subscriptionManager.onDisconnected(data.accountId, 0);\n            await this._subscriptionManager.onDisconnected(data.accountId, 1);\n          }\n        }\n      };\n      if (data.type === 'authenticated') {\n        resetDisconnectTimer();\n        if (!data.sessionId || socketInstance && data.sessionId === socketInstance.sessionId) {\n          this._latencyService.onConnected(instanceId);\n          this._connectedHosts[instanceId] = data.host;\n          for (let listener of this._synchronizationListeners[primaryAccountId] || []) {\n            await this._processEvent(\n              () => listener.onConnected(instanceIndex, data.replicas),\n              `${primaryAccountId}:${sourceLabel}:onConnected`);\n          }\n          this._subscriptionManager.cancelSubscribe(data.accountId + ':' + instanceNumber);\n          if (data.replicas === 1) {\n            this._subscriptionManager.cancelAccount(data.accountId);\n          } else {\n            this._subscriptionManager.cancelSubscribe(data.accountId + ':' + instanceNumber);\n          }\n        }\n      } else if (data.type === 'disconnected') {\n        cancelDisconnectTimer();\n        await onDisconnected();\n      } else if (data.type === 'synchronizationStarted') {\n        this._updateEvents[instanceId] = [];\n        this._synchronizationFlags[data.synchronizationId] = {\n          accountId: data.accountId, instanceNumber,\n          specificationsUpdated: data.specificationsHashIndex === undefined,\n          positionsUpdated: data.positionsHashIndex === undefined,\n          ordersUpdated: data.ordersHashIndex === undefined\n        };\n        this._synchronizationIdByInstance[instanceId] = data.synchronizationId;\n        const specificationsHash = (data.specificationsHashIndex !== undefined) ? \n          this._synchronizationHashes[data.synchronizationId] && \n          this._synchronizationHashes[data.synchronizationId]\n            .specificationsHashes[data.specificationsHashIndex] : undefined;\n        const positionsHash = (data.positionsHashIndex !== undefined) ? \n          this._synchronizationHashes[data.synchronizationId] && \n          this._synchronizationHashes[data.synchronizationId].positionsHashes[data.positionsHashIndex] : undefined;\n        const ordersHash = (data.ordersHashIndex !== undefined) ? \n          this._synchronizationHashes[data.synchronizationId] && \n          this._synchronizationHashes[data.synchronizationId].ordersHashes[data.ordersHashIndex] : undefined;\n        delete this._synchronizationHashes[data.synchronizationId];\n        for (let listener of this._synchronizationListeners[primaryAccountId] || []) {\n          await this._processEvent(\n            () => listener.onSynchronizationStarted(instanceIndex, specificationsHash,\n              positionsHash, ordersHash, data.synchronizationId),\n            `${primaryAccountId}:${sourceLabel}:onSynchronizationStarted`);\n        }\n      } else if (data.type === 'accountInformation') {\n        if (data.synchronizationId && data.synchronizationId !== this._synchronizationIdByInstance[instanceId]) {\n          return;\n        }\n        if (data.accountInformation) {\n          for (let listener of this._synchronizationListeners[primaryAccountId] || []) {\n            try {\n              await this._processEvent(\n                () => listener.onAccountInformationUpdated(instanceIndex, data.accountInformation),\n                `${primaryAccountId}:${sourceLabel}:onAccountInformationUpdated`, true);\n              // eslint-disable-next-line max-depth\n              if (this._synchronizationFlags[data.synchronizationId] &&\n                !this._synchronizationFlags[data.synchronizationId].positionsUpdated) {\n                await this._processEvent(\n                  () => listener.onPositionsSynchronized(instanceIndex, data.synchronizationId),\n                  `${primaryAccountId}:${sourceLabel}:onPositionsSynchronized`, true);\n                // eslint-disable-next-line max-depth\n                if (!this._synchronizationFlags[data.synchronizationId].ordersUpdated) {\n                  await this._processEvent(\n                    () => listener.onPendingOrdersSynchronized(instanceIndex, data.synchronizationId),\n                    `${primaryAccountId}:${sourceLabel}:onPendingOrdersSynchronized`, true);\n                }\n              }\n            } catch (err) {\n              this._logger.error(`${primaryAccountId}:${sourceLabel}: Failed to notify listener ` +\n                'about accountInformation event', err);\n            }\n          }\n          if (this._synchronizationFlags[data.synchronizationId] && \n              !this._synchronizationFlags[data.synchronizationId].positionsUpdated && \n              !this._synchronizationFlags[data.synchronizationId].ordersUpdated) {\n            delete this._synchronizationFlags[data.synchronizationId];\n          }\n        }\n      } else if (data.type === 'deals') {\n        if (data.synchronizationId && data.synchronizationId !== this._synchronizationIdByInstance[instanceId]) {\n          return;\n        }\n        for (let deal of (data.deals || [])) {\n          for (let listener of this._synchronizationListeners[primaryAccountId] || []) {\n            await this._processEvent(\n              () => listener.onDealAdded(instanceIndex, deal),\n              `${primaryAccountId}:${sourceLabel}:onDealAdded`);\n          }\n        }\n      } else if (data.type === 'orders') {\n        if (data.synchronizationId && data.synchronizationId !== this._synchronizationIdByInstance[instanceId]) {\n          return;\n        }\n        for (let listener of this._synchronizationListeners[primaryAccountId] || []) {\n          try {\n            await this._processEvent(\n              () => listener.onPendingOrdersReplaced(instanceIndex, data.orders || []),\n              `${primaryAccountId}:${sourceLabel}:onPendingOrdersReplaced`, true);\n            await this._processEvent(\n              () => listener.onPendingOrdersSynchronized(instanceIndex, data.synchronizationId),\n              `${primaryAccountId}:${sourceLabel}:onPendingOrdersSynchronized`, true);\n          } catch (err) {\n            this._logger.error(`${primaryAccountId}:${sourceLabel}: Failed to notify listener ` +\n              'about orders event', err);\n          }\n        }\n        if (this._synchronizationFlags[data.synchronizationId]) {\n          delete this._synchronizationFlags[data.synchronizationId];\n        }\n      } else if (data.type === 'historyOrders') {\n        if (data.synchronizationId && data.synchronizationId !== this._synchronizationIdByInstance[instanceId]) {\n          return;\n        }\n        for (let historyOrder of (data.historyOrders || [])) {\n          for (let listener of this._synchronizationListeners[primaryAccountId] || []) {\n            await this._processEvent(\n              () => listener.onHistoryOrderAdded(instanceIndex, historyOrder),\n              `${primaryAccountId}:${sourceLabel}:onHistoryOrderAdded`);\n          }\n        }\n      } else if (data.type === 'positions') {\n        if (data.synchronizationId && data.synchronizationId !== this._synchronizationIdByInstance[instanceId]) {\n          return;\n        }\n        for (let listener of this._synchronizationListeners[primaryAccountId] || []) {\n          try {\n            await this._processEvent(\n              () => listener.onPositionsReplaced(instanceIndex, data.positions || []),\n              `${primaryAccountId}:${sourceLabel}:onPositionsReplaced`, true);\n            await this._processEvent(\n              () => listener.onPositionsSynchronized(instanceIndex, data.synchronizationId),\n              `${primaryAccountId}:${sourceLabel}:onPositionsSynchronized`, true);\n            if (this._synchronizationFlags[data.synchronizationId] &&\n              !this._synchronizationFlags[data.synchronizationId].ordersUpdated) {\n              await this._processEvent(\n                () => listener.onPendingOrdersSynchronized(instanceIndex, data.synchronizationId),\n                `${primaryAccountId}:${sourceLabel}:onPendingOrdersSynchronized`, true);\n            }\n          } catch (err) {\n            this._logger.error(`${primaryAccountId}:${sourceLabel}: Failed to notify listener ` +\n              'about positions event', err);\n          }\n        }\n        if (this._synchronizationFlags[data.synchronizationId] && \n          !this._synchronizationFlags[data.synchronizationId].ordersUpdated) {\n          delete this._synchronizationFlags[data.synchronizationId];\n        }\n      } else if (data.type === 'update') {\n        this._updateEvents[instanceId]?.push({socket, data});\n        if (data.accountInformation) {\n          for (let listener of this._synchronizationListeners[primaryAccountId] || []) {\n            await this._processEvent(\n              () => listener.onAccountInformationUpdated(instanceIndex, data.accountInformation),\n              `${primaryAccountId}:${sourceLabel}:onAccountInformationUpdated`);\n          }\n        }\n        const updatedPositions = data.updatedPositions || [];\n        const removedPositionIds = data.removedPositionIds || [];\n        if (updatedPositions.length || removedPositionIds.length) {\n          for (let listener of this._synchronizationListeners[primaryAccountId] || []) {\n            await this._processEvent(\n              () => listener.onPositionsUpdated(instanceIndex, updatedPositions, removedPositionIds),\n              `${primaryAccountId}:${sourceLabel}:onPositionsUpdated`);\n          }\n        }\n        for (let position of updatedPositions) {\n          for (let listener of this._synchronizationListeners[primaryAccountId] || []) {\n            await this._processEvent(\n              () => listener.onPositionUpdated(instanceIndex, position),\n              `${primaryAccountId}:${sourceLabel}:onPositionUpdated`);\n          }\n        }\n        for (let positionId of removedPositionIds) {\n          for (let listener of this._synchronizationListeners[primaryAccountId] || []) {\n            await this._processEvent(\n              () => listener.onPositionRemoved(instanceIndex, positionId),\n              `${primaryAccountId}:${sourceLabel}:onPositionRemoved`);\n          }\n        }\n        const updatedOrders = data.updatedOrders || [];\n        const completedOrderIds = data.completedOrderIds || [];\n        if (updatedOrders.length || completedOrderIds.length) {\n          for (let listener of this._synchronizationListeners[primaryAccountId] || []) {\n            await this._processEvent(\n              () => listener.onPendingOrdersUpdated(instanceIndex, updatedOrders, completedOrderIds),\n              `${primaryAccountId}:${sourceLabel}:onPendingOrdersUpdated`);\n          }\n        }\n        for (let order of updatedOrders) {\n          for (let listener of this._synchronizationListeners[primaryAccountId] || []) {\n            await this._processEvent(\n              () => listener.onPendingOrderUpdated(instanceIndex, order),\n              `${primaryAccountId}:${sourceLabel}:onPendingOrderUpdated`);\n          }\n        }\n        for (let orderId of completedOrderIds) {\n          for (let listener of this._synchronizationListeners[primaryAccountId] || []) {\n            await this._processEvent(\n              () => listener.onPendingOrderCompleted(instanceIndex, orderId),\n              `${primaryAccountId}:${sourceLabel}:onPendingOrderCompleted`);\n          }\n        }\n        for (let historyOrder of (data.historyOrders || [])) {\n          for (let listener of this._synchronizationListeners[primaryAccountId] || []) {\n            await this._processEvent(\n              () => listener.onHistoryOrderAdded(instanceIndex, historyOrder),\n              `${primaryAccountId}:${sourceLabel}:onHistoryOrderAdded`);\n          }\n        }\n        for (let deal of (data.deals || [])) {\n          for (let listener of this._synchronizationListeners[primaryAccountId] || []) {\n            await this._processEvent(\n              () => listener.onDealAdded(instanceIndex, deal),\n              `${primaryAccountId}:${sourceLabel}:onDealAdded`);\n          }\n        }\n        if (data.timestamps) {\n          data.timestamps.clientProcessingFinished = new Date();\n          // eslint-disable-next-line max-depth\n          for (let listener of this._latencyListeners || []) {\n            await this._processEvent(\n              () => listener.onUpdate(data.accountId, data.timestamps),\n              `${primaryAccountId}:${sourceLabel}:onUpdate`);\n          }\n        }\n      } else if (data.type === 'dealSynchronizationFinished') {\n        if (data.synchronizationId && data.synchronizationId !== this._synchronizationIdByInstance[instanceId]) {\n          delete this._synchronizationIdByInstance[instanceId];\n          return;\n        }\n        this._latencyService.onDealsSynchronized(instanceId);\n        for (let listener of this._synchronizationListeners[primaryAccountId] || []) {\n          socketInstance?.synchronizationThrottler.removeSynchronizationId(data.synchronizationId);\n          await this._processEvent(\n            () => listener.onDealsSynchronized(instanceIndex, data.synchronizationId),\n            `${primaryAccountId}:${sourceLabel}:onDealsSynchronized`);\n        }\n        if (this._updateEvents[instanceId]) {\n          let eventCalls = this._updateEvents[instanceId].map(event => (\n            () => this._processSynchronizationPacket(event.socket, event.data)\n          ));\n          if (this._eventQueues[primaryAccountId]) {\n            this._eventQueues[primaryAccountId] = eventCalls.concat(this._eventQueues[primaryAccountId]);\n            delete this._updateEvents[instanceId];\n          } else {\n            this._eventQueues[primaryAccountId] = eventCalls;\n            delete this._updateEvents[instanceId];\n            this._callAccountEvents(primaryAccountId);\n          }\n        }\n      } else if (data.type === 'orderSynchronizationFinished') {\n        if (data.synchronizationId && data.synchronizationId !== this._synchronizationIdByInstance[instanceId]) {\n          return;\n        }\n        for (let listener of this._synchronizationListeners[primaryAccountId] || []) {\n          await this._processEvent(\n            () => listener.onHistoryOrdersSynchronized(instanceIndex, data.synchronizationId),\n            `${primaryAccountId}:${sourceLabel}:onHistoryOrdersSynchronized`);\n        }\n      } else if (data.type === 'status') {\n        if (!this._connectedHosts[instanceId]) {\n          if (this._statusTimers[instanceId] && data.authenticated && \n              (this._subscriptionManager.isDisconnectedRetryMode(data.accountId, instanceNumber) || \n              !this._subscriptionManager.isAccountSubscribing(data.accountId, instanceNumber))) {\n            this._subscriptionManager.cancelSubscribe(data.accountId + ':' + instanceNumber);\n            await new Promise(res => setTimeout(res, 10));\n            // eslint-disable-next-line no-console\n            this._logger.info(\n              'it seems like we are not connected to a running API server yet, retrying subscription for account' +\n              _.compact([instanceId, socket.clientApiHostname]).join(':')\n            );\n            this.ensureSubscribe(data.accountId, instanceNumber);\n          }\n        } else {\n          resetDisconnectTimer();\n          for (let listener of this._synchronizationListeners[primaryAccountId] || []) {\n            await this._processEvent(\n              () => listener.onBrokerConnectionStatusChanged(instanceIndex, !!data.connected),\n              `${primaryAccountId}:${sourceLabel}:onBrokerConnectionStatusChanged`);\n          }\n          if (data.healthStatus) {\n            // eslint-disable-next-line max-depth\n            for (let listener of this._synchronizationListeners[primaryAccountId] || []) {\n              await this._processEvent(\n                () => listener.onHealthStatus(instanceIndex, data.healthStatus),\n                `${primaryAccountId}:${sourceLabel}:onHealthStatus`);\n            }\n          }\n        }\n      } else if (data.type === 'downgradeSubscription') {\n        this._logger.info(`${primaryAccountId}:${sourceLabel}: Market data subscriptions for symbol ` +\n          `${data.symbol} were downgraded by the server due to rate limits. Updated subscriptions: ` +\n          `${JSON.stringify(data.updates)}, removed subscriptions: ${JSON.stringify(data.unsubscriptions)}. ` +\n          'Please read https://metaapi.cloud/docs/client/rateLimiting/ for more details.');\n        for (let listener of this._synchronizationListeners[primaryAccountId] || []) {\n          await this._processEvent(\n            () => listener.onSubscriptionDowngraded(instanceIndex, data.symbol, data.updates, data.unsubscriptions),\n            `${primaryAccountId}:${sourceLabel}:onSubscriptionDowngraded`);\n        }\n      } else if (data.type === 'specifications') {\n        if (data.synchronizationId && data.synchronizationId !== this._synchronizationIdByInstance[instanceId]) {\n          return;\n        }\n        for (let listener of this._synchronizationListeners[primaryAccountId] || []) {\n          await this._processEvent(\n            () => listener.onSymbolSpecificationsUpdated(instanceIndex, data.specifications || [],\n              data.removedSymbols || []), `${primaryAccountId}:${sourceLabel}:onSymbolSpecificationsUpdated`);\n        }\n        for (let specification of (data.specifications || [])) {\n          for (let listener of this._synchronizationListeners[primaryAccountId] || []) {\n            await this._processEvent(\n              () => listener.onSymbolSpecificationUpdated(instanceIndex, specification),\n              `${primaryAccountId}:${sourceLabel}:onSymbolSpecificationUpdated`);\n          }\n        }\n        for (let removedSymbol of (data.removedSymbols || [])) {\n          for (let listener of this._synchronizationListeners[primaryAccountId] || []) {\n            await this._processEvent(\n              () => listener.onSymbolSpecificationRemoved(instanceIndex, removedSymbol),\n              `${primaryAccountId}:${sourceLabel}:onSymbolSpecificationRemoved`);\n          }\n        }\n      } else if (data.type === 'prices') {\n        if (data.synchronizationId && data.synchronizationId !== this._synchronizationIdByInstance[instanceId]) {\n          return;\n        }\n        let prices = data.prices || [];\n        let candles = data.candles || [];\n        let ticks = data.ticks || [];\n        let books = data.books || [];\n        for (let listener of this._synchronizationListeners[primaryAccountId] || []) {\n          if (prices.length) {\n            await this._processEvent(\n              () => listener.onSymbolPricesUpdated(instanceIndex, prices, data.equity, data.margin, data.freeMargin,\n                data.marginLevel, data.accountCurrencyExchangeRate),\n              `${primaryAccountId}:${sourceLabel}:onSymbolPricesUpdated`);\n          }\n          if (candles.length) {\n            await this._processEvent(\n              () => listener.onCandlesUpdated(instanceIndex, candles, data.equity, data.margin, data.freeMargin,\n                data.marginLevel, data.accountCurrencyExchangeRate),\n              `${primaryAccountId}:${sourceLabel}:onCandlesUpdated`);\n          }\n          if (ticks.length) {\n            await this._processEvent(\n              () => listener.onTicksUpdated(instanceIndex, ticks, data.equity, data.margin, data.freeMargin,\n                data.marginLevel, data.accountCurrencyExchangeRate),\n              `${primaryAccountId}:${sourceLabel}:onTicksUpdated`);\n          }\n          if (books.length) {\n            await this._processEvent(\n              () => listener.onBooksUpdated(instanceIndex, books, data.equity, data.margin, data.freeMargin,\n                data.marginLevel, data.accountCurrencyExchangeRate),\n              `${primaryAccountId}:${sourceLabel}:onBooksUpdated`);\n          }\n        }\n        for (let price of prices) {\n          for (let listener of this._synchronizationListeners[primaryAccountId] || []) {\n            await this._processEvent(\n              () => listener.onSymbolPriceUpdated(instanceIndex, price),\n              `${primaryAccountId}:${sourceLabel}:onSymbolPriceUpdated`);\n          }\n        }\n        for (let price of prices) {\n          if (price.timestamps) {\n            price.timestamps.clientProcessingFinished = new Date();\n            // eslint-disable-next-line max-depth\n            for (let listener of this._latencyListeners || []) {\n              await this._processEvent(\n                () => listener.onSymbolPrice(data.accountId, price.symbol, price.timestamps),\n                `${primaryAccountId}:${sourceLabel}:onSymbolPrice`);\n            }\n          }\n        }\n      }\n    } catch (err) {\n      this._logger.error('Failed to process incoming synchronization packet', err);\n    }\n  }\n\n  async _processEvent(callable, label, throwError?) {\n    const startTime = Date.now();\n    let isLongEvent = false;\n    let isEventDone = false;\n\n    const checkLongEvent = async () => {\n      await new Promise(res => setTimeout(res, 1000));\n      if (!isEventDone) {\n        isLongEvent = true;\n        this._logger.warn(`${label}: event is taking more than 1 second to process`);\n      }\n    };\n\n    checkLongEvent();\n    try {\n      await callable();\n    } catch (err) {\n      if (throwError) {\n        throw err;\n      }\n      this._logger.error(`${label}: event failed with error`, err);\n    }\n    isEventDone = true;\n    if (isLongEvent) {\n      this._logger.warn(`${label}: finished in ${Math.floor((Date.now() - startTime) / 1000)} seconds`);\n    }\n  }\n\n  async _fireReconnected(instanceNumber, socketInstanceIndex, region) {\n    try {\n      const reconnectListeners = [];\n      for (let listener of this._reconnectListeners) {\n        if (this._socketInstancesByAccounts[instanceNumber][listener.accountId] === socketInstanceIndex && \n          this.getAccountRegion(listener.accountId) === region) {\n          reconnectListeners.push(listener);\n        }\n      }\n      Object.keys(this._synchronizationFlags).forEach(synchronizationId => {\n        const accountId = this._synchronizationFlags[synchronizationId].accountId;\n        if (this._socketInstancesByAccounts[instanceNumber][accountId] === socketInstanceIndex\n            && this._synchronizationFlags[synchronizationId].instanceNumber === instanceNumber\n            && this._regionsByAccounts[accountId]\n            && this._regionsByAccounts[accountId].region === region) {\n          delete this._synchronizationFlags[synchronizationId];\n        }\n      });\n      const reconnectAccountIds = reconnectListeners.map(listener => listener.accountId);\n      this._subscriptionManager.onReconnected(instanceNumber, socketInstanceIndex, reconnectAccountIds);\n      this._packetOrderer.onReconnected(reconnectAccountIds);\n\n      for (let listener of reconnectListeners) {\n        Promise.resolve(listener.listener.onReconnected(region, instanceNumber))\n          .catch(err => this._logger.error('Failed to notify reconnect listener', err));\n      }\n    } catch (err) {\n      this._logger.error('Failed to process reconnected event', err);\n    }\n  }\n\n  _getSocketInstanceByAccount(accountId, instanceNumber) {\n    const region = this.getAccountRegion(accountId);\n    return this._socketInstances[region][instanceNumber][this._socketInstancesByAccounts[instanceNumber][accountId]];\n  }\n\n  async getUrlSettings(instanceNumber, region) {\n    if (this._url) {\n      return {url: this._url, isSharedClientApi: true};\n    }\n\n    const urlSettings = await this._domainClient.getSettings();\n    const getUrl = (hostname) => \n      `https://${hostname}.${region}-${String.fromCharCode(97 + Number(instanceNumber))}.${urlSettings.domain}`;\n\n    let url;\n    if (this._useSharedClientApi) {\n      url = getUrl(this._hostname);\n    } else {\n      url = getUrl(urlSettings.hostname);\n    }\n    const isSharedClientApi = url === getUrl(this._hostname);\n    return {url, isSharedClientApi};\n  }\n\n  // eslint-disable-next-line complexity\n  private async _getServerUrl(instanceNumber: number, socketInstanceIndex, region) {\n    if (this._url) {\n      return this._url;\n    }\n\n    while (this.socketInstances[region][instanceNumber][socketInstanceIndex].connected) {\n      try {\n        const urlSettings = await this.getUrlSettings(instanceNumber, region);\n        const url = urlSettings.url;\n        const isSharedClientApi = urlSettings.isSharedClientApi;\n        let logMessage = 'Connecting MetaApi websocket client to the MetaApi server ' +\n      `via ${url} ${isSharedClientApi ? 'shared' : 'dedicated'} server.`;\n        if (this._firstConnect && !isSharedClientApi) {\n          logMessage += ' Please note that it can take up to 3 minutes for your dedicated server to start for the ' +\n        'first time. During this time it is OK if you see some connection errors.';\n          this._firstConnect = false;\n        }\n        this._logger.info(logMessage);\n        return url;\n      } catch (err) {\n        this._logger.error('Failed to retrieve server URL', err);\n        await new Promise(res => setTimeout(res, 1000));\n      }\n    }\n  }\n\n  _throttleRequest(type, accountId, instanceNumber, timeInMs) {\n    this._lastRequestsTime[instanceNumber] = this._lastRequestsTime[instanceNumber] || {};\n    this._lastRequestsTime[instanceNumber][type] = this._lastRequestsTime[instanceNumber][type] || {};\n    let lastTime = this._lastRequestsTime[instanceNumber][type][accountId];\n    if (!lastTime || (lastTime < Date.now() - timeInMs)) {\n      this._lastRequestsTime[instanceNumber][type][accountId] = Date.now();\n      return !!lastTime;\n    }\n    return false;\n  }\n\n  _refreshAccountRegion(accountId) {\n    if (this._regionsByAccounts[accountId]) {\n      this._regionsByAccounts[accountId].lastUsed = Date.now();\n    }\n  }\n\n  //eslint-disable-next-line complexity\n  async _createSocketInstanceByAccount(accountId, instanceNumber) {\n    const region = this.getAccountRegion(accountId);\n    if (this._socketInstancesByAccounts[instanceNumber][accountId] === undefined) {\n      let socketInstanceIndex = null;\n      while (this._subscribeLock && ((new Date(this._subscribeLock.recommendedRetryTime).getTime() > Date.now() && \n          this.subscribedAccountIds(instanceNumber, undefined, region).length < \n          this._subscribeLock.lockedAtAccounts) || \n          (new Date(this._subscribeLock.lockedAtTime).getTime() + this._subscribeCooldownInSeconds * 1000 > \n          Date.now() && this.subscribedAccountIds(instanceNumber, undefined, region).length >= \n          this._subscribeLock.lockedAtAccounts))) {\n        await new Promise(res => setTimeout(res, 1000));\n      }\n      for (let index = 0; index < this._socketInstances[region][instanceNumber].length; index++) {\n        const accountCounter = this._getAssignedAccounts(instanceNumber, index, region).length;\n        const instance = this.socketInstances[region][instanceNumber][index];\n        if (instance.subscribeLock) {\n          if (instance.subscribeLock.type === 'LIMIT_ACCOUNT_SUBSCRIPTIONS_PER_USER_PER_SERVER' && \n            (new Date(instance.subscribeLock.recommendedRetryTime).getTime() > Date.now() || \n            this.subscribedAccountIds(instanceNumber, index, region).length >= \n            instance.subscribeLock.lockedAtAccounts)) {\n            continue;\n          }\n          if (instance.subscribeLock.type === 'LIMIT_ACCOUNT_SUBSCRIPTIONS_PER_SERVER' && \n            new Date(instance.subscribeLock.recommendedRetryTime).getTime() > Date.now() &&\n            this.subscribedAccountIds(instanceNumber, index, region).length >= \n            instance.subscribeLock.lockedAtAccounts) {\n            continue;\n          }\n        }\n        if (accountCounter < this._maxAccountsPerInstance) {\n          socketInstanceIndex = index;\n          break;\n        }\n      }\n      if (socketInstanceIndex === null) {\n        socketInstanceIndex = this._socketInstances[region][instanceNumber].length;\n        await this.connect(instanceNumber, region);\n      }\n      this._socketInstancesByAccounts[instanceNumber][accountId] = socketInstanceIndex;\n    }\n  }  \n\n  private _clearAccountCacheJob() {\n    const date = Date.now();\n    Object.keys(this._regionsByAccounts).forEach(replicaId => {\n      const data = this._regionsByAccounts[replicaId];\n      if (data && data.connections === 0 && date - data.lastUsed > 2 * 60 * 60 * 1000) {\n        const primaryAccountId = this._accountsByReplicaId[replicaId];\n        const replicas = Object.values<any>(this._accountReplicas[primaryAccountId] || {});\n        replicas.forEach(replica => {\n          delete this._accountsByReplicaId[replica];\n          delete this._regionsByAccounts[replica];\n        });\n        delete this._accountReplicas[primaryAccountId];\n        this._logger.debug(`${primaryAccountId}: removed expired account replicas data`);\n      }\n    });\n  }\n\n  _clearInactiveSyncDataJob() {\n    const date = Date.now();\n    Object.keys(this._synchronizationHashes).forEach(synchronizationId => {\n      if (this._synchronizationHashes[synchronizationId].lastUpdated < date - 30 * 60 * 1000) {\n        delete this._synchronizationHashes[synchronizationId];\n      }\n    });\n  }\n}\n\nnamespace MetaApiWebsocketClient {\n\n  /** Account replicas by region (including primary replica) by primary ID */\n  export type AccountReplicas = {[primaryId: string]: MetatraderAccount.AccountsByRegion};\n\n  /**\n   * Account IDs by replica\n   * - keys are replica or primary account IDs\n   * - values are primary account IDs\n   */\n  export type AccountsByReplica = {[replicaId: string]: string};\n\n  /**\n   * Socket instance\n   * @todo describe fields\n   */\n  export type SocketInstance = {\n    id: number;\n    reconnectWaitTime: number;\n    connected: boolean;\n    requestResolves: any;\n    resolved: boolean;\n    connectResult: Promise<any>;\n    sessionId: string;\n    isReconnecting: boolean;\n    socket?: any;\n    /** The final client API hostname the SDK has connected to behind load balancer */\n    clientApiHostname?: string;\n    synchronizationThrottler: SynchronizationThrottler;\n    subscribeLock?: any;\n    instanceNumber: number;\n  };\n}\n\nexport default MetaApiWebsocketClient;\n\n/**\n * Regions by accounts\n * - keys are replica or primary account ID\n */\ntype RegionsByAccounts = {[accountId: string]: {\n  region: string;\n  connections: number;\n  lastUsed: number;\n}};\n\ntype SynchronizationFlag = {\n  accountId: string,\n  instanceNumber: number;\n  specificationsUpdated: boolean;\n  positionsUpdated: boolean;\n  ordersUpdated: boolean;\n};\n\ntype SocketInstances = {[region: string]: {[instanceNumber: number]: MetaApiWebsocketClient.SocketInstance[]}};\n\ntype Packet = {\n  socket: MetaApiWebsocketClient.SocketInstance;\n  data: any;\n};\n\ntype RestoredOrderPacket = PacketOrderer.Packet & {\n  socket: MetaApiWebsocketClient.SocketInstance;\n  packet: any;\n};\n\ntype MetadataPacket = {\n  clientApiHostname: string;\n};\n"],"names":["randomstring","socketIO","TimeoutError","ValidationError","NotFoundError","InternalError","UnauthorizedError","TooManyRequestsError","ForbiddenError","OptionsValidator","NotSynchronizedError","NotConnectedError","TradeError","PacketOrderer","SynchronizationThrottler","SubscriptionManager","LoggerManager","any","LatencyService","_","PacketLogger","window","require","default","MetaApiWebsocketClient","onOutOfOrderPacket","accountId","instanceIndex","expectedSequenceNumber","actualSequenceNumber","packet","receivedAt","primaryAccountId","_accountsByReplicaId","_subscriptionManager","isSubscriptionActive","level","_latencyService","getSynchronizedAccountInstances","length","_logger","type","ensureSubscribe","url","_url","region","_region","socketInstances","_socketInstances","socketInstancesByAccounts","_socketInstancesByAccounts","accountReplicas","_accountReplicas","accountsByReplicaId","clearAccountCacheJob","_clearAccountCacheJob","bind","latencyService","subscribedAccountIds","instanceNumber","socketInstanceIndex","connectedIds","Object","keys","_connectedHosts","forEach","instanceId","split","accountRegion","getAccountRegion","includes","undefined","push","connected","instance","socket","_getAssignedAccounts","accountIds","key","_regionsByAccounts","addAccountCache","replicas","replicaId","connections","lastUsed","Date","now","debug","updateAccountCache","oldReplicas","connectionCount","removeAccountCache","lockSocketInstance","metadata","_subscribeLock","recommendedRetryTime","lockedAtAccounts","lockedAtTime","subscribedAccounts","socketInstance","close","_reconnect","subscribeLock","connect","clientId","Math","random","resolve","result","Promise","res","rej","id","reconnectWaitTime","_socketMinimumReconnectTimeout","requestResolves","resolved","connectResult","sessionId","generate","isReconnecting","synchronizationThrottler","_synchronizationThrottlerOpts","start","serverUrl","_getServerUrl","path","reconnection","reconnectionDelay","reconnectionDelayMax","reconnectionAttempts","Infinity","timeout","_connectTimeout","extraHeaders","query","_token","protocol","on","info","_fireReconnected","err","error","reason","onDisconnect","data","JSON","parse","stringify","requestId","timestamps","requestResolve","reject","_convertIsoTimeToDate","clientProcessingFinished","listener","_latencyListeners","then","onTrade","onResponse","catch","_convertError","trace","sequenceNumber","sequenceTimestamp","synchronizationId","application","host","specificationsUpdated","positionsUpdated","ordersUpdated","specifications","_synchronizationListeners","activeSynchronizationIds","_packetLogger","logPacket","ignoredPacketTypes","_throttleRequest","_unsubscribeThrottlingInterval","unsubscribe","warn","queuePacket","clientApiHostname","values","Error","_packetOrderer","stop","clearInterval","_clearAccountCacheInterval","_clearInactiveSyncDataInterval","getAccountInformation","options","response","rpcRequest","accountInformation","getPositions","positions","getPosition","positionId","position","getOrders","orders","getOrder","orderId","order","getHistoryOrdersByTicket","ticket","historyOrders","synchronizing","getHistoryOrdersByPosition","getHistoryOrdersByTimeRange","startTime","endTime","offset","limit","getDealsByTicket","deals","getDealsByPosition","getDealsByTimeRange","removeApplication","trade","reliability","rpcRequestAllInstances","_application","stringCode","description","numericCode","message","scheduleSubscribe","subscribe","synchronize","startingHistoryOrderTime","startingDealTime","hashes","_getSocketInstanceByAccount","_createSocketInstanceByAccount","syncThrottler","_synchronizationHashes","lastUpdated","scheduleSynchronize","version","waitSynchronized","applicationPattern","timeoutInSeconds","subscribeToMarketData","symbol","subscriptions","refreshMarketDataSubscriptions","unsubscribeFromMarketData","getSymbols","symbols","getSymbolSpecification","specification","getSymbolPrice","keepSubscription","price","getCandle","timeframe","candle","getTick","tick","getBook","book","refreshTerminalState","refreshSymbolQuotes","refreshedQuotes","saveUptime","uptime","onUnsubscribe","_updateEvents","filter","startsWith","all","map","Number","name","getServerTime","serverTime","calculateMargin","margin","unsubscribeAccountRegion","unsubscribePromises","_processEvent","onUnsubscribeRegion","addSynchronizationListener","listeners","removeSynchronizationListener","l","addLatencyListener","removeLatencyListener","addReconnectListener","_reconnectListeners","removeReconnectListener","removeAllListeners","onAccountDeleted","cancelAccount","masterAccountId","regionData","_synchronizationIdByInstance","replica","packets","restoreOrder","p","_sequentialEventProcessing","events","item","_processSynchronizationPacket","_eventQueues","_callAccountEvents","concat","queueEvent","callable","event","shift","_tryReconnect","min","setTimeout","io","opts","uri","request","assign","errors","ignoredRequestTypes","connectedInstance","getActiveAccountInstances","waitConnectedInstance","activeRegion","_refreshAccountRegion","_makeRequest","retryCounter","calcRetryCounter","calcRequestTime","_retries","pow","_minRetryDelayInSeconds","_maxRetryDelayInSeconds","retryTime","getTime","clientProcessingStarted","race","_requestTimeout","emit","details","field","value","match","Array","isArray","prices","updateSynchronizationId","sourceLabel","compact","join","isOnlyActiveInstance","activeInstanceIds","cancelDisconnectTimer","_statusTimers","clearTimeout","resetDisconnectTimer","onTimeout","onDisconnected","isTimeout","onStreamClosed","removeIdByParameters","onConnected","cancelSubscribe","_synchronizationFlags","specificationsHashIndex","positionsHashIndex","ordersHashIndex","specificationsHash","specificationsHashes","positionsHash","positionsHashes","ordersHash","ordersHashes","onSynchronizationStarted","onAccountInformationUpdated","onPositionsSynchronized","onPendingOrdersSynchronized","deal","onDealAdded","onPendingOrdersReplaced","historyOrder","onHistoryOrderAdded","onPositionsReplaced","updatedPositions","removedPositionIds","onPositionsUpdated","onPositionUpdated","onPositionRemoved","updatedOrders","completedOrderIds","onPendingOrdersUpdated","onPendingOrderUpdated","onPendingOrderCompleted","onUpdate","onDealsSynchronized","removeSynchronizationId","eventCalls","onHistoryOrdersSynchronized","authenticated","isDisconnectedRetryMode","isAccountSubscribing","onBrokerConnectionStatusChanged","healthStatus","onHealthStatus","updates","unsubscriptions","onSubscriptionDowngraded","onSymbolSpecificationsUpdated","removedSymbols","onSymbolSpecificationUpdated","removedSymbol","onSymbolSpecificationRemoved","candles","ticks","books","onSymbolPricesUpdated","equity","freeMargin","marginLevel","accountCurrencyExchangeRate","onCandlesUpdated","onTicksUpdated","onBooksUpdated","onSymbolPriceUpdated","onSymbolPrice","label","throwError","isLongEvent","isEventDone","checkLongEvent","floor","reconnectListeners","reconnectAccountIds","onReconnected","getUrlSettings","isSharedClientApi","urlSettings","_domainClient","getSettings","getUrl","hostname","String","fromCharCode","domain","_useSharedClientApi","_hostname","logMessage","_firstConnect","timeInMs","_lastRequestsTime","lastTime","_subscribeCooldownInSeconds","index","accountCounter","_maxAccountsPerInstance","date","_clearInactiveSyncDataJob","constructor","metaApi","domainClient","token","_domain","_metaApi","validator","packetOrderingTimeout","validateNonZero","requestTimeout","connectTimeout","retryOpts","validateNumber","retries","minDelayInSeconds","maxDelayInSeconds","subscribeCooldownInSeconds","validateBoolean","useSharedClientApi","unsubscribeThrottlingIntervalInSeconds","packetLogger","enabled","getLogger","disableInternalJobs","setInterval"],"mappings":"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"}