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)
252 lines (251 loc) • 34.2 kB
JavaScript
'use strict';
function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
try {
var info = gen[key](arg);
var value = info.value;
} catch (error) {
reject(error);
return;
}
if (info.done) {
resolve(value);
} else {
Promise.resolve(value).then(_next, _throw);
}
}
function _async_to_generator(fn) {
return function() {
var self = this, args = arguments;
return new Promise(function(resolve, reject) {
var gen = fn.apply(self, args);
function _next(value) {
asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value);
}
function _throw(err) {
asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err);
}
_next(undefined);
});
};
}
import LoggerManager from '../logger';
import MetaApiConnectionInstance from './metaApiConnectionInstance';
let RpcMetaApiConnectionInstance = class RpcMetaApiConnectionInstance extends MetaApiConnectionInstance {
/**
* Opens the connection. Can only be called the first time, next calls will be ignored.
* @return {Promise} promise resolving when the connection is opened
*/ connect() {
var _this = this;
return _async_to_generator(function*() {
if (!_this._opened) {
_this._opened = true;
_this._metaApiConnection.connect(_this.instanceId);
}
})();
}
/**
* Closes the connection. The instance of the class should no longer be used after this method is invoked.
*/ close() {
var _this = this;
return _async_to_generator(function*() {
if (!_this._closed) {
_this._metaApiConnection.close(_this.instanceId);
_this._closed = true;
}
})();
}
/**
* Returns account information
* @param {GetAccountInformationOptions} [options] additional request options
* @returns {Promise<MetatraderAccountInformation>} promise resolving with account information
*/ getAccountInformation(options) {
this._checkIsConnectionActive();
return this._websocketClient.getAccountInformation(this._metaApiConnection.account.id, options);
}
/**
* Returns positions
* @param {GetPositionsOptions} [options] additional request options
* @returns {Promise<Array<MetatraderPosition>} promise resolving with array of open positions
*/ getPositions(options) {
this._checkIsConnectionActive();
return this._websocketClient.getPositions(this._metaApiConnection.account.id, options);
}
/**
* Returns specific position
* @param {String} positionId position id
* @param {GetPositionOptions} [options] additional request options
* @return {Promise<MetatraderPosition>} promise resolving with MetaTrader position found
*/ getPosition(positionId, options) {
this._checkIsConnectionActive();
return this._websocketClient.getPosition(this._metaApiConnection.account.id, positionId, options);
}
/**
* Returns open orders
* @param {GetOrdersOptions} [options] additional request options
* @return {Promise<Array<MetatraderOrder>>} promise resolving with open MetaTrader orders
*/ getOrders(options) {
this._checkIsConnectionActive();
return this._websocketClient.getOrders(this._metaApiConnection.account.id, options);
}
/**
* Returns specific open order
* @param {String} orderId order id (ticket number)
* @param {GetOrderOptions} [options] additional request options
* @return {Promise<MetatraderOrder>} promise resolving with metatrader order found
*/ getOrder(orderId, options) {
this._checkIsConnectionActive();
return this._websocketClient.getOrder(this._metaApiConnection.account.id, orderId, options);
}
/**
* Returns the history of completed orders for a specific ticket number
* @param {String} ticket ticket number (order id)
* @returns {Promise<MetatraderHistoryOrders>} promise resolving with request results containing history orders found
*/ getHistoryOrdersByTicket(ticket) {
this._checkIsConnectionActive();
return this._websocketClient.getHistoryOrdersByTicket(this._metaApiConnection.account.id, ticket);
}
/**
* Returns the history of completed orders for a specific position id
* @param {String} positionId position id
* @returns {Promise<MetatraderHistoryOrders>} promise resolving with request results containing history orders found
*/ getHistoryOrdersByPosition(positionId) {
this._checkIsConnectionActive();
return this._websocketClient.getHistoryOrdersByPosition(this._metaApiConnection.account.id, positionId);
}
/**
* Returns the history of completed orders for a specific time range
* @param {Date} startTime start of time range, inclusive
* @param {Date} endTime end of time range, exclusive
* @param {Number} offset pagination offset, default is 0
* @param {Number} limit pagination limit, default is 1000
* @returns {Promise<MetatraderHistoryOrders>} promise resolving with request results containing history orders found
*/ getHistoryOrdersByTimeRange(startTime, endTime, offset = 0, limit = 1000) {
this._checkIsConnectionActive();
return this._websocketClient.getHistoryOrdersByTimeRange(this._metaApiConnection.account.id, startTime, endTime, offset, limit);
}
/**
* Returns history deals with a specific ticket number
* @param {String} ticket ticket number (deal id for MT5 or order id for MT4)
* @returns {Promise<MetatraderDeals>} promise resolving with request results containing deals found
*/ getDealsByTicket(ticket) {
this._checkIsConnectionActive();
return this._websocketClient.getDealsByTicket(this._metaApiConnection.account.id, ticket);
}
/**
* Returns history deals for a specific position id
* @param {String} positionId position id
* @returns {Promise<MetatraderDeals>} promise resolving with request results containing deals found
*/ getDealsByPosition(positionId) {
this._checkIsConnectionActive();
return this._websocketClient.getDealsByPosition(this._metaApiConnection.account.id, positionId);
}
/**
* Returns history deals with for a specific time range
* @param {Date} startTime start of time range, inclusive
* @param {Date} endTime end of time range, exclusive
* @param {Number} offset pagination offset, default is 0
* @param {Number} limit pagination limit, default is 1000
* @returns {Promise<MetatraderDeals>} promise resolving with request results containing deals found
*/ getDealsByTimeRange(startTime, endTime, offset = 0, limit = 1000) {
this._checkIsConnectionActive();
return this._websocketClient.getDealsByTimeRange(this._metaApiConnection.account.id, startTime, endTime, offset, limit);
}
/**
* Retrieves available symbols for an account
* @param {String} symbol symbol to retrieve symbols for
* @returns {Promise<Array<string>>} promise which resolves when symbols are retrieved
*/ getSymbols() {
this._checkIsConnectionActive();
return this._websocketClient.getSymbols(this._metaApiConnection.account.id);
}
/**
* Retrieves specification for a symbol
* @param {String} symbol symbol to retrieve specification for
* @returns {Promise<MetatraderSymbolSpecification>} promise which resolves when specification is retrieved
*/ getSymbolSpecification(symbol) {
this._checkIsConnectionActive();
return this._websocketClient.getSymbolSpecification(this._metaApiConnection.account.id, symbol);
}
/**
* Retrieves latest price for a symbol
* @param {String} symbol symbol to retrieve price for
* @param {boolean} keepSubscription if set to true, the account will get a long-term subscription to symbol market
* data. Long-term subscription means that on subsequent calls you will get updated value faster. If set to false or
* not set, the subscription will be set to expire in 12 minutes.
* @returns {Promise<MetatraderSymbolPrice>} promise which resolves when price is retrieved
*/ getSymbolPrice(symbol, keepSubscription) {
this._checkIsConnectionActive();
return this._websocketClient.getSymbolPrice(this._metaApiConnection.account.id, symbol, keepSubscription);
}
/**
* Retrieves latest candle for a symbol and timeframe
* @param {String} symbol symbol to retrieve candle for
* @param {string} timeframe defines the timeframe according to which the candle must be generated. Allowed values for
* MT5 are 1m, 2m, 3m, 4m, 5m, 6m, 10m, 12m, 15m, 20m, 30m, 1h, 2h, 3h, 4h, 6h, 8h, 12h, 1d, 1w, 1mn. Allowed values
* for MT4 are 1m, 5m, 15m 30m, 1h, 4h, 1d, 1w, 1mn
* @param {boolean} keepSubscription if set to true, the account will get a long-term subscription to symbol market
* data. Long-term subscription means that on subsequent calls you will get updated value faster. If set to false or
* not set, the subscription will be set to expire in 12 minutes.
* @returns {Promise<MetatraderCandle>} promise which resolves when candle is retrieved
*/ getCandle(symbol, timeframe, keepSubscription = false) {
this._checkIsConnectionActive();
return this._websocketClient.getCandle(this._metaApiConnection.account.id, symbol, timeframe, keepSubscription);
}
/**
* Retrieves latest tick for a symbol. MT4 G1 accounts do not support this API
* @param {String} symbol symbol to retrieve tick for
* @param {boolean} keepSubscription if set to true, the account will get a long-term subscription to symbol market
* data. Long-term subscription means that on subsequent calls you will get updated value faster. If set to false or
* not set, the subscription will be set to expire in 12 minutes.
* @returns {Promise<MetatraderTick>} promise which resolves when tick is retrieved
*/ getTick(symbol, keepSubscription = false) {
this._checkIsConnectionActive();
return this._websocketClient.getTick(this._metaApiConnection.account.id, symbol, keepSubscription);
}
/**
* Retrieves latest order book for a symbol. MT4 accounts do not support this API
* @param {string} symbol symbol to retrieve order book for
* @param {boolean} keepSubscription if set to true, the account will get a long-term subscription to symbol market
* data. Long-term subscription means that on subsequent calls you will get updated value faster. If set to false or
* not set, the subscription will be set to expire in 12 minutes.
* @returns {Promise<MetatraderTick>} promise which resolves when order book is retrieved
*/ getBook(symbol, keepSubscription = false) {
this._checkIsConnectionActive();
return this._websocketClient.getBook(this._metaApiConnection.account.id, symbol, keepSubscription);
}
/**
* Returns server time for a specified MetaTrader account
* @returns {Promise<ServerTime>} promise resolving with server time
*/ getServerTime() {
var _this = this;
return _async_to_generator(function*() {
_this._checkIsConnectionActive();
return _this._websocketClient.getServerTime(_this._metaApiConnection.account.id);
})();
}
/**
* Waits until synchronization to RPC application is completed
* @param {Number} timeoutInSeconds synchronization timeout in seconds
* @return {Promise} promise which resolves when synchronization to RPC application is completed
* @throws {TimeoutError} if application failed to synchronize with the teminal within timeout allowed
*/ waitSynchronized(timeoutInSeconds = 300) {
var _this = this;
return _async_to_generator(function*() {
_this._checkIsConnectionActive();
return _this._metaApiConnection.waitSynchronized(timeoutInSeconds);
})();
}
/**
* Constructs MetaApi MetaTrader RPC Api connection instance
* @param {MetaApiWebsocketClient} websocketClient MetaApi websocket client
* @param {StreamingMetaApiConnection} metaApiConnection RPC MetaApi connection
*/ constructor(websocketClient, metaApiConnection){
super(websocketClient, metaApiConnection);
this._metaApiConnection = metaApiConnection;
this._logger = LoggerManager.getLogger('RpcMetaApiConnectionInstance');
}
};
/**
* Exposes MetaApi MetaTrader RPC API connection instance to consumers
*/ export { RpcMetaApiConnectionInstance as default };
//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["<anon>"],"sourcesContent":["'use strict';\n\nimport LoggerManager from '../logger';\nimport MetaApiConnectionInstance from './metaApiConnectionInstance';\n\n/**\n * Exposes MetaApi MetaTrader RPC API connection instance to consumers\n */\nexport default class RpcMetaApiConnectionInstance extends MetaApiConnectionInstance {\n\n  /**\n   * Constructs MetaApi MetaTrader RPC Api connection instance\n   * @param {MetaApiWebsocketClient} websocketClient MetaApi websocket client\n   * @param {StreamingMetaApiConnection} metaApiConnection RPC MetaApi connection\n   */\n  constructor(websocketClient, metaApiConnection) {\n    super(websocketClient, metaApiConnection);\n    this._metaApiConnection = metaApiConnection;\n    this._logger = LoggerManager.getLogger('RpcMetaApiConnectionInstance');\n  }\n\n  /**\n   * Opens the connection. Can only be called the first time, next calls will be ignored.\n   * @return {Promise} promise resolving when the connection is opened\n   */\n  async connect() {\n    if (!this._opened) {\n      this._opened = true;\n      this._metaApiConnection.connect(this.instanceId);\n    }\n  }\n\n  /**\n   * Closes the connection. The instance of the class should no longer be used after this method is invoked.\n   */\n  async close() {\n    if (!this._closed) {\n      this._metaApiConnection.close(this.instanceId);\n      this._closed = true;\n    }\n  }\n\n  /**\n   * Returns account information\n   * @param {GetAccountInformationOptions} [options] additional request options\n   * @returns {Promise<MetatraderAccountInformation>} promise resolving with account information\n   */\n  getAccountInformation(options) {\n    this._checkIsConnectionActive();\n    return this._websocketClient.getAccountInformation(this._metaApiConnection.account.id, options);\n  }\n\n  /**\n   * Returns positions\n   * @param {GetPositionsOptions} [options] additional request options\n   * @returns {Promise<Array<MetatraderPosition>} promise resolving with array of open positions\n   */\n  getPositions(options) {\n    this._checkIsConnectionActive();\n    return this._websocketClient.getPositions(this._metaApiConnection.account.id, options);\n  }\n\n  /**\n   * Returns specific position\n   * @param {String} positionId position id\n   * @param {GetPositionOptions} [options] additional request options\n   * @return {Promise<MetatraderPosition>} promise resolving with MetaTrader position found\n   */\n  getPosition(positionId, options) {\n    this._checkIsConnectionActive();\n    return this._websocketClient.getPosition(this._metaApiConnection.account.id, positionId, options);\n  }\n\n  /**\n   * Returns open orders\n   * @param {GetOrdersOptions} [options] additional request options\n   * @return {Promise<Array<MetatraderOrder>>} promise resolving with open MetaTrader orders\n   */\n  getOrders(options) {\n    this._checkIsConnectionActive();\n    return this._websocketClient.getOrders(this._metaApiConnection.account.id, options);\n  }\n\n  /**\n   * Returns specific open order\n   * @param {String} orderId order id (ticket number)\n   * @param {GetOrderOptions} [options] additional request options\n   * @return {Promise<MetatraderOrder>} promise resolving with metatrader order found\n   */\n  getOrder(orderId, options) {\n    this._checkIsConnectionActive();\n    return this._websocketClient.getOrder(this._metaApiConnection.account.id, orderId, options);\n  }\n\n  /**\n   * Returns the history of completed orders for a specific ticket number\n   * @param {String} ticket ticket number (order id)\n   * @returns {Promise<MetatraderHistoryOrders>} promise resolving with request results containing history orders found\n   */\n  getHistoryOrdersByTicket(ticket) {\n    this._checkIsConnectionActive();\n    return this._websocketClient.getHistoryOrdersByTicket(this._metaApiConnection.account.id, ticket);\n  }\n\n  /**\n   * Returns the history of completed orders for a specific position id\n   * @param {String} positionId position id\n   * @returns {Promise<MetatraderHistoryOrders>} promise resolving with request results containing history orders found\n   */\n  getHistoryOrdersByPosition(positionId) {\n    this._checkIsConnectionActive();\n    return this._websocketClient.getHistoryOrdersByPosition(this._metaApiConnection.account.id, positionId);\n  }\n\n  /**\n   * Returns the history of completed orders for a specific time range\n   * @param {Date} startTime start of time range, inclusive\n   * @param {Date} endTime end of time range, exclusive\n   * @param {Number} offset pagination offset, default is 0\n   * @param {Number} limit pagination limit, default is 1000\n   * @returns {Promise<MetatraderHistoryOrders>} promise resolving with request results containing history orders found\n   */\n  getHistoryOrdersByTimeRange(startTime, endTime, offset = 0, limit = 1000) {\n    this._checkIsConnectionActive();\n    return this._websocketClient.getHistoryOrdersByTimeRange(this._metaApiConnection.account.id, \n      startTime, endTime, offset, limit);\n  }\n\n  /**\n   * Returns history deals with a specific ticket number\n   * @param {String} ticket ticket number (deal id for MT5 or order id for MT4)\n   * @returns {Promise<MetatraderDeals>} promise resolving with request results containing deals found\n   */\n  getDealsByTicket(ticket) {\n    this._checkIsConnectionActive();\n    return this._websocketClient.getDealsByTicket(this._metaApiConnection.account.id, ticket);\n  }\n\n  /**\n   * Returns history deals for a specific position id\n   * @param {String} positionId position id\n   * @returns {Promise<MetatraderDeals>} promise resolving with request results containing deals found\n   */\n  getDealsByPosition(positionId) {\n    this._checkIsConnectionActive();\n    return this._websocketClient.getDealsByPosition(this._metaApiConnection.account.id, positionId);\n  }\n\n  /**\n   * Returns history deals with for a specific time range\n   * @param {Date} startTime start of time range, inclusive\n   * @param {Date} endTime end of time range, exclusive\n   * @param {Number} offset pagination offset, default is 0\n   * @param {Number} limit pagination limit, default is 1000\n   * @returns {Promise<MetatraderDeals>} promise resolving with request results containing deals found\n   */\n  getDealsByTimeRange(startTime, endTime, offset = 0, limit = 1000) {\n    this._checkIsConnectionActive();\n    return this._websocketClient.getDealsByTimeRange(this._metaApiConnection.account.id, \n      startTime, endTime, offset, limit);\n  }\n\n  /**\n   * Retrieves available symbols for an account\n   * @param {String} symbol symbol to retrieve symbols for\n   * @returns {Promise<Array<string>>} promise which resolves when symbols are retrieved\n   */\n  getSymbols() {\n    this._checkIsConnectionActive();\n    return this._websocketClient.getSymbols(this._metaApiConnection.account.id);\n  }\n\n  /**\n   * Retrieves specification for a symbol\n   * @param {String} symbol symbol to retrieve specification for\n   * @returns {Promise<MetatraderSymbolSpecification>} promise which resolves when specification is retrieved\n   */\n  getSymbolSpecification(symbol) {\n    this._checkIsConnectionActive();\n    return this._websocketClient.getSymbolSpecification(this._metaApiConnection.account.id, symbol);\n  }\n\n  /**\n   * Retrieves latest price for a symbol\n   * @param {String} symbol symbol to retrieve price for\n   * @param {boolean} keepSubscription if set to true, the account will get a long-term subscription to symbol market\n   * data. Long-term subscription means that on subsequent calls you will get updated value faster. If set to false or\n   * not set, the subscription will be set to expire in 12 minutes.\n   * @returns {Promise<MetatraderSymbolPrice>} promise which resolves when price is retrieved\n   */\n  getSymbolPrice(symbol, keepSubscription) {\n    this._checkIsConnectionActive();\n    return this._websocketClient.getSymbolPrice(this._metaApiConnection.account.id, symbol, keepSubscription);\n  }\n\n  /**\n   * Retrieves latest candle for a symbol and timeframe\n   * @param {String} symbol symbol to retrieve candle for\n   * @param {string} timeframe defines the timeframe according to which the candle must be generated. Allowed values for\n   * MT5 are 1m, 2m, 3m, 4m, 5m, 6m, 10m, 12m, 15m, 20m, 30m, 1h, 2h, 3h, 4h, 6h, 8h, 12h, 1d, 1w, 1mn. Allowed values\n   * for MT4 are 1m, 5m, 15m 30m, 1h, 4h, 1d, 1w, 1mn\n   * @param {boolean} keepSubscription if set to true, the account will get a long-term subscription to symbol market\n   * data. Long-term subscription means that on subsequent calls you will get updated value faster. If set to false or\n   * not set, the subscription will be set to expire in 12 minutes.\n   * @returns {Promise<MetatraderCandle>} promise which resolves when candle is retrieved\n   */\n  getCandle(symbol, timeframe, keepSubscription = false) {\n    this._checkIsConnectionActive();\n    return this._websocketClient.getCandle(this._metaApiConnection.account.id, symbol, timeframe, keepSubscription);\n  }\n\n  /**\n   * Retrieves latest tick for a symbol. MT4 G1 accounts do not support this API\n   * @param {String} symbol symbol to retrieve tick for\n   * @param {boolean} keepSubscription if set to true, the account will get a long-term subscription to symbol market\n   * data. Long-term subscription means that on subsequent calls you will get updated value faster. If set to false or\n   * not set, the subscription will be set to expire in 12 minutes.\n   * @returns {Promise<MetatraderTick>} promise which resolves when tick is retrieved\n   */\n  getTick(symbol, keepSubscription = false) {\n    this._checkIsConnectionActive();\n    return this._websocketClient.getTick(this._metaApiConnection.account.id, symbol, keepSubscription);\n  }\n\n  /**\n   * Retrieves latest order book for a symbol. MT4 accounts do not support this API\n   * @param {string} symbol symbol to retrieve order book for\n   * @param {boolean} keepSubscription if set to true, the account will get a long-term subscription to symbol market\n   * data. Long-term subscription means that on subsequent calls you will get updated value faster. If set to false or\n   * not set, the subscription will be set to expire in 12 minutes.\n   * @returns {Promise<MetatraderTick>} promise which resolves when order book is retrieved\n   */\n  getBook(symbol, keepSubscription = false) {\n    this._checkIsConnectionActive();\n    return this._websocketClient.getBook(this._metaApiConnection.account.id, symbol, keepSubscription);\n  }\n\n  /**\n   * Returns server time for a specified MetaTrader account\n   * @returns {Promise<ServerTime>} promise resolving with server time\n   */\n  async getServerTime() {\n    this._checkIsConnectionActive();\n    return this._websocketClient.getServerTime(this._metaApiConnection.account.id);\n  }\n\n\n  /**\n   * Waits until synchronization to RPC application is completed\n   * @param {Number} timeoutInSeconds synchronization timeout in seconds\n   * @return {Promise} promise which resolves when synchronization to RPC application is completed\n   * @throws {TimeoutError} if application failed to synchronize with the teminal within timeout allowed\n   */\n  async waitSynchronized(timeoutInSeconds=300) {\n    this._checkIsConnectionActive();\n    return this._metaApiConnection.waitSynchronized(timeoutInSeconds);\n  }\n\n}\n"],"names":["LoggerManager","MetaApiConnectionInstance","RpcMetaApiConnectionInstance","connect","_opened","_metaApiConnection","instanceId","close","_closed","getAccountInformation","options","_checkIsConnectionActive","_websocketClient","account","id","getPositions","getPosition","positionId","getOrders","getOrder","orderId","getHistoryOrdersByTicket","ticket","getHistoryOrdersByPosition","getHistoryOrdersByTimeRange","startTime","endTime","offset","limit","getDealsByTicket","getDealsByPosition","getDealsByTimeRange","getSymbols","getSymbolSpecification","symbol","getSymbolPrice","keepSubscription","getCandle","timeframe","getTick","getBook","getServerTime","waitSynchronized","timeoutInSeconds","constructor","websocketClient","metaApiConnection","_logger","getLogger"],"mappings":"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"}