Neutrino: Sync

bin/bcoin

@@ -43,7 +43,10 @@ for arg in "$@"; do
     --daemon)
       daemon=1
     ;;
-    --spv)
+   --neutrino)
+      cmd='neutrino'
+    ;;
+   --spv)
       cmd='spvnode'
     ;;
   esac

bin/neutrino

@@ -0,0 +1,43 @@
+#!/usr/bin/env node
+
+'use strict';
+
+console.log('Starting bcoin');
+process.title = 'bcoin';
+const Neutrino = require('../lib/node/neutrino');
+
+const node = new Neutrino({
+  file: true,
+  argv: true,
+  env: true,
+  logFile: true,
+  logConsole: true, // todo: remove
+  logLevel: 'debug', // todo: remove
+  db: 'leveldb',
+  memory: false,
+  workers: true,
+  loader: require
+});
+
+if (!node.config.bool('no-wallet') && !node.has('walletdb')) {
+  const plugin = require('../lib/wallet/plugin');
+  node.use(plugin);
+}
+
+(async () => {
+  await node.ensure();
+  await node.open();
+  await node.connect();
+  node.startSync();
+})().catch((err) => {
+  console.error(err.stack);
+  process.exit(1);
+});
+
+process.on('unhandledRejection', (err, promise) => {
+  throw err;
+});
+
+process.on('SIGINT', async () => {
+  await node.close();
+});

lib/bcoin-browser.js

@@ -89,6 +89,7 @@
 bcoin.Node = require('./node/node');
 bcoin.FullNode = require('./node/fullnode');
 bcoin.SPVNode = require('./node/spvnode');
+bcoin.Neutrino = require('./node/neutrino');
 
 // Primitives
 bcoin.primitives = require('./primitives');

lib/bcoin.js

@@ -123,6 +123,7 @@
 bcoin.define('Node', './node/node');
 bcoin.define('FullNode', './node/fullnode');
 bcoin.define('SPVNode', './node/spvnode');
+bcoin.define('Neutrino', './node/neutrino');
 
 // Primitives
 bcoin.define('primitives', './primitives');

lib/client/node.js

@@ -164,9 +164,13 @@
    * @returns {Promise}
    */
 
