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)
360 lines (359 loc) • 48.5 kB
JavaScript
;
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;
}
import LoggerManager from '../../logger';
let SubscriptionManager = class SubscriptionManager {
/**
* Returns whether an account is currently subscribing
* @param {String} accountId account id
* @param {Number} instanceNumber instance index number
* @returns {Boolean} whether an account is currently subscribing
*/ isAccountSubscribing(accountId, instanceNumber) {
if (instanceNumber !== undefined) {
return Object.keys(this._subscriptions).includes(accountId + ':' + instanceNumber);
} else {
for (let key of Object.keys(this._subscriptions)){
if (key.startsWith(accountId)) {
return true;
}
}
return false;
}
}
/**
* Returns whether an instance is in disconnected retry mode
* @param {String} accountId account id
* @param {Number} instanceNumber instance index number
* @returns {Boolean} whether an account is currently subscribing
*/ isDisconnectedRetryMode(accountId, instanceNumber) {
let instanceId = accountId + ':' + (instanceNumber || 0);
return this._subscriptions[instanceId] ? this._subscriptions[instanceId].isDisconnectedRetryMode : false;
}
/**
* Returns whether an account subscription is active
* @param {String} accountId account id
* @returns {Boolean} instance actual subscribe state
*/ isSubscriptionActive(accountId) {
return !!this._subscriptionState[accountId];
}
/**
* 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) {
this._subscriptionState[accountId] = true;
return this._websocketClient.rpcRequest(accountId, {
type: 'subscribe',
instanceIndex: instanceNumber
});
}
/**
* Schedules to send subscribe requests to an account until cancelled
* @param {String} accountId id of the MetaTrader account
* @param {Number} instanceNumber instance index number
* @param {Boolean} isDisconnectedRetryMode whether to start subscription in disconnected retry
* mode. Subscription task in disconnected mode will be immediately replaced when the status packet is received
*/ scheduleSubscribe(accountId, instanceNumber, isDisconnectedRetryMode = false) {
var _this = this;
return _async_to_generator(function*() {
const client = _this._websocketClient;
let instanceId = accountId + ':' + (instanceNumber || 0);
if (!_this._subscriptions[instanceId]) {
_this._subscriptions[instanceId] = {
shouldRetry: true,
task: null,
waitTask: null,
future: null,
isDisconnectedRetryMode
};
let subscribeRetryIntervalInSeconds = 3;
while(_this._subscriptions[instanceId].shouldRetry){
let resolveSubscribe;
_this._subscriptions[instanceId].task = {
promise: new Promise((res)=>{
resolveSubscribe = res;
})
};
_this._subscriptions[instanceId].task.resolve = resolveSubscribe;
// eslint-disable-next-line no-inner-declarations, complexity
let subscribeTask = function() {
var _ref = _async_to_generator(function*() {
try {
_this._logger.debug(`${accountId}:${instanceNumber}: running subscribe task`);
yield _this.subscribe(accountId, instanceNumber);
} catch (err) {
if (err.name === 'TooManyRequestsError') {
const socketInstanceIndex = client.socketInstancesByAccounts[instanceNumber][accountId];
if (err.metadata.type === 'LIMIT_ACCOUNT_SUBSCRIPTIONS_PER_USER') {
_this._logSubscriptionError(accountId, `${instanceId}: Failed to subscribe`, err);
}
if ([
'LIMIT_ACCOUNT_SUBSCRIPTIONS_PER_USER',
'LIMIT_ACCOUNT_SUBSCRIPTIONS_PER_SERVER',
'LIMIT_ACCOUNT_SUBSCRIPTIONS_PER_USER_PER_SERVER'
].includes(err.metadata.type)) {
delete client.socketInstancesByAccounts[instanceNumber][accountId];
client.lockSocketInstance(instanceNumber, socketInstanceIndex, _this._websocketClient.getAccountRegion(accountId), err.metadata);
} else {
const retryTime = new Date(err.metadata.recommendedRetryTime).getTime();
if (Date.now() + subscribeRetryIntervalInSeconds * 1000 < retryTime) {
yield new Promise((res)=>setTimeout(res, retryTime - Date.now() - subscribeRetryIntervalInSeconds * 1000));
}
}
} else {
_this._logSubscriptionError(accountId, `${instanceId}: Failed to subscribe`, err);
if (err.name === 'NotFoundError') {
_this.refreshAccount(accountId);
}
if (err.name === 'TimeoutError') {
const mainAccountId = _this._websocketClient.accountsByReplicaId[accountId];
if (mainAccountId) {
const region = _this._websocketClient.getAccountRegion(accountId);
const connectedInstances = _this._latencyService.getActiveAccountInstances(mainAccountId);
// eslint-disable-next-line max-depth
if (!connectedInstances.some((instance)=>instance.startsWith(`${mainAccountId}:${region}`))) {
_this._timeoutErrorCounter[accountId] = _this._timeoutErrorCounter[accountId] || 0;
_this._timeoutErrorCounter[accountId]++;
// eslint-disable-next-line max-depth
if (_this._timeoutErrorCounter[accountId] > 4) {
_this._timeoutErrorCounter[accountId] = 0;
_this.refreshAccount(accountId);
}
}
}
}
}
}
resolveSubscribe();
});
return function subscribeTask() {
return _ref.apply(this, arguments);
};
}();
subscribeTask();
yield _this._subscriptions[instanceId].task.promise;
if (!_this._subscriptions[instanceId].shouldRetry) {
break;
}
const retryInterval = subscribeRetryIntervalInSeconds;
subscribeRetryIntervalInSeconds = Math.min(subscribeRetryIntervalInSeconds * 2, 300);
let resolve;
let subscribePromise = new Promise((res)=>{
resolve = res;
});
_this._subscriptions[instanceId].waitTask = setTimeout(()=>{
resolve(true);
}, retryInterval * 1000);
_this._subscriptions[instanceId].future = {
resolve,
promise: subscribePromise
};
const result = yield _this._subscriptions[instanceId].future.promise;
_this._subscriptions[instanceId].future = null;
if (!result) {
break;
}
}
delete _this._subscriptions[instanceId];
}
})();
}
/**
* Unsubscribe from account
* @param {String} accountId id of the MetaTrader account to unsubscribe
* @param {Number} instanceNumber instance index number
* @returns {Promise} promise which resolves when socket unsubscribed
*/ unsubscribe(accountId, instanceNumber) {
var _this = this;
return _async_to_generator(function*() {
_this.cancelAccount(accountId);
delete _this._subscriptionState[accountId];
return _this._websocketClient.rpcRequest(accountId, {
type: 'unsubscribe',
instanceIndex: instanceNumber
});
})();
}
/**
* Cancels active subscription tasks for an instance id
* @param {String} instanceId instance id to cancel subscription task for
*/ cancelSubscribe(instanceId) {
if (this._subscriptions[instanceId]) {
const subscription = this._subscriptions[instanceId];
if (subscription.future) {
subscription.future.resolve(false);
clearTimeout(subscription.waitTask);
}
if (subscription.task) {
subscription.task.resolve(false);
}
subscription.shouldRetry = false;
}
}
/**
* Cancels active subscription tasks for an account
* @param {String} accountId account id to cancel subscription tasks for
*/ cancelAccount(accountId) {
for (let instanceId of Object.keys(this._subscriptions).filter((key)=>key.startsWith(accountId))){
this.cancelSubscribe(instanceId);
}
Object.keys(this._awaitingResubscribe).forEach((instanceNumber)=>delete this._awaitingResubscribe[instanceNumber][accountId]);
delete this._timeoutErrorCounter[accountId];
}
/**
* Invoked on account timeout.
* @param {String} accountId id of the MetaTrader account
* @param {Number} instanceNumber instance index number
*/ onTimeout(accountId, instanceNumber) {
const region = this._websocketClient.getAccountRegion(accountId);
if (this._websocketClient.socketInstancesByAccounts[instanceNumber][accountId] !== undefined && this._websocketClient.connected(instanceNumber, this._websocketClient.socketInstancesByAccounts[instanceNumber][accountId], region)) {
this._logger.debug(`${accountId}:${instanceNumber}: scheduling subscribe because of account timeout`);
this.scheduleSubscribe(accountId, instanceNumber, true);
}
}
/**
* Invoked when connection to MetaTrader terminal terminated
* @param {String} accountId id of the MetaTrader account
* @param {Number} instanceNumber instance index number
*/ onDisconnected(accountId, instanceNumber) {
var _this = this;
return _async_to_generator(function*() {
yield new Promise((res)=>setTimeout(res, Math.max(Math.random() * 5, 1) * 1000));
if (_this._websocketClient.socketInstancesByAccounts[instanceNumber][accountId] !== undefined) {
_this._logger.debug(`${accountId}:${instanceNumber}: scheduling subscribe because account disconnected`);
_this.scheduleSubscribe(accountId, instanceNumber, true);
}
})();
}
/**
* Invoked when connection to MetaApi websocket API restored after a disconnect.
* @param {Number} instanceNumber instance index number
* @param {Number} socketInstanceIndex socket instance index
* @param {String[]} reconnectAccountIds account ids to reconnect
*/ onReconnected(instanceNumber, socketInstanceIndex, reconnectAccountIds) {
if (!this._awaitingResubscribe[instanceNumber]) {
this._awaitingResubscribe[instanceNumber] = {};
}
const socketInstancesByAccounts = this._websocketClient.socketInstancesByAccounts[instanceNumber];
for (let instanceId of Object.keys(this._subscriptions)){
const accountId = instanceId.split(':')[0];
if (socketInstancesByAccounts[accountId] === socketInstanceIndex) {
this.cancelSubscribe(instanceId);
}
}
var _this = this;
reconnectAccountIds.forEach(function() {
var _ref = _async_to_generator(function*(accountId) {
if (!_this._awaitingResubscribe[instanceNumber][accountId]) {
_this._awaitingResubscribe[instanceNumber][accountId] = true;
while(_this.isAccountSubscribing(accountId, instanceNumber)){
yield new Promise((res)=>setTimeout(res, 1000));
}
yield new Promise((res)=>setTimeout(res, Math.random() * 5000));
if (_this._awaitingResubscribe[instanceNumber][accountId]) {
delete _this._awaitingResubscribe[instanceNumber][accountId];
_this._logger.debug(`${accountId}:${instanceNumber}: scheduling subscribe because account reconnected`);
_this.scheduleSubscribe(accountId, instanceNumber);
}
}
});
return function(accountId) {
return _ref.apply(this, arguments);
};
}());
}
/**
* Schedules a task to refresh the account data
* @param {string} accountId account id
*/ refreshAccount(accountId) {
const mainAccountId = this._websocketClient.accountsByReplicaId[accountId];
if (mainAccountId) {
const registry = this._metaApi._connectionRegistry;
const rpcConnection = registry.rpcConnections[mainAccountId];
const region = this._websocketClient.getAccountRegion(accountId);
if (region) {
if (rpcConnection) {
rpcConnection.scheduleRefresh(region);
}
const streamingConnection = registry.streamingConnections[mainAccountId];
if (streamingConnection) {
streamingConnection.scheduleRefresh(region);
}
}
}
}
_logSubscriptionError(accountId, message, error) {
const primaryAccountId = this._websocketClient.accountsByReplicaId[accountId];
const method = this._latencyService.getSynchronizedAccountInstances(primaryAccountId).length ? 'debug' : 'error';
this._logger[method](message, error);
}
/**
* Constructs the subscription manager
* @param {MetaApiWebsocketClient} websocketClient websocket client to use for sending requests
* @param {MetaApi} metaApi metaApi instance
*/ constructor(websocketClient, metaApi){
_define_property(this, "_websocketClient", void 0);
_define_property(this, "_latencyService", void 0);
_define_property(this, "_metaApi", void 0);
_define_property(this, "_subscriptions", void 0);
_define_property(this, "_awaitingResubscribe", void 0);
_define_property(this, "_subscriptionState", void 0);
_define_property(this, "_logger", void 0);
_define_property(this, "_timeoutErrorCounter", void 0);
_define_property(this, "_recentlyDeletedAccounts", void 0);
this._websocketClient = websocketClient;
this._latencyService = websocketClient.latencyService;
this._metaApi = metaApi;
this._subscriptions = {};
this._awaitingResubscribe = {};
this._subscriptionState = {};
this._logger = LoggerManager.getLogger('SubscriptionManager');
this._timeoutErrorCounter = {};
this._recentlyDeletedAccounts = {};
}
};
/**
* Subscription manager to handle account subscription logic
*/ export { SubscriptionManager as default };
//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["<anon>"],"sourcesContent":["'use strict';\n\nimport LoggerManager from '../../logger';\nimport MetaApiWebsocketClient from './metaApiWebsocket.client';\n\n/**\n * Subscription manager to handle account subscription logic\n */\nexport default class SubscriptionManager {\n  \n  private _websocketClient: MetaApiWebsocketClient;\n  private _latencyService: any;\n  private _metaApi: any;\n  private _subscriptions: {};\n  private _awaitingResubscribe: {};\n  private _subscriptionState: {};\n  private _logger: any;\n  private _timeoutErrorCounter: {};\n  private _recentlyDeletedAccounts: {};\n\n  /**\n   * Constructs the subscription manager\n   * @param {MetaApiWebsocketClient} websocketClient websocket client to use for sending requests\n   * @param {MetaApi} metaApi metaApi instance\n   */\n  constructor(websocketClient, metaApi) {\n    this._websocketClient = websocketClient;\n    this._latencyService = websocketClient.latencyService;\n    this._metaApi = metaApi;\n    this._subscriptions = {};\n    this._awaitingResubscribe = {};\n    this._subscriptionState = {};\n    this._logger = LoggerManager.getLogger('SubscriptionManager');\n    this._timeoutErrorCounter = {};\n    this._recentlyDeletedAccounts = {};\n  }\n\n  /**\n   * Returns whether an account is currently subscribing\n   * @param {String} accountId account id\n   * @param {Number} instanceNumber instance index number\n   * @returns {Boolean} whether an account is currently subscribing\n   */\n  isAccountSubscribing(accountId, instanceNumber) {\n    if (instanceNumber !== undefined) {\n      return Object.keys(this._subscriptions).includes(accountId + ':' + instanceNumber);\n    } else {\n      for (let key of Object.keys(this._subscriptions)) {\n        if (key.startsWith(accountId)) {\n          return true;\n        }\n      }\n      return false;\n    }\n  }\n\n  /**\n   * Returns whether an instance is in disconnected retry mode\n   * @param {String} accountId account id\n   * @param {Number} instanceNumber instance index number\n   * @returns {Boolean} whether an account is currently subscribing\n   */\n  isDisconnectedRetryMode(accountId, instanceNumber) {\n    let instanceId = accountId + ':' + (instanceNumber || 0);\n    return this._subscriptions[instanceId] ? this._subscriptions[instanceId].isDisconnectedRetryMode : false;\n  }\n\n  /**\n   * Returns whether an account subscription is active\n   * @param {String} accountId account id\n   * @returns {Boolean} instance actual subscribe state\n   */\n  isSubscriptionActive(accountId) {\n    return !!this._subscriptionState[accountId];\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    this._subscriptionState[accountId] = true;\n    return this._websocketClient.rpcRequest(accountId, {type: 'subscribe', instanceIndex: instanceNumber});\n  }\n\n  /**\n   * Schedules to send subscribe requests to an account until cancelled\n   * @param {String} accountId id of the MetaTrader account\n   * @param {Number} instanceNumber instance index number\n   * @param {Boolean} isDisconnectedRetryMode whether to start subscription in disconnected retry\n   * mode. Subscription task in disconnected mode will be immediately replaced when the status packet is received\n   */\n  async scheduleSubscribe(accountId, instanceNumber, isDisconnectedRetryMode = false) {\n    const client = this._websocketClient;\n    let instanceId = accountId + ':' + (instanceNumber || 0);\n    if (!this._subscriptions[instanceId]) {\n      this._subscriptions[instanceId] = {\n        shouldRetry: true,\n        task: null,\n        waitTask: null,\n        future: null,\n        isDisconnectedRetryMode\n      };\n      let subscribeRetryIntervalInSeconds = 3;\n      while (this._subscriptions[instanceId].shouldRetry) {\n        let resolveSubscribe;\n        this._subscriptions[instanceId].task = {promise: new Promise((res) => {\n          resolveSubscribe = res;\n        })};\n        this._subscriptions[instanceId].task.resolve = resolveSubscribe;\n        // eslint-disable-next-line no-inner-declarations, complexity\n        let subscribeTask = async () => {\n          try {\n            this._logger.debug(`${accountId}:${instanceNumber}: running subscribe task`);\n            await this.subscribe(accountId, instanceNumber);\n          } catch (err) {\n            if (err.name === 'TooManyRequestsError') {\n              const socketInstanceIndex = client.socketInstancesByAccounts[instanceNumber][accountId];\n              if (err.metadata.type === 'LIMIT_ACCOUNT_SUBSCRIPTIONS_PER_USER') {\n                this._logSubscriptionError(accountId, `${instanceId}: Failed to subscribe`, err);\n              }\n              if (['LIMIT_ACCOUNT_SUBSCRIPTIONS_PER_USER', 'LIMIT_ACCOUNT_SUBSCRIPTIONS_PER_SERVER', \n                'LIMIT_ACCOUNT_SUBSCRIPTIONS_PER_USER_PER_SERVER'].includes(err.metadata.type)) {\n                delete client.socketInstancesByAccounts[instanceNumber][accountId];\n                client.lockSocketInstance(instanceNumber, socketInstanceIndex, \n                  this._websocketClient.getAccountRegion(accountId), err.metadata);\n              } else {\n                const retryTime = new Date(err.metadata.recommendedRetryTime).getTime();\n                if (Date.now() + subscribeRetryIntervalInSeconds * 1000 < retryTime) {\n                  await new Promise(res => setTimeout(res, retryTime - Date.now() -\n                    subscribeRetryIntervalInSeconds * 1000));\n                }\n              }\n            } else {\n              this._logSubscriptionError(accountId, `${instanceId}: Failed to subscribe`, err);\n              if (err.name === 'NotFoundError') {\n                this.refreshAccount(accountId);\n              }\n              if (err.name === 'TimeoutError') {\n                const mainAccountId = this._websocketClient.accountsByReplicaId[accountId];\n                if (mainAccountId) {\n                  const region = this._websocketClient.getAccountRegion(accountId);\n                  const connectedInstances = this._latencyService.getActiveAccountInstances(mainAccountId);\n                  // eslint-disable-next-line max-depth\n                  if (!connectedInstances.some(instance => instance.startsWith(`${mainAccountId}:${region}`))) {\n                    this._timeoutErrorCounter[accountId] = this._timeoutErrorCounter[accountId] || 0;\n                    this._timeoutErrorCounter[accountId]++;\n                    // eslint-disable-next-line max-depth\n                    if (this._timeoutErrorCounter[accountId] > 4) {\n                      this._timeoutErrorCounter[accountId] = 0;\n                      this.refreshAccount(accountId);\n                    }\n                  }\n                }\n              }\n            }\n          }\n          resolveSubscribe();\n        };\n        subscribeTask();\n        await this._subscriptions[instanceId].task.promise;\n        if (!this._subscriptions[instanceId].shouldRetry) {\n          break;\n        }\n        const retryInterval = subscribeRetryIntervalInSeconds;\n        subscribeRetryIntervalInSeconds = Math.min(subscribeRetryIntervalInSeconds * 2, 300);\n        let resolve;\n        let subscribePromise = new Promise((res) => {\n          resolve = res;\n        });\n        this._subscriptions[instanceId].waitTask = setTimeout(() => {\n          resolve(true);\n        }, retryInterval * 1000);\n        this._subscriptions[instanceId].future = {resolve, promise: subscribePromise};\n        const result = await this._subscriptions[instanceId].future.promise;\n        this._subscriptions[instanceId].future = null;\n        if (!result) {\n          break;\n        }\n      }\n      delete this._subscriptions[instanceId];\n    }\n  }\n\n  /**\n   * Unsubscribe from account\n   * @param {String} accountId id of the MetaTrader account to unsubscribe\n   * @param {Number} instanceNumber instance index number\n   * @returns {Promise} promise which resolves when socket unsubscribed\n   */\n  async unsubscribe(accountId, instanceNumber) {\n    this.cancelAccount(accountId);\n    delete this._subscriptionState[accountId];\n    return this._websocketClient.rpcRequest(accountId, {type: 'unsubscribe', instanceIndex: instanceNumber});\n  }\n\n  /**\n   * Cancels active subscription tasks for an instance id\n   * @param {String} instanceId instance id to cancel subscription task for\n   */\n  cancelSubscribe(instanceId) {\n    if (this._subscriptions[instanceId]) {\n      const subscription = this._subscriptions[instanceId];\n      if (subscription.future) {\n        subscription.future.resolve(false);\n        clearTimeout(subscription.waitTask);\n      }\n      if (subscription.task) {\n        subscription.task.resolve(false);\n      }\n      subscription.shouldRetry = false;\n    }\n  }\n\n  /**\n   * Cancels active subscription tasks for an account\n   * @param {String} accountId account id to cancel subscription tasks for\n   */\n  cancelAccount(accountId) {\n    for (let instanceId of Object.keys(this._subscriptions).filter(key => key.startsWith(accountId))) {\n      this.cancelSubscribe(instanceId);\n    }\n    Object.keys(this._awaitingResubscribe).forEach(instanceNumber => \n      delete this._awaitingResubscribe[instanceNumber][accountId]);\n    delete this._timeoutErrorCounter[accountId];\n  }\n\n  /**\n   * Invoked on account timeout.\n   * @param {String} accountId id of the MetaTrader account\n   * @param {Number} instanceNumber instance index number\n   */\n  onTimeout(accountId, instanceNumber) {\n    const region = this._websocketClient.getAccountRegion(accountId);\n    if (\n      this._websocketClient.socketInstancesByAccounts[instanceNumber][accountId] !== undefined && \n      this._websocketClient.connected(\n        instanceNumber, this._websocketClient.socketInstancesByAccounts[instanceNumber][accountId], region\n      )\n    ) {\n      this._logger.debug(`${accountId}:${instanceNumber}: scheduling subscribe because of account timeout`);\n      this.scheduleSubscribe(accountId, instanceNumber, true);\n    }\n  }\n\n  /**\n   * Invoked when connection to MetaTrader terminal terminated\n   * @param {String} accountId id of the MetaTrader account\n   * @param {Number} instanceNumber instance index number\n   */\n  async onDisconnected(accountId, instanceNumber) {\n    await new Promise(res => setTimeout(res, Math.max(Math.random() * 5, 1) * 1000));\n    if (this._websocketClient.socketInstancesByAccounts[instanceNumber][accountId] !== undefined) {\n      this._logger.debug(`${accountId}:${instanceNumber}: scheduling subscribe because account disconnected`);\n      this.scheduleSubscribe(accountId, instanceNumber, true);\n    }\n  }\n\n  /**\n   * Invoked when connection to MetaApi websocket API restored after a disconnect.\n   * @param {Number} instanceNumber instance index number\n   * @param {Number} socketInstanceIndex socket instance index\n   * @param {String[]} reconnectAccountIds account ids to reconnect\n   */\n  onReconnected(instanceNumber, socketInstanceIndex, reconnectAccountIds) {\n    if (!this._awaitingResubscribe[instanceNumber]) {\n      this._awaitingResubscribe[instanceNumber] = {};\n    }\n    const socketInstancesByAccounts = this._websocketClient.socketInstancesByAccounts[instanceNumber];\n    for(let instanceId of Object.keys(this._subscriptions)){\n      const accountId = instanceId.split(':')[0];\n      if (socketInstancesByAccounts[accountId] === socketInstanceIndex) {\n        this.cancelSubscribe(instanceId);\n      }\n    }\n    reconnectAccountIds.forEach(async accountId => {\n      if (!this._awaitingResubscribe[instanceNumber][accountId]) {\n        this._awaitingResubscribe[instanceNumber][accountId] = true;\n        while (this.isAccountSubscribing(accountId, instanceNumber)) {\n          await new Promise(res => setTimeout(res, 1000));\n        }\n        await new Promise(res => setTimeout(res, Math.random() * 5000));\n        if (this._awaitingResubscribe[instanceNumber][accountId]) {\n          delete this._awaitingResubscribe[instanceNumber][accountId];\n          this._logger.debug(`${accountId}:${instanceNumber}: scheduling subscribe because account reconnected`);\n          this.scheduleSubscribe(accountId, instanceNumber);\n        }\n      }\n    });\n  }\n\n  /**\n   * Schedules a task to refresh the account data\n   * @param {string} accountId account id\n   */\n  refreshAccount(accountId) {\n    const mainAccountId = this._websocketClient.accountsByReplicaId[accountId];\n    if (mainAccountId) {\n      const registry = this._metaApi._connectionRegistry;\n      const rpcConnection = registry.rpcConnections[mainAccountId];\n      const region = this._websocketClient.getAccountRegion(accountId);\n      if (region) {\n        if (rpcConnection) {\n          rpcConnection.scheduleRefresh(region);\n        }\n        const streamingConnection = registry.streamingConnections[mainAccountId];\n        if (streamingConnection) {\n          streamingConnection.scheduleRefresh(region);\n        }\n      }\n    }\n  }\n\n  _logSubscriptionError(accountId, message, error) {\n    const primaryAccountId = this._websocketClient.accountsByReplicaId[accountId];\n    const method = this._latencyService.getSynchronizedAccountInstances(primaryAccountId).length ? 'debug' : 'error';\n    this._logger[method](message, error);\n  }\n}"],"names":["LoggerManager","SubscriptionManager","isAccountSubscribing","accountId","instanceNumber","undefined","Object","keys","_subscriptions","includes","key","startsWith","isDisconnectedRetryMode","instanceId","isSubscriptionActive","_subscriptionState","subscribe","_websocketClient","rpcRequest","type","instanceIndex","scheduleSubscribe","client","shouldRetry","task","waitTask","future","subscribeRetryIntervalInSeconds","resolveSubscribe","promise","Promise","res","resolve","subscribeTask","_logger","debug","err","name","socketInstanceIndex","socketInstancesByAccounts","metadata","_logSubscriptionError","lockSocketInstance","getAccountRegion","retryTime","Date","recommendedRetryTime","getTime","now","setTimeout","refreshAccount","mainAccountId","accountsByReplicaId","region","connectedInstances","_latencyService","getActiveAccountInstances","some","instance","_timeoutErrorCounter","retryInterval","Math","min","subscribePromise","result","unsubscribe","cancelAccount","cancelSubscribe","subscription","clearTimeout","filter","_awaitingResubscribe","forEach","onTimeout","connected","onDisconnected","max","random","onReconnected","reconnectAccountIds","split","registry","_metaApi","_connectionRegistry","rpcConnection","rpcConnections","scheduleRefresh","streamingConnection","streamingConnections","message","error","primaryAccountId","method","getSynchronizedAccountInstances","length","constructor","websocketClient","metaApi","_recentlyDeletedAccounts","latencyService","getLogger"],"mappings":"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"}