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)
260 lines (259 loc) • 35.5 kB
JavaScript
"use strict";
Object.defineProperty(exports, "__esModule", {
value: true
});
Object.defineProperty(exports, "default", {
enumerable: true,
get: function() {
return MetatraderAccountReplica;
}
});
const _timeoutError = /*#__PURE__*/ _interop_require_default(require("../clients/timeoutError"));
function _interop_require_default(obj) {
return obj && obj.__esModule ? obj : {
default: obj
};
}
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
*/ async remove() {
await this._metatraderAccountClient.deleteAccountReplica(this.primaryAccount.id, this.id);
try {
await 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
*/ async deploy() {
await this._metatraderAccountClient.deployAccountReplica(this.primaryAccount.id, this.id);
await 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
*/ async undeploy() {
await this._metatraderAccountClient.undeployAccountReplica(this.primaryAccount.id, this.id);
await 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
*/ async redeploy() {
await this._metatraderAccountClient.redeployAccountReplica(this.primaryAccount.id, this.id);
await 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
*/ async increaseReliability() {
await this._metatraderAccountClient.increaseReliability(this.id);
await 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
*/ async waitDeployed(timeoutInSeconds = 300, intervalInMilliseconds = 1000) {
let startTime = Date.now();
await this._primaryAccount.reload();
while(this.state !== "DEPLOYED" && startTime + timeoutInSeconds * 1000 > Date.now()){
await this._delay(intervalInMilliseconds);
await this._primaryAccount.reload();
}
if (this.state !== "DEPLOYED") {
throw new _timeoutError.default("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
*/ async waitUndeployed(timeoutInSeconds = 300, intervalInMilliseconds = 1000) {
let startTime = Date.now();
await this._primaryAccount.reload();
while(this.state !== "UNDEPLOYED" && startTime + timeoutInSeconds * 1000 > Date.now()){
await this._delay(intervalInMilliseconds);
await this._primaryAccount.reload();
}
if (this.state !== "UNDEPLOYED") {
throw new _timeoutError.default("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
*/ async waitRemoved(timeoutInSeconds = 300, intervalInMilliseconds = 1000) {
let startTime = Date.now();
await this._primaryAccount.reload();
while(startTime + timeoutInSeconds * 1000 > Date.now() && this._primaryAccount.accountRegions[this.region] === this.id){
await this._delay(intervalInMilliseconds);
await this._primaryAccount.reload();
}
if (this._primaryAccount.accountRegions[this.region] === this.id) {
throw new _timeoutError.default("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
*/ async waitConnected(timeoutInSeconds = 300, intervalInMilliseconds = 1000) {
let startTime = Date.now();
await this._primaryAccount.reload();
while(this.connectionStatus !== "CONNECTED" && startTime + timeoutInSeconds * 1000 > Date.now()){
await this._delay(intervalInMilliseconds);
await this._primaryAccount.reload();
}
if (this.connectionStatus !== "CONNECTED") {
throw new _timeoutError.default("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
*/ async update(metatraderAccount) {
await this._metatraderAccountClient.updateAccountReplica(this._primaryAccount.id, this.id, metatraderAccount);
await 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;
}
};
//# 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":["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","TimeoutError","waitUndeployed","waitRemoved","accountRegions","waitConnected","update","metatraderAccount","updateAccountReplica","timeoutInMilliseconds","Promise","res","setTimeout","constructor","metatraderAccountClient"],"mappings":"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"}