bluebot/web/routes/startBlueBot.js

A bitcoin trading bot for auto trading at various exchanges

const _ = require('lodash');
const promisify = require('tiny-promisify');
const moment = require('moment');

const pipelineRunner = promisify(require('../../core/workers/pipeline/parent'));
const cache = require('../state/cache');
const Logger = require('../state/logger');
const broadcast = cache.get('broadcast');
const apiKeyManager= cache.get('apiKeyManager');
const bluebotManager = cache.get('bluebots');

const base = require('./baseConfig');

// starts an import
// requires a post body with a config object
module.exports = function *() {
  const mode = this.request.body.mode;

  let config = {};

  _.merge(config, base, this.request.body);

  // Attach API keys
  if(config.trader && config.trader.enabled) {

    const keys = apiKeyManager._getApiKeyPair(config.watch.exchange);

    if(!keys) {
      this.body = 'No API keys found for this exchange.';
      return;
    }

    _.merge(
      config.trader,
      keys
    );
  }

  // set type
  if(mode === 'realtime') {
    if(config.market && config.market.type)
      var type = config.market.type;
    else
      var type = 'watcher';
  } else {
    var type = '';
  }

  const id = (Math.random() + '').slice(3);

  let errored = false;

  var logType = type;
  if(logType === 'leech') {
    if(config.trader && config.trader.enabled)
      logType = 'tradebot';
    else
      logType = 'papertrader';
  }
  const logger = new Logger(logType);

  console.log('BlueBot', id, 'started');

  const child = pipelineRunner(mode, config, (err, event) => {

    if(err) {
      if(errored)
        return;

      let deleted = bluebotManager.delete(id);

      if(!deleted)
        // it was already deleted
        return;

      errored = true;
      console.error('RECEIVED ERROR IN GEKKO', id);
      console.error(err);
      return broadcast({
        type: 'bluebot_error',
        bluebot_id: id,
        error: err
      });
    }

    if(!event)
      return;

    if(event.type === 'trade') {
      let trade = event.trade;
      bluebotManager.push(id, 'trades', trade);
      let wsEvent = {
        type: 'trade',
        bluebot_id: id,
        bluebot_mode: mode,
        bluebot_type: type,
        emitter: 'bluebot',
        trade
      }
      broadcast(wsEvent);
      return;
    } else if(event.type === 'roundtrip') {
      let roundtrip = event.roundtrip;
      bluebotManager.push(id, 'roundtrips', roundtrip);
      let wsEvent = {
        type: 'roundtrip',
        bluebot_id: id,
        bluebot_mode: mode,
        bluebot_type: type,
        emitter: 'bluebot',
        roundtrip
      }
      broadcast(wsEvent);
      return;
    } else if(event.log) {
      logger.write(event.log);
    }

    let updates = {};


    if(event.type === 'update') {
      updates.latest = event.latest;
    }  else {
      // all possible events can be found in
      // @file bluebot/core/cp.js
      updates[event.type] = event[event.type];
    }


    bluebotManager.update(id, updates);
    // emit update over ws
    let wsEvent = {
      type: event.type,
      bluebot_id: id,
      bluebot_mode: mode,
      bluebot_type: type,
      emitter: 'bluebot',
      updates
    }
    broadcast(wsEvent);
  });

  const now = moment.utc().format();

  var bluebot = {
    watch: config.watch,
    id,
    startAt: '',
    latest: '',
    mode,
    type
  }

  if(config.tradingAdvisor && config.tradingAdvisor.enabled) {
    bluebot.strat = {
      name: config.tradingAdvisor.method,
      tradingAdvisor: config.tradingAdvisor,
      params: config[ config.tradingAdvisor.method ]
    };

    bluebot.trades = [];
    bluebot.roundtrips = [];

    if(config.trader && config.trader.enabled)
      bluebot.trader = 'tradebot';
    else
      bluebot.trader = 'paper trader';
  }

  bluebotManager.add(bluebot);

  broadcast({
    type: 'new_bluebot',
    bluebot
  });

  this.body = bluebot;
}