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)
240 lines (239 loc) • 28.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);
});
};
}
let TerminalListener = class TerminalListener {
/**
* Returns MetaApiConnection instance
* @return {MetaApiConnection} MetaApiConnection instance
*/ get connection() {
return this._connection;
}
/**
* Sets MetaApiConnection instance
* @param {MetaApiConnection} connection MetaApiConnection instance
*/ set connection(connection) {
this._connection = connection;
}
/**
* Invoked when connection to MetaTrader terminal established
* @return {Promise} promise which resolves when the asynchronous event is processed
*/ onConnected() {
return _async_to_generator(function*() {})();
}
/**
* Invoked when connection to MetaTrader terminal terminated
* @return {Promise} promise which resolves when the asynchronous event is processed
*/ onDisconnected() {
return _async_to_generator(function*() {})();
}
/**
* Invoked when broker connection satus have changed
* @param {Boolean} connected is MetaTrader terminal is connected to broker
* @return {Promise} promise which resolves when the asynchronous event is processed
*/ onBrokerConnectionStatus(connected) {
return _async_to_generator(function*() {})();
}
/**
* Invoked when MetaTrader terminal state synchronization is started
* @param {string} instanceIndex index of an account instance connected
* @param {string} specificationsHash specifications hash
* @param {string} positionsHash positions hash
* @param {string} ordersHash orders hash
* @param {string} synchronizationId synchronization id
* @return {Promise} promise which resolves when the asynchronous event is processed
*/ onSynchronizationStarted(instanceIndex, specificationsHash, positionsHash, ordersHash, synchronizationId) {}
/**
* Invoked when MetaTrader account information is updated
* @param {MetatraderAccountInformation} accountInformation updated MetaTrader account information
* @return {Promise} promise which resolves when the asynchronous event is processed
*/ onAccountInformationUpdated(accountInformation) {
return _async_to_generator(function*() {})();
}
/**
* Invoked when the positions are replaced as a result of initial terminal state synchronization. This method
* will be invoked only if server thinks the data was updated, otherwise invocation can be skipped
* @param {Array<MetatraderPosition>} positions updated array of positions
* @return {Promise} promise which resolves when the asynchronous event is processed
*/ onPositionsReplaced(positions) {
return _async_to_generator(function*() {})();
}
/**
* Invoked when position synchronization fnished to indicate progress of an initial terminal state synchronization
* @return {Promise} promise which resolves when the asynchronous event is processed
*/ onPositionsSynchronized() {
return _async_to_generator(function*() {})();
}
/**
* Invoked when MetaTrader position is updated
* @param {MetatraderPosition} position updated MetaTrader position
* @return {Promise} promise which resolves when the asynchronous event is processed
*/ onPositionUpdated(position) {
return _async_to_generator(function*() {})();
}
/**
* Invoked when MetaTrader position is removed
* @param {String} positionId removed MetaTrader position id
* @return {Promise} promise which resolves when the asynchronous event is processed
*/ onPositionRemoved(positionId) {
return _async_to_generator(function*() {})();
}
/**
* Invoked when the pending orders are replaced as a result of initial terminal state synchronization. This method
* will be invoked only if server thinks the data was updated, otherwise invocation can be skipped
* @param {Array<MetatraderOrder>} orders updated array of pending orders
* @return {Promise} promise which resolves when the asynchronous event is processed
*/ onPendingOrdersReplaced(orders) {
return _async_to_generator(function*() {})();
}
/**
* Invoked when MetaTrader pending order is updated
* @param {MetatraderOrder} order updated MetaTrader pending order
* @return {Promise} promise which resolves when the asynchronous event is processed
*/ onPendingOrderUpdated(order) {
return _async_to_generator(function*() {})();
}
/**
* Invoked when MetaTrader pending order is completed (executed or canceled)
* @param {String} orderId completed MetaTrader pending order id
* @return {Promise} promise which resolves when the asynchronous event is processed
*/ onPendingOrderCompleted(orderId) {
return _async_to_generator(function*() {})();
}
/**
* Invoked when pending order synchronization fnished to indicate progress of an initial terminal state
* synchronization
* @return {Promise} promise which resolves when the asynchronous event is processed
*/ onPendingOrdersSynchronized() {
return _async_to_generator(function*() {})();
}
/**
* Invoked when a new MetaTrader history order is added
* @param {MetatraderOrder} historyOrder new MetaTrader history order
* @return {Promise} promise which resolves when the asynchronous event is processed
*/ onHistoryOrderAdded(historyOrder) {
return _async_to_generator(function*() {})();
}
/**
* Invoked when a synchronization of history orders on a MetaTrader account have finished to indicate progress of an
* initial terminal state synchronization
* @return {Promise} promise which resolves when the asynchronous event is processed
*/ onHistoryOrdersSynchronized() {
return _async_to_generator(function*() {})();
}
/**
* Invoked when a new MetaTrader history deal is added
* @param {MetatraderDeal} deal new MetaTrader history deal
* @return {Promise} promise which resolves when the asynchronous event is processed
*/ onDealAdded(deal) {
return _async_to_generator(function*() {})();
}
/**
* Invoked when a synchronization of history deals on a MetaTrader account have finished to indicate progress of an
* initial terminal state synchronization
* @return {Promise} promise which resolves when the asynchronous event is processed
*/ onDealsSynchronized() {
return _async_to_generator(function*() {})();
}
/**
* Invoked when a symbol specification was updated
* @param {MetatraderSymbolSpecification} specification updated MetaTrader symbol specification
* @return {Promise} promise which resolves when the asynchronous event is processed
*/ onSymbolSpecificationUpdated(specification) {
return _async_to_generator(function*() {})();
}
/**
* Invoked when a symbol specification was removed
* @param {String} symbol removed symbol
* @returns {Promise} promise which resolves when the asynchronous event is processed
*/ onSymbolSpecificationRemoved(symbol) {
return _async_to_generator(function*() {})();
}
/**
* Invoked when a symbol price was updated
* @param {MetatraderSymbolPrice} quote updated MetaTrader symbol quote
* @return {Promise} promise which resolves when the asynchronous event is processed
*/ onQuote(quote) {
return _async_to_generator(function*() {})();
}
/**
* Invoked when symbol candles were updated
* @param {MetatraderCandle} candle updated MetaTrader symbol candle
* @return {Promise} promise which resolves when the asynchronous event is processed
*/ onCandle(candles) {
return _async_to_generator(function*() {})();
}
/**
* Invoked when symbol ticks were updated
* @param {MetatraderTick} tick updated MetaTrader symbol tick
* @return {Promise} promise which resolves when the asynchronous event is processed
*/ onTick(tick) {
return _async_to_generator(function*() {})();
}
/**
* Invoked when order books were updated
* @param {MetatraderBook} book updated MetaTrader order book
* @return {Promise} promise which resolves when the asynchronous event is processed
*/ onBook(book) {
return _async_to_generator(function*() {})();
}
/**
* Invoked when subscription downgrade has occurred
* @param {string} symbol symbol to update subscriptions for
* @param {Array<MarketDataSubscription>} updates array of market data subscription to update
* @param {Array<MarketDataUnsubscription>} unsubscriptions array of subscriptions to cancel
* @return {Promise} promise which resolves when the asynchronous event is processed
*/ onSubscriptionDowngraded(symbol, updates, unsubscriptions) {
return _async_to_generator(function*() {})();
}
};
/**
* Defines interface for a terminal listener class. You can extend your trading application implementation from
* this class.
* Unlike low-level SynchronizationListener, when you use TerminalListener, the SDK will remove race conditions and most
* events duplicates present on the transport layer. There is also a warranty that TeminalListener listener methods
* will be invoked in sequence. No new event will be delivered until previous event have finished processing.
* So that it is much easier to create trading applicaitions using TerminalListener, especially if the application is a
* complex one.
* Please note that some event listener methods can still receive event duplicates, so that they must be idempotent.
* The terminal lifecycle starts with onConnected event, followed by initial synchronization, followed by data updates.
* During initial synchronization the SDK will invoke the following methods in sequence: onSynchronizationStarted,
* onSymbolSpecificationUpdated (invoked both for new and updated symbol specifications, can be skipped if
* specifications data has not changed), onSymbolSpecificationRemoved, onQuote, onAccountInformationUpdated,
* onPositionsReplaced (can be skipped if position data has not changed), onPositionsSynchronized,
* onPendingOrdersReplaced (can be skipped if pending order data has not changed), onPendingOrdersSynchronized,
* onHistoryOrderAdded, onHistoryOrdersSynchronized, onDealAdded, onDealsSynchronized.
* Data update events are onPositionUpdated (invoked both for new and updated positions), onPositionRemoved,
* onPendingOrderUpdated (invoked both for new and updated pending orders), onPendingOrderCompleted,
* onHistoryOrderAdded, onDealAdded, onSymbolSpecificationUpdated (invoked both for new and updated symbol
* specifications), onSymbolSpecificationRemoved, onQuote, onCandle, onTick, onBook.
* There are also status events available such as onBrokerConnectionStatus, onDisconnected,
* onSubscriptionDowngraded.
*/ export { TerminalListener as default };
//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["<anon>"],"sourcesContent":["'use strict';\n\n/**\n * Defines interface for a terminal listener class. You can extend your trading application implementation from\n * this class.\n * Unlike low-level SynchronizationListener, when you use TerminalListener, the SDK will remove race conditions and most\n * events duplicates present on the transport layer. There is also a warranty that TeminalListener listener methods\n * will be invoked in sequence. No new event will be delivered until previous event have finished processing.\n * So that it is much easier to create trading applicaitions using TerminalListener, especially if the application is a\n * complex one.\n * Please note that some event listener methods can still receive event duplicates, so that they must be idempotent.\n * The terminal lifecycle starts with onConnected event, followed by initial synchronization, followed by data updates.\n * During initial synchronization the SDK will invoke the following methods in sequence: onSynchronizationStarted,\n * onSymbolSpecificationUpdated (invoked both for new and updated symbol specifications, can be skipped if\n * specifications data has not changed), onSymbolSpecificationRemoved, onQuote, onAccountInformationUpdated,\n * onPositionsReplaced (can be skipped if position data has not changed), onPositionsSynchronized,\n * onPendingOrdersReplaced (can be skipped if pending order data has not changed), onPendingOrdersSynchronized,\n * onHistoryOrderAdded, onHistoryOrdersSynchronized, onDealAdded, onDealsSynchronized.\n * Data update events are onPositionUpdated (invoked both for new and updated positions), onPositionRemoved,\n * onPendingOrderUpdated (invoked both for new and updated pending orders), onPendingOrderCompleted,\n * onHistoryOrderAdded, onDealAdded, onSymbolSpecificationUpdated (invoked both for new and updated symbol\n * specifications), onSymbolSpecificationRemoved, onQuote, onCandle, onTick, onBook.\n * There are also status events available such as onBrokerConnectionStatus, onDisconnected,\n * onSubscriptionDowngraded.\n */\nexport default class TerminalListener {\n\n  /**\n   * Returns MetaApiConnection instance\n   * @return {MetaApiConnection} MetaApiConnection instance\n   */\n  get connection() {\n    return this._connection;\n  }\n\n  /**\n   * Sets MetaApiConnection instance\n   * @param {MetaApiConnection} connection MetaApiConnection instance\n   */\n  set connection(connection) {\n    this._connection = connection;\n  }\n\n  /**\n   * Invoked when connection to MetaTrader terminal established\n   * @return {Promise} promise which resolves when the asynchronous event is processed\n   */\n  async onConnected() {}\n\n  /**\n   * Invoked when connection to MetaTrader terminal terminated\n   * @return {Promise} promise which resolves when the asynchronous event is processed\n   */\n  async onDisconnected() {}\n\n  /**\n   * Invoked when broker connection satus have changed\n   * @param {Boolean} connected is MetaTrader terminal is connected to broker\n   * @return {Promise} promise which resolves when the asynchronous event is processed\n   */\n  async onBrokerConnectionStatus(connected) {}\n\n  /**\n   * Invoked when MetaTrader terminal state synchronization is started\n   * @param {string} instanceIndex index of an account instance connected\n   * @param {string} specificationsHash specifications hash\n   * @param {string} positionsHash positions hash\n   * @param {string} ordersHash orders hash\n   * @param {string} synchronizationId synchronization id\n   * @return {Promise} promise which resolves when the asynchronous event is processed\n   */\n  onSynchronizationStarted(instanceIndex, specificationsHash, positionsHash, ordersHash, synchronizationId) {}\n\n  /**\n   * Invoked when MetaTrader account information is updated\n   * @param {MetatraderAccountInformation} accountInformation updated MetaTrader account information\n   * @return {Promise} promise which resolves when the asynchronous event is processed\n   */\n  async onAccountInformationUpdated(accountInformation) {}\n\n  /**\n   * Invoked when the positions are replaced as a result of initial terminal state synchronization. This method\n   * will be invoked only if server thinks the data was updated, otherwise invocation can be skipped\n   * @param {Array<MetatraderPosition>} positions updated array of positions\n   * @return {Promise} promise which resolves when the asynchronous event is processed\n   */\n  async onPositionsReplaced(positions) {}\n\n  /**\n   * Invoked when position synchronization fnished to indicate progress of an initial terminal state synchronization\n   * @return {Promise} promise which resolves when the asynchronous event is processed\n   */\n  async onPositionsSynchronized() {}\n\n  /**\n   * Invoked when MetaTrader position is updated\n   * @param {MetatraderPosition} position updated MetaTrader position\n   * @return {Promise} promise which resolves when the asynchronous event is processed\n   */\n  async onPositionUpdated(position) {}\n\n  /**\n   * Invoked when MetaTrader position is removed\n   * @param {String} positionId removed MetaTrader position id\n   * @return {Promise} promise which resolves when the asynchronous event is processed\n   */\n  async onPositionRemoved(positionId) {}\n\n  /**\n   * Invoked when the pending orders are replaced as a result of initial terminal state synchronization. This method\n   * will be invoked only if server thinks the data was updated, otherwise invocation can be skipped\n   * @param {Array<MetatraderOrder>} orders updated array of pending orders\n   * @return {Promise} promise which resolves when the asynchronous event is processed\n   */\n  async onPendingOrdersReplaced(orders) {}\n\n  /**\n   * Invoked when MetaTrader pending order is updated\n   * @param {MetatraderOrder} order updated MetaTrader pending order\n   * @return {Promise} promise which resolves when the asynchronous event is processed\n   */\n  async onPendingOrderUpdated(order) {}\n\n  /**\n   * Invoked when MetaTrader pending order is completed (executed or canceled)\n   * @param {String} orderId completed MetaTrader pending order id\n   * @return {Promise} promise which resolves when the asynchronous event is processed\n   */\n  async onPendingOrderCompleted(orderId) {}\n\n  /**\n   * Invoked when pending order synchronization fnished to indicate progress of an initial terminal state\n   * synchronization\n   * @return {Promise} promise which resolves when the asynchronous event is processed\n   */\n  async onPendingOrdersSynchronized() {}\n\n  /**\n   * Invoked when a new MetaTrader history order is added\n   * @param {MetatraderOrder} historyOrder new MetaTrader history order\n   * @return {Promise} promise which resolves when the asynchronous event is processed\n   */\n  async onHistoryOrderAdded(historyOrder) {}\n\n  /**\n   * Invoked when a synchronization of history orders on a MetaTrader account have finished to indicate progress of an\n   * initial terminal state synchronization\n   * @return {Promise} promise which resolves when the asynchronous event is processed\n   */\n  async onHistoryOrdersSynchronized() {}\n\n  /**\n   * Invoked when a new MetaTrader history deal is added\n   * @param {MetatraderDeal} deal new MetaTrader history deal\n   * @return {Promise} promise which resolves when the asynchronous event is processed\n   */\n  async onDealAdded(deal) {}\n\n  /**\n   * Invoked when a synchronization of history deals on a MetaTrader account have finished to indicate progress of an\n   * initial terminal state synchronization\n   * @return {Promise} promise which resolves when the asynchronous event is processed\n   */\n  async onDealsSynchronized() {}\n\n  /**\n   * Invoked when a symbol specification was updated\n   * @param {MetatraderSymbolSpecification} specification updated MetaTrader symbol specification\n   * @return {Promise} promise which resolves when the asynchronous event is processed\n   */\n  async onSymbolSpecificationUpdated(specification) {}\n\n  /**\n   * Invoked when a symbol specification was removed\n   * @param {String} symbol removed symbol\n   * @returns {Promise} promise which resolves when the asynchronous event is processed\n   */\n  async onSymbolSpecificationRemoved(symbol) {}\n\n  /**\n   * Invoked when a symbol price was updated\n   * @param {MetatraderSymbolPrice} quote updated MetaTrader symbol quote\n   * @return {Promise} promise which resolves when the asynchronous event is processed\n   */\n  async onQuote(quote) {}\n\n  /**\n   * Invoked when symbol candles were updated\n   * @param {MetatraderCandle} candle updated MetaTrader symbol candle\n   * @return {Promise} promise which resolves when the asynchronous event is processed\n   */\n  async onCandle(candles) {}\n\n  /**\n   * Invoked when symbol ticks were updated\n   * @param {MetatraderTick} tick updated MetaTrader symbol tick\n   * @return {Promise} promise which resolves when the asynchronous event is processed\n   */\n  async onTick(tick) {}\n\n  /**\n   * Invoked when order books were updated\n   * @param {MetatraderBook} book updated MetaTrader order book\n   * @return {Promise} promise which resolves when the asynchronous event is processed\n   */\n  async onBook(book) {}\n\n  /**\n   * Invoked when subscription downgrade has occurred\n   * @param {string} symbol symbol to update subscriptions for\n   * @param {Array<MarketDataSubscription>} updates array of market data subscription to update\n   * @param {Array<MarketDataUnsubscription>} unsubscriptions array of subscriptions to cancel\n   * @return {Promise} promise which resolves when the asynchronous event is processed\n   */\n  async onSubscriptionDowngraded(symbol, updates, unsubscriptions) {}\n\n}\n"],"names":["TerminalListener","connection","_connection","onConnected","onDisconnected","onBrokerConnectionStatus","connected","onSynchronizationStarted","instanceIndex","specificationsHash","positionsHash","ordersHash","synchronizationId","onAccountInformationUpdated","accountInformation","onPositionsReplaced","positions","onPositionsSynchronized","onPositionUpdated","position","onPositionRemoved","positionId","onPendingOrdersReplaced","orders","onPendingOrderUpdated","order","onPendingOrderCompleted","orderId","onPendingOrdersSynchronized","onHistoryOrderAdded","historyOrder","onHistoryOrdersSynchronized","onDealAdded","deal","onDealsSynchronized","onSymbolSpecificationUpdated","specification","onSymbolSpecificationRemoved","symbol","onQuote","quote","onCandle","candles","onTick","tick","onBook","book","onSubscriptionDowngraded","updates","unsubscriptions"],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAyBe,IAAA,AAAMA,mBAAN,MAAMA;IAEnB;;;GAGC,GACD,IAAIC,aAAa;QACf,OAAO,IAAI,CAACC,WAAW;IACzB;IAEA;;;GAGC,GACD,IAAID,WAAWA,UAAU,EAAE;QACzB,IAAI,CAACC,WAAW,GAAGD;IACrB;IAEA;;;GAGC,GACD,AAAME;eAAN,oBAAA,aAAqB;;IAErB;;;GAGC,GACD,AAAMC;eAAN,oBAAA,aAAwB;;IAExB;;;;GAIC,GACD,AAAMC,yBAAyBC,SAAS;eAAxC,oBAAA,aAA2C;;IAE3C;;;;;;;;GAQC,GACDC,yBAAyBC,aAAa,EAAEC,kBAAkB,EAAEC,aAAa,EAAEC,UAAU,EAAEC,iBAAiB,EAAE,CAAC;IAE3G;;;;GAIC,GACD,AAAMC,4BAA4BC,kBAAkB;eAApD,oBAAA,aAAuD;;IAEvD;;;;;GAKC,GACD,AAAMC,oBAAoBC,SAAS;eAAnC,oBAAA,aAAsC;;IAEtC;;;GAGC,GACD,AAAMC;eAAN,oBAAA,aAAiC;;IAEjC;;;;GAIC,GACD,AAAMC,kBAAkBC,QAAQ;eAAhC,oBAAA,aAAmC;;IAEnC;;;;GAIC,GACD,AAAMC,kBAAkBC,UAAU;eAAlC,oBAAA,aAAqC;;IAErC;;;;;GAKC,GACD,AAAMC,wBAAwBC,MAAM;eAApC,oBAAA,aAAuC;;IAEvC;;;;GAIC,GACD,AAAMC,sBAAsBC,KAAK;eAAjC,oBAAA,aAAoC;;IAEpC;;;;GAIC,GACD,AAAMC,wBAAwBC,OAAO;eAArC,oBAAA,aAAwC;;IAExC;;;;GAIC,GACD,AAAMC;eAAN,oBAAA,aAAqC;;IAErC;;;;GAIC,GACD,AAAMC,oBAAoBC,YAAY;eAAtC,oBAAA,aAAyC;;IAEzC;;;;GAIC,GACD,AAAMC;eAAN,oBAAA,aAAqC;;IAErC;;;;GAIC,GACD,AAAMC,YAAYC,IAAI;eAAtB,oBAAA,aAAyB;;IAEzB;;;;GAIC,GACD,AAAMC;eAAN,oBAAA,aAA6B;;IAE7B;;;;GAIC,GACD,AAAMC,6BAA6BC,aAAa;eAAhD,oBAAA,aAAmD;;IAEnD;;;;GAIC,GACD,AAAMC,6BAA6BC,MAAM;eAAzC,oBAAA,aAA4C;;IAE5C;;;;GAIC,GACD,AAAMC,QAAQC,KAAK;eAAnB,oBAAA,aAAsB;;IAEtB;;;;GAIC,GACD,AAAMC,SAASC,OAAO;eAAtB,oBAAA,aAAyB;;IAEzB;;;;GAIC,GACD,AAAMC,OAAOC,IAAI;eAAjB,oBAAA,aAAoB;;IAEpB;;;;GAIC,GACD,AAAMC,OAAOC,IAAI;eAAjB,oBAAA,aAAoB;;IAEpB;;;;;;GAMC,GACD,AAAMC,yBAAyBT,MAAM,EAAEU,OAAO,EAAEC,eAAe;eAA/D,oBAAA,aAAkE;;AAEpE;AAtNA;;;;;;;;;;;;;;;;;;;;;;CAsBC,GACD,SAAqBjD,8BA+LpB"}