bitcore-node-zcash/lib/node.js

'use strict';

var util = require('util');
var EventEmitter = require('events').EventEmitter;
var async = require('async');
var bitcore = require('bitcore');
var BufferUtil = bitcore.util.buffer;
var Networks = bitcore.Networks;
var _ = bitcore.deps._;
var $ = bitcore.util.preconditions;
var Block = bitcore.Block;
var Chain = require('./chain');
var index = require('./');
var log = index.log;
var Bus = require('./bus');
var BaseModule = require('./module');

function Node(config) {
  if(!(this instanceof Node)) {
    return new Node(config);
  }

  this.chain = null;
  this.network = null;

  this.modules = {};
  this._unloadedModules = [];

  // TODO type check the arguments of config.modules
  if (config.modules) {
    $.checkArgument(Array.isArray(config.modules));
    this._unloadedModules = config.modules;
  }

  $.checkState(config.datadir, 'Node config expects "datadir"');
  this.datadir = config.datadir;

  this._loadConfiguration(config);
  this._initialize();
}

util.inherits(Node, EventEmitter);

Node.prototype.openBus = function() {
  return new Bus({node: this});
};

Node.prototype.addModule = function(service) {
  var self = this;
  var mod = new service.module({
    node: this
  });

  $.checkState(
    mod instanceof BaseModule,
    'Unexpected module instance type for module:' + service.name
  );

  // include in loaded modules
  this.modules[service.name] = mod;

  // add API methods
  var methodData = mod.getAPIMethods();
  methodData.forEach(function(data) {
    var name = data[0];
    var instance = data[1];
    var method = data[2];

    if (self[name]) {
      throw new Error('Existing API method exists:' + name);
    } else {
      self[name] = function() {
        return method.apply(instance, arguments);
      };
    }
  });
};

Node.prototype.getAllAPIMethods = function() {
  var methods = [];
  for(var i in this.modules) {
    var mod = this.modules[i];
    methods = methods.concat(mod.getAPIMethods());
  }
  return methods;
};

Node.prototype.getAllPublishEvents = function() {
  var events = [];
  for (var i in this.modules) {
    var mod = this.modules[i];
    events = events.concat(mod.getPublishEvents());
  }
  return events;
};

Node.prototype._loadConfiguration = function(config) {
  this._loadNetwork(config);
  this._loadConsensus(config);
};

/**
 * This function will find the common ancestor between the current chain and a forked block,
 * by moving backwards from the forked block until it meets the current chain.
 * @param {Block} block - The new tip that forks the current chain.
 * @param {Function} done - A callback function that is called when complete.
 */
Node.prototype._syncBitcoindAncestor = function(block, done) {

  var self = this;

  // The current chain of hashes will likely already be available in a cache.
  self.chain.getHashes(self.chain.tip.hash, function(err, currentHashes) {
    if (err) {
      done(err);
    }

    // Create a hash map for faster lookups
    var currentHashesMap = {};
    var length = currentHashes.length;
    for (var i = 0; i < length; i++) {
      currentHashesMap[currentHashes[i]] = true;
    }

    // TODO: expose prevHash as a string from bitcore
    var ancestorHash = BufferUtil.reverse(block.header.prevHash).toString('hex');

    // We only need to go back until we meet the main chain for the forked block
    // and thus don't need to find the entire chain of hashes.

    while(ancestorHash && !currentHashesMap[ancestorHash]) {
      var blockIndex = self.modules.bitcoind.getBlockIndex(ancestorHash);
      ancestorHash = blockIndex ? blockIndex.prevHash : null;
    }

    // Hash map is no-longer needed, quickly let
    // scavenging garbage collection know to cleanup
    currentHashesMap = null;

    if (!ancestorHash) {
      return done(new Error('Unknown common ancestor.'));
    }

    done(null, ancestorHash);

  });
};

/**
 * This function will attempt to rewind the chain to the common ancestor
 * between the current chain and a forked block.
 * @param {Block} block - The new tip that forks the current chain.
 * @param {Function} done - A callback function that is called when complete.
 */
Node.prototype._syncBitcoindRewind = function(block, done) {

  var self = this;

  self._syncBitcoindAncestor(block, function(err, ancestorHash) {
    if (err) {
      return done(err);
    }
    // Rewind the chain to the common ancestor
    async.whilst(
      function() {
        // Wait until the tip equals the ancestor hash
        return self.chain.tip.hash !== ancestorHash;
      },
      function(removeDone) {

        var tip = self.chain.tip;

        // TODO: expose prevHash as a string from bitcore
        var prevHash = BufferUtil.reverse(tip.header.prevHash).toString('hex');

        self.getBlock(prevHash, function(err, previousTip) {
          if (err) {
            removeDone(err);
          }

          // Undo the related indexes for this block
          self.modules.db.disconnectBlock(tip, function(err) {
            if (err) {
              return removeDone(err);
            }

            // Set the new tip
            previousTip.__height = self.chain.tip.__height - 1;
            self.chain.tip = previousTip;
            self.chain.saveMetadata();
            self.chain.emit('removeblock', tip);
            removeDone();
          });

        });

      }, done
    );
  });
};

/**
 * This function will synchronize additional indexes for the chain based on
 * the current active chain in the bitcoin daemon. In the event that there is
 * a reorganization in the daemon, the chain will rewind to the last common
 * ancestor and then resume syncing.
 */
