[GB] init real trader trigger glue

exchange/gekkoBroker.js

@@ -14,10 +14,13 @@ const errors = require('./exchangeErrors');
 const Portfolio = require('./portfolioManager');
 // const Market = require('./market');
 const orders = require('./orders');
+const Trigger = require('./trigger');
 const exchangeUtils = require('./exchangeUtils');
 const bindAll = exchangeUtils.bindAll;
 const isValidOrder = exchangeUtils.isValidOrder;
 
+
+
 class Broker {
   constructor(config) {
     this.config = config;
@@ -157,6 +160,15 @@ class Broker {
 
     return order;
   }
+
+  createTrigger({type, onTrigger, props}) {
+    return new Trigger({
+      api: this.api,
+      type,
+      props,
+      onTrigger
+    });
+  }
 }
 
 module.exports = Broker;

exchange/trigger.js

@@ -0,0 +1,84 @@
+// wraps around a low level trigger and feeds
+// it live market data.
+
+const _ = require('lodash');
+
+const exchangeUtils = require('./exchangeUtils');
+const bindAll = exchangeUtils.bindAll;
+
+const triggers = require('./triggers');
+
+// @param api: a gekko broker wrapper instance
+// @param type: type of trigger to wrap
+// @param props: properties to feed to trigger
+class Trigger {
+  constructor({api, type, props, onTrigger}) {
+    this.onTrigger = onTrigger;
+    this.api = api;
+    this.props = props;
+    this.type = type;
+
+    this.isLive = true;
+
+    // note: we stay on the safe side and trigger
+    // as soon as the bid goes below trail.
+    this.tickerProp = 'bid';
+
+    if(!_.has(triggers, type)) {
+      throw new Error('Gekko Broker does not know trigger ' + type);
+    }
+
+    this.CHECK_INTERVAL = this.api.interval * 10;
+
+    bindAll(this);
+
+    this.api.getTicker(this.init);
+  }
+
+  init(err, ticker) {
+    if(err) {
+      return console.log('[GB/trigger] failed to init ticker:', err);
+    }
+
+    this.trigger = new triggers[this.type]({
+      initialPrice: ticker[this.tickerProp],
+      onTrigger: this.propogateTrigger,
+      ...this.props
+    })
+
+    this.scheduleFetch();
+  }
+
+  scheduleFetch() {
+    setTimeout(this.fetch, this.CHECK_INTERVAL);
+  }
+
+  fetch() {
+    if(!this.isLive) {
+      return;
+    }
+    this.api.getTicker(this.processTicker)
+  }
+
+  processTicker(err, ticker) {
+    if(!this.isLive) {
+      return;
+    }
+
+    if(err) {
+      return console.log('[GB/trigger] failed to fetch ticker:', err);
+    }
+
+    this.price = ticker[this.tickerProp];
+
+    this.trigger.updatePrice(this.price);
+    this.scheduleFetch();
+  }
+
+  propogateTrigger() {
+    this.isLive = false;
+    this.onTrigger();
+  }
+}
+
+module.exports = Trigger;

exchange/triggers/index.js

@@ -0,0 +1,3 @@
+const trailingStop = require('./trailingStop');
+
+module.exports = { trailingStop };

plugins/paperTrader/paperTrader.js

@@ -182,12 +182,7 @@ PaperTrader.prototype.processAdvice = function(advice) {
 PaperTrader.prototype.createTrigger = function(advice) {
   const trigger = advice.trigger;
 
-  if(trigger.type === 'trailingStop') {
-
-    if(trigger.trailPercentage && !trigger.trailValue) {
-      trigger.trailValue = trigger.trailPercentage / 100 * this.price;
-      log.info('[PaperTrader] Trailing stop trail value specified as percentage, setting to:', trigger.trailValue, this.currency);
-    }
+  if(trigger && trigger.type === 'trailingStop') {
 
     if(!trigger.trailValue) {
       return log.warn(`[Papertrader] ignoring trailing stop without trail value`);

plugins/trader/trader.js

@@ -5,7 +5,7 @@ const dirs = util.dirs();
 const moment = require('moment');
 
 const log = require(dirs.core + 'log');
-const Broker = require(dirs.gekko + '/exchange/gekkoBroker');
+const Broker = require(dirs.broker + '/gekkoBroker');
 
 require(dirs.gekko + '/exchange/dependencyCheck');
 
@@ -20,6 +20,7 @@ const Trader = function(next) {
   }
 
   this.propogatedTrades = 0;
+  this.propogatedTriggers = 0;
 
   try {
     this.broker = new Broker(this.brokerConfig);
@@ -180,6 +181,34 @@ Trader.prototype.processAdvice = function(advice) {
       });
     }
 
+    const trigger = advice.trigger;
+
+    if(trigger && trigger.type === 'trailingStop') {
+      const triggerId = 'trigger-' + (++this.propogatedTriggers);
+
+      this.deferredEmit('triggerCreated', {
+        id: triggerId,
+        at: advice.date,
+        initialPrice: this.price,
+        type: 'trialingStop',
+        proprties: {
+          trail: trigger.trailValue
+        }
+      });
+
+      this.activeStopTrigger = {
+        id: triggerId,
+        adviceId: advice.id,
+        instance: this.broker.createTrigger({
+          type: trigger.type,
+          onTrigger: this.onStopTrigger,
+          props: {
+            trail: trigger.trailValue,
+          }
+        })
+      }
+    }
+
     amount = this.portfolio.currency / this.price * 0.95;
 
     log.info(
@@ -202,6 +231,16 @@ Trader.prototype.processAdvice = function(advice) {
       });
     }
 
+    // clean up potential old stop trigger
+    if(this.activeStopTrigger) {
+      this.deferredEmit('triggerAborted', {
+        id: this.activeStopTrigger.id,
+        date: advice.date
+      });
+
+      delete this.activeStopTrigger;
+    }
+
     amount = this.portfolio.asset;
 
     log.info(
@@ -320,6 +359,22 @@ Trader.prototype.createOrder = function(side, amount, advice, id) {
   });
 }
 
+Trader.prototype.onStopTrigger = function() {
+  this.deferredEmit('triggerFired', {
+    id: this.activeStopTrigger.id,
+    date: moment()
+  });
+
+  const adviceMock = {
+    recommendation: 'short',
+    id: this.activeStopTrigger.adviceId
+  }
+
+  delete this.activeStopTrigger;
+
+  this.processAdvice(adviceMock);
+}
+
 Trader.prototype.cancelOrder = function(id, advice, next) {
 
   if(!this.order) {

plugins/tradingAdvisor/baseTradingMethod.js

@@ -231,8 +231,14 @@ Base.prototype.advice = function(newDirection) {
           'As such the stop is ignored'
         );
       } else {
+
         // the trigger is implemented in a trader
         trigger = newDirection.trigger;
+
+        if(trigger.trailPercentage && !trigger.trailValue) {
+          trigger.trailValue = (1 - (trigger.trailPercentage / 100)) * this.candle.close;
+          log.info('[StratRunner] Trailing stop trail value specified as percentage, setting to:', trigger.trailValue);
+        }
       }
     }