crypto-nodes/bitstamp.js

const { TickerStream, OrderBookStream, LiveOrderStream, Bitstamp, CURRENCY } = require("node-bitstamp");

var per_second = 0;

var bitstamp_obj = {

  init_ws: function (node, symbols) {

  	var that = this;
  	console.log('INIT WS BUTSTAMP');

	this.OrderBookStream = new OrderBookStream();
	this.LiveOrderStream = new LiveOrderStream();

    for (x in symbols) {

    	function sub(symbol) {

    		console.log('SUB SYM ' + symbol);

    		var OrderBookTopic = that.OrderBookStream.subscribe(symbol);	
    		var LiveOrderTopic = that.LiveOrderStream.subscribe(symbol);

            that.LiveOrderStream.on(LiveOrderTopic, data => {

            	per_second++;

              data.snapshot = false;

				if(!symbol) { symbol = 'btcusd'; }

				node.send({
					payload: {
						exchange: 'bitstamp',
						fees: that.fees,
						sym_from: symbol.substr(0, 3).toUpperCase(),
						sym_to: symbol.substr(3, 3).toUpperCase(),
						data: data
					}
				});

            });
			
    		that.OrderBookStream.on(OrderBookTopic, data => {

	            per_second++;

              data.snapshot = true;

				if(!symbol) { symbol = 'btcusd'; }

				node.send({
					payload: {
						exchange: 'bitstamp',
						fees: that.fees,
						sym_from: symbol.substr(0, 3).toUpperCase(),
						sym_to: symbol.substr(3, 3).toUpperCase(),
						data: data
					}
				});

       		 });

    	}

    	sub(symbols[x]);

    }
  
  },
  fees: {},
  interval: false,
  connected: false,
  exchange_symbols: [],
  configured_symbols: [],
  enabled_symbols: [],
  get_exchange_symbols: function(callback) {
	
  	callback({
			BTC_USD: "",
			BCH_USD: "bchusd",
			BCH_EUR: "bcheur",
			BCH_BTC: "bchbtc",
			BTC_EUR: "btceur",
			EUR_USD: "eurusd",
			XRP_USD: "xrpusd",
			XRP_EUR: "xrpeur",
			XRP_BTC: "xrpbtc",
			LTC_USD: "ltcusd",
			LTC_EUR: "ltceur",
			LTC_BTC: "ltcbtc",
			ETH_USD: "ethusd",
			ETH_EUR: "etheur",
			ETH_BTC: "ethbtc"
	});

  },
  get_enabled_symbols: function() {

    var out = [];

    for(x in this.exchange_symbols) {

      var pass = false;

      var exc_tmp = x.split('_');

      for(y in this.configured_symbols) {

        var cfg_tmp = this.configured_symbols[y].split('/');

        // If its matching or inverted variant matches its enabled symbol
        if((exc_tmp[0] == cfg_tmp[0] && exc_tmp[1] == cfg_tmp[1]) || 
           (exc_tmp[0] == cfg_tmp[1] && exc_tmp[1] == cfg_tmp[0])
          ) {

          pass = true;

        }

      }

      if(pass) {

        out.push(this.exchange_symbols[x]);

      }

    }

    return out;

  },
  init: function(config, node, symbols, callback) {

      var that = this;

      this.configured_symbols = symbols;
      console.log(symbols);
      try { this.fees = JSON.parse(config.fees); } catch (e) {}
      
      if (!this.interval) {
        this.interval = setInterval(function() {

            var color = per_second > 0 ? 'green' : 'red';
            node.status({ fill: color, shape: 'ring', text: per_second + ' requests per second' });
            per_second = 0;

        }, 1000);
      }

      this.get_exchange_symbols(function (exchange_symbols) {

          that.exchange_symbols = exchange_symbols;
          var enabled_symbols = that.get_enabled_symbols();
          that.init_ws(node, enabled_symbols);

      });

  },

}

module.exports = function(RED) {

    function Bitstamp(config) {
       
        RED.nodes.createNode(this, config);
        var node = this;

        node.on('input', function(msg) {

          if(config.disabled) {

            // Disable UI Updates
            if(bitstamp_obj.interval) {
              clearInterval(bitstamp_obj.interval);
            }

            // Set node status
            node.status({ fill: 'red',shape:'ring', text: 'Disabled' });

            // Emit flush orderbook
            node.send({payload: { exchange: 'bitstamp', op: 'flush' }});

            return;
            
          }

        	if(msg.payload && msg.payload.op == 'subscribe') {
        		bitstamp_obj.init(config, node, msg.payload.symbols);
	       	}
        });

        node.on('close', function() {
          // tidy up any async code here - shutdown connections and so on.
          node.status({ fill: 'red',shape:'ring', text: 'Offline' });
          node.send({payload: { exchange: 'bitstamp', op: 'flush' }});
          bitstamp_obj.OrderBookStream.close();
          bitstamp_obj.LiveOrderStream.close();
        });

    }
    RED.nodes.registerType("Bitstamp", Bitstamp);

}