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)
308 lines (307 loc) • 37.1 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);
});
};
}
import TimeoutError from '../clients/timeoutError';
let MetatraderAccountReplica = class MetatraderAccountReplica {
/**
* Returns account replica id
* @return {string} unique account replica id
*/ get id() {
return this._data._id;
}
/**
* Returns current account replica state. One of CREATED, DEPLOYING, DEPLOYED, DEPLOY_FAILED, UNDEPLOYING,
* UNDEPLOYED, UNDEPLOY_FAILED, DELETING, DELETE_FAILED, REDEPLOY_FAILED, DRAFT
* @return {State} current account replica state
*/ get state() {
return this._data.state;
}
/**
* Returns MetaTrader magic to place trades using
* @return {number} MetaTrader magic to place trades using
*/ get magic() {
return this._data.magic;
}
/**
* Returns terminal & broker connection status, one of CONNECTED, DISCONNECTED, DISCONNECTED_FROM_BROKER
* @return {ConnectionStatus} terminal & broker connection status
*/ get connectionStatus() {
return this._data.connectionStatus;
}
/**
* Returns quote streaming interval in seconds
* @return {number} quote streaming interval in seconds
*/ get quoteStreamingIntervalInSeconds() {
return this._data.quoteStreamingIntervalInSeconds;
}
/**
* Returns symbol provided by broker
* @return {string} any symbol provided by broker
*/ get symbol() {
return this._data.symbol;
}
/**
* Returns reliability value. Possible values are regular and high
* @return {Reliability} account replica reliability value
*/ get reliability() {
return this._data.reliability;
}
/**
* Returns user-defined account replica tags
* @return {Array<string>} user-defined account replica tags
*/ get tags() {
return this._data.tags;
}
/**
* Returns extra information which can be stored together with your account replica
* @return {Object} extra information which can be stored together with your account replica
*/ get metadata() {
return this._data.metadata;
}
/**
* Returns number of resource slots to allocate to account replica. Allocating extra resource slots
* results in better account performance under load which is useful for some applications. E.g. if you have many
* accounts copying the same strategy via CopyFactory API, then you can increase resourceSlots to get a lower trade
* copying latency. Please note that allocating extra resource slots is a paid option. Please note that high
* reliability accounts use redundant infrastructure, so that each resource slot for a high reliability account
* is billed as 2 standard resource slots.
* @return {number} number of resource slots to allocate to account replica
*/ get resourceSlots() {
return this._data.resourceSlots;
}
/**
* Returns the number of CopyFactory 2 resource slots to allocate to account replica.
* Allocating extra resource slots results in lower trade copying latency. Please note that allocating extra resource
* slots is a paid option. Please also note that CopyFactory 2 uses redundant infrastructure so that
* each CopyFactory resource slot is billed as 2 standard resource slots. You will be billed for CopyFactory 2
* resource slots only if you have added your account replica to CopyFactory 2 by specifying copyFactoryRoles field.
* @return {number} number of CopyFactory 2 resource slots to allocate to account replica
*/ get copyFactoryResourceSlots() {
return this._data.copyFactoryResourceSlots;
}
/**
* Returns account replica region
* @return {string} account replica region value
*/ get region() {
return this._data.region;
}
/**
* Returns the time account replica was created at, in ISO format
* @returns {string} the time account replica was created at, in ISO format
*/ get createdAt() {
return new Date(this._data.createdAt);
}
/**
* Returns primary MetaTrader account of the replica from DTO
* @return {MetatraderAccount} primary MetaTrader account of the replica from DTO
*/ get primaryAccountFromDto() {
return this._data.primaryAccount;
}
/**
* Returns primary MetaTrader account of the replica
* @return {MetatraderAccount} primary MetaTrader account of the replica
*/ get primaryAccount() {
return this._primaryAccount;
}
/**
* Updates account replica data
* @param {MetatraderAccountReplicaDto} data MetaTrader account replica data
*/ updateData(data) {
this._data = data;
}
/**
* Removes a trading account replica and stops the API server serving the replica
* @return {Promise} promise resolving when account replica is scheduled for deletion
*/ remove() {
var _this = this;
return _async_to_generator(function*() {
yield _this._metatraderAccountClient.deleteAccountReplica(_this.primaryAccount.id, _this.id);
try {
yield _this._primaryAccount.reload();
} catch (err) {
if (err.name !== 'NotFoundError') {
throw err;
}
}
})();
}
/**
* Starts API server and trading terminal for trading account replica.
* This request will be ignored if the replica is already deployed
* @returns {Promise} promise resolving when account replica is scheduled for deployment
*/ deploy() {
var _this = this;
return _async_to_generator(function*() {
yield _this._metatraderAccountClient.deployAccountReplica(_this.primaryAccount.id, _this.id);
yield _this._primaryAccount.reload();
})();
}
/**
* Stops API server and trading terminal for trading account replica.
* The request will be ignored if trading account replica is already undeployed
* @returns {Promise} promise resolving when account replica is scheduled for undeployment
*/ undeploy() {
var _this = this;
return _async_to_generator(function*() {
yield _this._metatraderAccountClient.undeployAccountReplica(_this.primaryAccount.id, _this.id);
yield _this._primaryAccount.reload();
})();
}
/**
* Redeploys trading account replica. This is equivalent to undeploy immediately followed by deploy.
* @returns {Promise} promise resolving when account replica is scheduled for redeployment
*/ redeploy() {
var _this = this;
return _async_to_generator(function*() {
yield _this._metatraderAccountClient.redeployAccountReplica(_this.primaryAccount.id, _this.id);
yield _this._primaryAccount.reload();
})();
}
/**
* Increases trading account reliability in order to increase the expected account uptime.
* The account will be temporary stopped to perform this action.
* Note that increasing reliability is a paid option
* @returns {Promise} promise resolving when account replica reliability is increased
*/ increaseReliability() {
var _this = this;
return _async_to_generator(function*() {
yield _this._metatraderAccountClient.increaseReliability(_this.id);
yield _this._primaryAccount.reload();
})();
}
/**
* Waits until API server has finished deployment and account replica reached the DEPLOYED state
* @param {number} timeoutInSeconds wait timeout in seconds, default is 5m
* @param {number} intervalInMilliseconds interval between account replica reloads while waiting for a change, default is 1s
* @return {Promise} promise which resolves when account replica is deployed
* @throws {TimeoutError} if account replica has not reached the DEPLOYED state within timeout allowed
*/ waitDeployed(timeoutInSeconds = 300, intervalInMilliseconds = 1000) {
var _this = this;
return _async_to_generator(function*() {
let startTime = Date.now();
yield _this._primaryAccount.reload();
while(_this.state !== 'DEPLOYED' && startTime + timeoutInSeconds * 1000 > Date.now()){
yield _this._delay(intervalInMilliseconds);
yield _this._primaryAccount.reload();
}
if (_this.state !== 'DEPLOYED') {
throw new TimeoutError('Timed out waiting for account replica ' + _this.id + ' to be deployed');
}
})();
}
/**
* Waits until API server has finished undeployment and account replica reached the UNDEPLOYED state
* @param {number} timeoutInSeconds wait timeout in seconds, default is 5m
* @param {number} intervalInMilliseconds interval between account replica reloads while waiting for a change, default is 1s
* @return {Promise} promise which resolves when account replica is deployed
* @throws {TimeoutError} if account replica has not reached the UNDEPLOYED state within timeout allowed
*/ waitUndeployed(timeoutInSeconds = 300, intervalInMilliseconds = 1000) {
var _this = this;
return _async_to_generator(function*() {
let startTime = Date.now();
yield _this._primaryAccount.reload();
while(_this.state !== 'UNDEPLOYED' && startTime + timeoutInSeconds * 1000 > Date.now()){
yield _this._delay(intervalInMilliseconds);
yield _this._primaryAccount.reload();
}
if (_this.state !== 'UNDEPLOYED') {
throw new TimeoutError('Timed out waiting for account replica ' + _this.id + ' to be undeployed');
}
})();
}
/**
* Waits until account replica has been deleted
* @param {number} timeoutInSeconds wait timeout in seconds, default is 5m
* @param {number} intervalInMilliseconds interval between account replica reloads while waiting for a change, default is 1s
* @return {Promise} promise which resolves when account replica is deleted
* @throws {TimeoutError} if account replica was not deleted within timeout allowed
*/ waitRemoved(timeoutInSeconds = 300, intervalInMilliseconds = 1000) {
var _this = this;
return _async_to_generator(function*() {
let startTime = Date.now();
yield _this._primaryAccount.reload();
while(startTime + timeoutInSeconds * 1000 > Date.now() && _this._primaryAccount.accountRegions[_this.region] === _this.id){
yield _this._delay(intervalInMilliseconds);
yield _this._primaryAccount.reload();
}
if (_this._primaryAccount.accountRegions[_this.region] === _this.id) {
throw new TimeoutError('Timed out waiting for account ' + _this.id + ' to be deleted');
}
})();
}
/**
* Waits until API server has connected to the terminal and terminal has connected to the broker
* @param {number} timeoutInSeconds wait timeout in seconds, default is 5m
* @param {number} intervalInMilliseconds interval between account replica reloads while waiting for a change, default is 1s
* @return {Promise} promise which resolves when API server is connected to the broker
* @throws {TimeoutError} if account replica has not connected to the broker within timeout allowed
*/ waitConnected(timeoutInSeconds = 300, intervalInMilliseconds = 1000) {
var _this = this;
return _async_to_generator(function*() {
let startTime = Date.now();
yield _this._primaryAccount.reload();
while(_this.connectionStatus !== 'CONNECTED' && startTime + timeoutInSeconds * 1000 > Date.now()){
yield _this._delay(intervalInMilliseconds);
yield _this._primaryAccount.reload();
}
if (_this.connectionStatus !== 'CONNECTED') {
throw new TimeoutError('Timed out waiting for account ' + _this.id + ' to connect to the broker');
}
})();
}
/**
* Updates trading account replica
* @param {UpdatedMetatraderAccountReplicaDto} metatraderAccount updated account replica information
* @return {Promise} promise resolving when account replica is updated
*/ update(metatraderAccount) {
var _this = this;
return _async_to_generator(function*() {
yield _this._metatraderAccountClient.updateAccountReplica(_this._primaryAccount.id, _this.id, metatraderAccount);
yield _this._primaryAccount.reload();
})();
}
_delay(timeoutInMilliseconds) {
return new Promise((res)=>setTimeout(res, timeoutInMilliseconds));
}
/**
* Constructs a MetaTrader account replica entity
* @param {MetatraderAccountReplicaDto} data MetaTrader account replica data
* @param {MetatraderAccount} primaryAccount primary MetaTrader account
* @param {MetatraderAccountClient} metatraderAccountClient MetaTrader account REST API client
*/ constructor(data, primaryAccount, metatraderAccountClient){
this._data = data;
this._primaryAccount = primaryAccount;
this._metatraderAccountClient = metatraderAccountClient;
}
};
// import {Reliability, State, ConnectionStatus} from '../clients/metaApi/metatraderAccount.client';
/**
* Implements a MetaTrader account replica entity
*/ export { MetatraderAccountReplica as default };
//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["<anon>"],"sourcesContent":["import TimeoutError from '../clients/timeoutError';\n// import {Reliability, State, ConnectionStatus} from '../clients/metaApi/metatraderAccount.client';\n\n/**\n * Implements a MetaTrader account replica entity\n */\nexport default class MetatraderAccountReplica {\n\n  /**\n   * Constructs a MetaTrader account replica entity\n   * @param {MetatraderAccountReplicaDto} data MetaTrader account replica data\n   * @param {MetatraderAccount} primaryAccount primary MetaTrader account\n   * @param {MetatraderAccountClient} metatraderAccountClient MetaTrader account REST API client\n   */\n  constructor(data, primaryAccount, metatraderAccountClient) {\n    this._data = data;\n    this._primaryAccount = primaryAccount;\n    this._metatraderAccountClient = metatraderAccountClient;\n  }\n\n  /**\n   * Returns account replica id\n   * @return {string} unique account replica id\n   */\n  get id() {\n    return this._data._id;\n  }\n\n  /**\n   * Returns current account replica state. One of CREATED, DEPLOYING, DEPLOYED, DEPLOY_FAILED, UNDEPLOYING,\n   * UNDEPLOYED, UNDEPLOY_FAILED, DELETING, DELETE_FAILED, REDEPLOY_FAILED, DRAFT\n   * @return {State} current account replica state\n   */\n  get state() {\n    return this._data.state;\n  }\n\n  /**\n   * Returns MetaTrader magic to place trades using\n   * @return {number} MetaTrader magic to place trades using\n   */\n  get magic() {\n    return this._data.magic;\n  }\n  \n  /**\n   * Returns terminal & broker connection status, one of CONNECTED, DISCONNECTED, DISCONNECTED_FROM_BROKER\n   * @return {ConnectionStatus} terminal & broker connection status\n   */\n  get connectionStatus() {\n    return this._data.connectionStatus;\n  }\n\n  /**\n   * Returns quote streaming interval in seconds \n   * @return {number} quote streaming interval in seconds\n   */\n  get quoteStreamingIntervalInSeconds() {\n    return this._data.quoteStreamingIntervalInSeconds;\n  }\n\n  /**\n   * Returns symbol provided by broker \n   * @return {string} any symbol provided by broker\n   */\n  get symbol() {\n    return this._data.symbol;\n  }\n\n  /**\n   * Returns reliability value. Possible values are regular and high\n   * @return {Reliability} account replica reliability value\n   */\n  get reliability() {\n    return this._data.reliability;\n  }\n\n  /**\n   * Returns user-defined account replica tags\n   * @return {Array<string>} user-defined account replica tags\n   */\n  get tags() {\n    return this._data.tags;\n  }  \n\n  /**\n   * Returns extra information which can be stored together with your account replica\n   * @return {Object} extra information which can be stored together with your account replica\n   */\n  get metadata() {\n    return this._data.metadata;\n  }\n\n  /**\n   * Returns number of resource slots to allocate to account replica. Allocating extra resource slots\n   * results in better account performance under load which is useful for some applications. E.g. if you have many\n   * accounts copying the same strategy via CopyFactory API, then you can increase resourceSlots to get a lower trade\n   * copying latency. Please note that allocating extra resource slots is a paid option. Please note that high\n   * reliability accounts use redundant infrastructure, so that each resource slot for a high reliability account\n   * is billed as 2 standard resource slots.\n   * @return {number} number of resource slots to allocate to account replica\n   */\n  get resourceSlots() {\n    return this._data.resourceSlots;\n  }\n\n  /**\n   * Returns the number of CopyFactory 2 resource slots to allocate to account replica.\n   * Allocating extra resource slots results in lower trade copying latency. Please note that allocating extra resource\n   * slots is a paid option. Please also note that CopyFactory 2 uses redundant infrastructure so that\n   * each CopyFactory resource slot is billed as 2 standard resource slots. You will be billed for CopyFactory 2\n   * resource slots only if you have added your account replica to CopyFactory 2 by specifying copyFactoryRoles field.\n   * @return {number} number of CopyFactory 2 resource slots to allocate to account replica\n   */\n  get copyFactoryResourceSlots() {\n    return this._data.copyFactoryResourceSlots;\n  }\n\n  /**\n     * Returns account replica region\n     * @return {string} account replica region value\n     */\n  get region() {\n    return this._data.region;\n  }\n\n  /**\n   * Returns the time account replica was created at, in ISO format\n   * @returns {string} the time account replica was created at, in ISO format\n   */\n  get createdAt() {\n    return new Date(this._data.createdAt);\n  }\n\n  /**\n   * Returns primary MetaTrader account of the replica from DTO\n   * @return {MetatraderAccount} primary MetaTrader account of the replica from DTO\n   */\n  get primaryAccountFromDto() {\n    return this._data.primaryAccount;\n  }\n\n  /**\n   * Returns primary MetaTrader account of the replica\n   * @return {MetatraderAccount} primary MetaTrader account of the replica\n   */\n  get primaryAccount() {\n    return this._primaryAccount;\n  }\n\n  /**\n   * Updates account replica data\n   * @param {MetatraderAccountReplicaDto} data MetaTrader account replica data \n   */\n  updateData(data) {\n    this._data = data;\n  }\n\n  /**\n   * Removes a trading account replica and stops the API server serving the replica\n   * @return {Promise} promise resolving when account replica is scheduled for deletion\n   */\n  async remove() {\n    await this._metatraderAccountClient.deleteAccountReplica(this.primaryAccount.id, this.id);\n    try {\n      await this._primaryAccount.reload();\n    } catch (err) {\n      if (err.name !== 'NotFoundError') {\n        throw err;\n      }\n    }\n  }\n\n  /**\n   * Starts API server and trading terminal for trading account replica.\n   * This request will be ignored if the replica is already deployed\n   * @returns {Promise} promise resolving when account replica is scheduled for deployment\n   */\n  async deploy() {\n    await this._metatraderAccountClient.deployAccountReplica(this.primaryAccount.id, this.id);\n    await this._primaryAccount.reload();\n  }\n\n  /**\n   * Stops API server and trading terminal for trading account replica.\n   * The request will be ignored if trading account replica is already undeployed\n   * @returns {Promise} promise resolving when account replica is scheduled for undeployment\n   */\n  async undeploy() {\n    await this._metatraderAccountClient.undeployAccountReplica(this.primaryAccount.id, this.id);\n    await this._primaryAccount.reload();\n  }\n\n  /**\n   * Redeploys trading account replica. This is equivalent to undeploy immediately followed by deploy.\n   * @returns {Promise} promise resolving when account replica is scheduled for redeployment\n   */\n  async redeploy() {\n    await this._metatraderAccountClient.redeployAccountReplica(this.primaryAccount.id, this.id);\n    await this._primaryAccount.reload();\n  }\n\n  /**\n   * Increases trading account reliability in order to increase the expected account uptime.\n   * The account will be temporary stopped to perform this action.\n   * Note that increasing reliability is a paid option\n   * @returns {Promise} promise resolving when account replica reliability is increased\n   */\n  async increaseReliability() {\n    await this._metatraderAccountClient.increaseReliability(this.id);\n    await this._primaryAccount.reload();\n  }\n\n  /**\n   * Waits until API server has finished deployment and account replica reached the DEPLOYED state\n   * @param {number} timeoutInSeconds wait timeout in seconds, default is 5m\n   * @param {number} intervalInMilliseconds interval between account replica reloads while waiting for a change, default is 1s\n   * @return {Promise} promise which resolves when account replica is deployed\n   * @throws {TimeoutError} if account replica has not reached the DEPLOYED state within timeout allowed\n   */\n  async waitDeployed(timeoutInSeconds = 300, intervalInMilliseconds = 1000) {\n    let startTime = Date.now();\n    await this._primaryAccount.reload();\n    while (this.state !== 'DEPLOYED' && (startTime + timeoutInSeconds * 1000) > Date.now()) {\n      await this._delay(intervalInMilliseconds);\n      await this._primaryAccount.reload();\n    }\n    if (this.state !== 'DEPLOYED') {\n      throw new TimeoutError('Timed out waiting for account replica ' + this.id + ' to be deployed');\n    }\n  }\n\n  /**\n   * Waits until API server has finished undeployment and account replica reached the UNDEPLOYED state\n   * @param {number} timeoutInSeconds wait timeout in seconds, default is 5m\n   * @param {number} intervalInMilliseconds interval between account replica reloads while waiting for a change, default is 1s\n   * @return {Promise} promise which resolves when account replica is deployed\n   * @throws {TimeoutError} if account replica has not reached the UNDEPLOYED state within timeout allowed\n   */\n  async waitUndeployed(timeoutInSeconds = 300, intervalInMilliseconds = 1000) {\n    let startTime = Date.now();\n    await this._primaryAccount.reload();\n    while (this.state !== 'UNDEPLOYED' && (startTime + timeoutInSeconds * 1000) > Date.now()) {\n      await this._delay(intervalInMilliseconds);\n      await this._primaryAccount.reload();\n    }\n    if (this.state !== 'UNDEPLOYED') {\n      throw new TimeoutError('Timed out waiting for account replica ' + this.id + ' to be undeployed');\n    }\n  }\n\n  /**\n   * Waits until account replica has been deleted\n   * @param {number} timeoutInSeconds wait timeout in seconds, default is 5m\n   * @param {number} intervalInMilliseconds interval between account replica reloads while waiting for a change, default is 1s\n   * @return {Promise} promise which resolves when account replica is deleted\n   * @throws {TimeoutError} if account replica was not deleted within timeout allowed\n   */\n  async waitRemoved(timeoutInSeconds = 300, intervalInMilliseconds = 1000) {\n    let startTime = Date.now();\n    await this._primaryAccount.reload();\n    while (startTime + timeoutInSeconds * 1000 > Date.now() && \n        this._primaryAccount.accountRegions[this.region] === this.id) {\n      await this._delay(intervalInMilliseconds);\n      await this._primaryAccount.reload();\n    }\n    if(this._primaryAccount.accountRegions[this.region] === this.id) {\n      throw new TimeoutError('Timed out waiting for account ' + this.id + ' to be deleted');\n    }\n  }\n\n  /**\n   * Waits until API server has connected to the terminal and terminal has connected to the broker\n   * @param {number} timeoutInSeconds wait timeout in seconds, default is 5m\n   * @param {number} intervalInMilliseconds interval between account replica reloads while waiting for a change, default is 1s\n   * @return {Promise} promise which resolves when API server is connected to the broker\n   * @throws {TimeoutError} if account replica has not connected to the broker within timeout allowed\n   */\n  async waitConnected(timeoutInSeconds = 300, intervalInMilliseconds = 1000) {\n    let startTime = Date.now();\n    await this._primaryAccount.reload();\n    while (this.connectionStatus !== 'CONNECTED' && (startTime + timeoutInSeconds * 1000) > Date.now()) {\n      await this._delay(intervalInMilliseconds);\n      await this._primaryAccount.reload();\n    }\n    if (this.connectionStatus !== 'CONNECTED') {\n      throw new TimeoutError('Timed out waiting for account ' + this.id + ' to connect to the broker');\n    }\n  }\n\n  /**\n   * Updates trading account replica\n   * @param {UpdatedMetatraderAccountReplicaDto} metatraderAccount updated account replica information\n   * @return {Promise} promise resolving when account replica is updated\n   */\n  async update(metatraderAccount) {\n    await this._metatraderAccountClient.updateAccountReplica(this._primaryAccount.id, this.id, metatraderAccount);\n    await this._primaryAccount.reload();\n  }\n\n  _delay(timeoutInMilliseconds) {\n    return new Promise(res => setTimeout(res, timeoutInMilliseconds));\n  }\n\n}\n"],"names":["TimeoutError","MetatraderAccountReplica","id","_data","_id","state","magic","connectionStatus","quoteStreamingIntervalInSeconds","symbol","reliability","tags","metadata","resourceSlots","copyFactoryResourceSlots","region","createdAt","Date","primaryAccountFromDto","primaryAccount","_primaryAccount","updateData","data","remove","_metatraderAccountClient","deleteAccountReplica","reload","err","name","deploy","deployAccountReplica","undeploy","undeployAccountReplica","redeploy","redeployAccountReplica","increaseReliability","waitDeployed","timeoutInSeconds","intervalInMilliseconds","startTime","now","_delay","waitUndeployed","waitRemoved","accountRegions","waitConnected","update","metatraderAccount","updateAccountReplica","timeoutInMilliseconds","Promise","res","setTimeout","constructor","metatraderAccountClient"],"mappings":"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"}