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)
322 lines (321 loc) • 46.5 kB
JavaScript
"use strict";
Object.defineProperty(exports, "__esModule", {
value: true
});
Object.defineProperty(exports, "default", {
enumerable: true,
get: function() {
return SubscriptionManager;
}
});
const _logger = /*#__PURE__*/ _interop_require_default(require("../../logger"));
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 _interop_require_default(obj) {
return obj && obj.__esModule ? obj : {
default: obj
};
}
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
*/ async scheduleSubscribe(accountId, instanceNumber, isDisconnectedRetryMode = false) {
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 = async ()=>{
try {
this._logger.debug(`${accountId}:${instanceNumber}: running subscribe task`);
await 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) {
await 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();
};
subscribeTask();
await 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 = await 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
*/ async unsubscribe(accountId, instanceNumber) {
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
*/ async onDisconnected(accountId, instanceNumber) {
await 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);
}
}
reconnectAccountIds.forEach(async (accountId)=>{
if (!this._awaitingResubscribe[instanceNumber][accountId]) {
this._awaitingResubscribe[instanceNumber][accountId] = true;
while(this.isAccountSubscribing(accountId, instanceNumber)){
await new Promise((res)=>setTimeout(res, 1000));
}
await 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);
}
}
});
}
/**
* 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 = _logger.default.getLogger("SubscriptionManager");
this._timeoutErrorCounter = {};
this._recentlyDeletedAccounts = {};
}
};
//# 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":["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","LoggerManager","getLogger"],"mappings":"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"}