-  getFilter(filter) {
-    assert(typeof filter === 'string' || typeof filter === 'number');
-    return this.get(`/filter/${filter}`);
+  getFilter(block) {
+    assert(typeof block === 'string' || typeof block === 'number');
+    return this.get(`/filter/${block}`);
+  }
+
+  getBlockPeer(hash) {
+    return this.call('get block peer', hash);
   }
 
   /**

lib/indexer/filterindexer.js

@@ -85,6 +85,31 @@ class FilterIndexer extends Indexer {
     this.put(layout.f.encode(hash), gcsFilter.hash());
   }
 
+   /**
+   * Save filter
+   * @param {Hash} blockHash
+   * @param {BasicFilter} basicFilter
+   * @param {Hash} filterHeader
+   * @returns {Promise}
+   */
+
+   async saveFilter(blockHash, blockHeight, basicFilter, filterHeader) {
+    assert(blockHash);
+    assert(blockHeight);
+    assert(basicFilter);
+    assert(filterHeader);
+
+    const filter = new Filter();
+    filter.filter = basicFilter.toRaw();
+    filter.header = filterHeader;
+
+    this.batch = this.db.batch();
+
+    await this.blocks.writeFilter(blockHash, filter.toRaw(), this.filterType);
+    this.put(layout.f.encode(blockHash), basicFilter.hash());
+    await super.syncHeight(blockHash, blockHeight);
+   }
+
   /**
    * Prune compact filters.
    * @private

lib/indexer/indexer.js

@@ -50,6 +50,8 @@ class Indexer extends EventEmitter {
     this.blocks = this.options.blocks;
     this.chain = this.options.chain;
 
+    this.neutrino = this.options.neutrino;
+
     this.closing = false;
     this.db = null;
     this.batch = null;
@@ -196,6 +198,13 @@ class Indexer extends EventEmitter {
     this.height = 0;
   }
 
+  async syncHeight(hash, height) {
+    const meta = new BlockMeta(hash, height);
+    await this._setTip(meta);
+    await this.commit();
+    this.height = height;
+  }
+
   /**
    * Bind to chain events and save listeners for removal on close
    * @private
@@ -292,6 +301,11 @@ class Indexer extends EventEmitter {
    */
 
   async _syncBlock(meta, block, view) {
+    if (this.neutrino) {
+      if (!this.batch)
+        this.start();
+      return true;
+    }
     // In the case that the next block is being
     // connected or the current block disconnected
     // use the block and view being passed directly,
@@ -636,6 +650,8 @@ class IndexOptions {
     this.cacheSize = 16 << 20;
     this.compression = true;
 
+    this.neutrino = false;
+
     if (options)
       this.fromOptions(options);
   }
@@ -697,6 +713,11 @@ class IndexOptions {
       this.compression = options.compression;
     }
 
+    if (options.neutrino != null) {
+      assert(typeof options.neutrino === 'boolean');
+      this.neutrino = options.neutrino;
+    }
+
     return this;
   }
 

lib/net/netaddress.js

@@ -478,7 +478,8 @@ class NetAddress {
 NetAddress.DEFAULT_SERVICES = 0
   | common.services.NETWORK
   | common.services.WITNESS
-  | common.services.BLOOM;
+  | common.services.BLOOM
+  | common.services.NODE_COMPACT_FILTERS;
 
 /*
  * Expose

lib/net/peer.js

@@ -1009,6 +1009,12 @@
       case packetTypes.GETHEADERS:
         this.request(packetTypes.HEADERS, timeout * 2);
         break;
+      case packetTypes.GETCFHEADERS:
+        this.request(packetTypes.CFHEADERS, timeout);
+        break;
+      case packetTypes.GETCFILTERS:
+        this.request(packetTypes.CFILTER, timeout);
+        break;
       case packetTypes.GETDATA:
         this.request(packetTypes.DATA, timeout * 2);
         break;
@@ -1449,6 +1455,12 @@
       if (!(this.services & services.NETWORK))
         throw new Error('Peer does not support network services.');
 
+      if (this.options.neutrino) {
+        if (!(this.services & services.NODE_COMPACT_FILTERS)) {
+          throw new Error('Peer does not support Compact Filters.');
+        }
+      }
+
       if (this.options.headers) {
         if (this.version < common.HEADERS_VERSION)
           throw new Error('Peer does not support getheaders.');
@@ -1668,6 +1680,11 @@
     this.compactWitness = packet.version === 2;
   }
 
+  sendSendHeaders() {
+    const packet = new packets.SendHeadersPacket();
+    this.send(packet);
+  }
+
   /**
    * Send `getheaders` to peer. Note that unlike
    * `getblocks`, `getheaders` can have a null locator.
@@ -1745,6 +1762,26 @@
     this.send(packet);
   }
 
+  /**
+   * @param {Number} filterType - `0` = basic
+   * @param {Number} startHeight - Height to start at.
+   * @param {Hash} stopHash - Hash to stop at.
+   * @returns {void}
+   * @description Send `getcfilters` to peer.
+   */
+  sendGetCFilters(filterType, startHeight, stopHash) {
+    const packet = new packets.GetCFiltersPacket(
+      filterType,
+      startHeight,
+      stopHash);
+
+    this.logger.debug(
+      'Sending getcfilters (type=%d, startHeight=%d, stopHash=%h).',
+      filterType, startHeight, stopHash);
+
+    this.send(packet);
+  }
+
   /**
    * Send `cfheaders` to peer.
    * @param {Number} filterType
@@ -1767,6 +1804,27 @@
     this.send(packet);
   }
 
+  /**
+   * @param {Number} filterType
+   * @param {Number} startHeight
+   * @param {Hash} stopHash
+   * @returns {void}
+   * @description Send `getcfheaders` to peer.
+   */
+
+  sendGetCFHeaders(filterType, startHeight, stopHash) {
+    const packet = new packets.GetCFHeadersPacket(
+      filterType,
+      startHeight,
+      stopHash);
+
+    this.logger.debug(
+      'Sending getcfheaders (type=%d, start=%h, stop=%h).',
+      filterType, startHeight, stopHash);
+
+    this.send(packet);
+  }
+
   /**
    * send `cfcheckpt` to peer.
    * @param {Number} filterType
@@ -2080,6 +2138,7 @@
     this.agent = common.USER_AGENT;
     this.noRelay = false;
     this.spv = false;
+    this.neutrino = false;
     this.compact = false;
     this.headers = false;
     this.banScore = common.BAN_SCORE;
@@ -2143,6 +2202,11 @@
       this.spv = options.spv;
     }
 
+    if (options.neutrino != null) {
+      assert(typeof options.neutrino === 'boolean');
+      this.neutrino = options.neutrino;
+    }
+
     if (options.compact != null) {
       assert(typeof options.compact === 'boolean');
       this.compact = options.compact;