Node.prototype._syncBitcoind = function() {
  var self = this;

  if (self.bitcoindSyncing) {
    return;
  }

  if (!self.chain.tip) {
    return;
  }

  self.bitcoindSyncing = true;
  self.chain.lastSavedMetadataThreshold = 30000;

  var height;

  async.whilst(function() {
    height = self.chain.tip.__height;
    return height < self.modules.bitcoind.height && !self.stopping;
  }, function(done) {
    self.modules.bitcoind.getBlock(height + 1, function(err, blockBuffer) {
      if (err) {
        return done(err);
      }

      var block = Block.fromBuffer(blockBuffer);

      // TODO: expose prevHash as a string from bitcore
      var prevHash = BufferUtil.reverse(block.header.prevHash).toString('hex');

      if (prevHash === self.chain.tip.hash) {

        // This block appends to the current chain tip and we can
        // immediately add it to the chain and create indexes.

        // Populate height
        block.__height = self.chain.tip.__height + 1;

        // Update chain.cache.hashes
        self.chain.cache.hashes[block.hash] = prevHash;

        // Update chain.cache.chainHashes
        self.chain.getHashes(block.hash, function(err, hashes) {
          if (err) {
            return done(err);
          }
          // Create indexes
          self.modules.db.connectBlock(block, function(err) {
            if (err) {
              return done(err);
            }
            self.chain.tip = block;
            log.debug('Saving metadata');
            self.chain.saveMetadata();
            log.debug('Chain added block to main chain');
            self.chain.emit('addblock', block);
            setImmediate(done);
          });
        });

      } else {
        // This block doesn't progress the current tip, so we'll attempt
        // to rewind the chain to the common ancestor of the block and
        // then we can resume syncing.
        self._syncBitcoindRewind(block, done);

      }
    });
  }, function(err) {
    if (err) {
      Error.captureStackTrace(err);
      return self.emit('error', err);
    }

    if(self.stopping) {
      return;
    }

    self.bitcoindSyncing = false;
    self.chain.lastSavedMetadataThreshold = 0;

    // If bitcoind is completely synced
    if (self.modules.bitcoind.isSynced()) {
      self.emit('synced');
    }

  });

};

Node.prototype._loadNetwork = function(config) {
  if (config.network === 'testnet') {
    this.network = Networks.get('testnet');
  } else if (config.network === 'regtest') {
    Networks.remove(Networks.testnet);
    Networks.add({
      name: 'regtest',
      alias: 'regtest',
      pubkeyhash: 0x6f,
      privatekey: 0xef,
      scripthash: 0xc4,
      xpubkey: 0x043587cf,
      xprivkey: 0x04358394,
      networkMagic: 0xfabfb5da,
      port: 18444,
      dnsSeeds: [ ]
    });
    this.network = Networks.get('regtest');
  } else {
    this.network = Networks.get('livenet');
  }
  $.checkState(this.network, 'Unrecognized network');
};

Node.prototype._loadConsensus = function(config) {
  var options;
  if (!config) {
    options = {};
  } else {
    options = _.clone(config.consensus || {});
  }
  options.node = this;
  this.chain = new Chain(options);
};

Node.prototype._initialize = function() {
  var self = this;

  this._initializeChain();

  this.start(function(err) {
    if(err) {
      return self.emit('error', err);
    }
    self.emit('ready');
  });
};

Node.prototype._initializeChain = function() {

  var self = this;
  this.chain.on('ready', function() {
    log.info('Bitcoin Chain Ready');

    // Notify that there is a new tip
    self.modules.bitcoind.on('tip', function(height) {
      if(!self.stopping) {
        var percentage = self.modules.bitcoind.syncPercentage();
        log.info('Bitcoin Core Daemon New Height:', height, 'Percentage:', percentage);
        self._syncBitcoind();
      }
    });

  });
  this.chain.on('error', function(err) {
    Error.captureStackTrace(err);
    self.emit('error', err);
  });
};

Node.prototype.getServices = function() {
  var services = [
    {
      name: 'chain',
      dependencies: ['db']
    }
  ];

  services = services.concat(this._unloadedModules);

  return services;
};

Node.prototype.getServiceOrder = function() {

  var services = this.getServices();

  // organize data for sorting
  var names = [];
  var servicesByName = {};
  for (var i = 0; i < services.length; i++) {
    var service = services[i];
    names.push(service.name);
    servicesByName[service.name] = service;
  }

  var stackNames = {};
  var stack = [];

  function addToStack(names) {
    for(var i = 0; i < names.length; i++) {

      var name = names[i];
      var service = servicesByName[name];
      $.checkState(service, 'Required dependency "' + name + '" not available.');

      // first add the dependencies
      addToStack(service.dependencies);

      // add to the stack if it hasn't been added
      if(!stackNames[name]) {
        stack.push(service);
        stackNames[name] = true;
      }

    }
  }

  addToStack(names);

  return stack;
};

Node.prototype.start = function(callback) {
  var self = this;
  var servicesOrder = this.getServiceOrder();

  async.eachSeries(
    servicesOrder,
    function(service, next) {
      log.info('Starting ' + service.name);

      if (service.module) {
        self.addModule(service);
        self.modules[service.name].start(next);
      } else {
        // TODO: implement bitcoind, chain and db as modules
        self[service.name].start(next);
      }
    },
    callback
  );
};

Node.prototype.stop = function(callback) {
  log.info('Beginning shutdown');
  var self = this;
  var services = this.getServiceOrder().reverse();

  this.stopping = true;
  this.emit('stopping');

  async.eachSeries(
    services,
    function(service, next) {
      log.info('Stopping ' + service.name);
      if (service.module) {
        self.modules[service.name].stop(next);
      } else {
        self[service.name].stop(next);
      }
    },
    callback
  );
};

module.exports = Node;