Adds Neutrino Client

bin/bcoin

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

bin/bcoin-cli

@@ -129,6 +129,22 @@ class CLI {
     this.log(filter);
   }
 
+  async getFilterHeader() {
+    let hash = this.config.str(0, '');
+
+    if (hash.length !== 64)
+      hash = parseInt(hash, 10);
+
+    const filterHeader = await this.client.getFilterHeader(hash);
+
+    if (!filterHeader) {
+      this.log('Filter header not found.');
+      return;
+    }
+
+    this.log(filterHeader);
+  }
+
   async estimateFee() {
     const blocks = this.config.uint(0, 1);
 
@@ -246,6 +262,9 @@ class CLI {
       case 'filter':
         await this.getFilter();
         break;
+      case 'filterheader':
+        await this.getFilterHeader();
+        break;
       case 'fee':
         await this.estimateFee();
         break;
@@ -263,6 +282,7 @@ class CLI {
         this.log('  $ coin [hash+index/address]: View coins.');
         this.log('  $ fee [target]: Estimate smart fee.');
         this.log('  $ filter [hash/height]: View filter.');
+        this.log('  $ filterheader [hash/height]: View filter header.');
         this.log('  $ header [hash/height]: View block header.');
         this.log('  $ info: Get server info.');
         this.log('  $ mempool: Get mempool snapshot.');

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');
 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');
 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/blockchain/chain.js

@@ -64,6 +64,8 @@ class Chain extends AsyncEmitter {
 
     this.orphanMap = new BufferMap();
     this.orphanPrev = new BufferMap();
+
+    this.getPrunedMap = new BufferMap();
   }
 
   /**
@@ -1368,7 +1370,17 @@ class Chain extends AsyncEmitter {
     }
 
     // Do we already have this block?
-    if (await this.hasEntry(hash)) {
+    const existingEntry = await this.getEntry(hash);
+
+    if (existingEntry && this.getPrunedMap.has(hash)) {
+      block = block.toBlock();
+      await this.db.updateNeutrinoSave();
+      await this.db.save(existingEntry, block, new CoinView());
+      await this.db.updateNeutrinoSave();
+      return existingEntry;
+    }
+
+    if (existingEntry) {
       this.logger.debug('Already have block: %h.', block.hash());
       throw new VerifyError(block, 'duplicate', 'duplicate', 0);
     }
@@ -1791,6 +1803,24 @@ class Chain extends AsyncEmitter {
     return this.hasEntry(hash);
   }
 
+  async getCFHeaderHeight() {
+    return await this.db.getCFHeaderHeight();
+  }
+
+  async saveCFHeaderHeight(height) {
+    this.db.neutrinoState.headerHeight = height;
+    await this.db.saveNeutrinoState();
+  }
+
+  async getCFilterHeight() {
+    return await this.db.getCFilterHeight();
+  }
+
+  async saveCFilterHeight(height) {
+    this.db.neutrinoState.filterHeight = height;
+    await this.db.saveNeutrinoState();
+  }
+
   /**
    * Find the corresponding block entry by hash or height.
    * @param {Hash|Number} hash/height
@@ -1925,6 +1955,33 @@ class Chain extends AsyncEmitter {
     return this.db.getBlock(hash);
   }
 
+  async getBlockPeer(hash) {
+    let block = await this.db.getBlock(hash);
+    if (block) {
+      const entry = await this.getEntry(hash);
+      assert(entry.hash.equals(hash));
+      return block;
+    } else {
+      this.logger.warning('Block not found, attempting to download');
+
+      // Ensure hash not height
+      hash = await this.db.getHash(hash);
+
+      const wait = new Promise((resolve, reject) => {
+        this.getPrunedMap.set(hash, resolve);
+      });
+
+      await this.emitAsync('getprunedblock', hash);
+      await wait;
+      block = await this.db.getBlock(hash);
+      const entry = await this.getEntry(hash);
+      assert(entry.hash.equals(hash));
+
+      this.emit('getblockpeer', entry, block);
+      return block;
+    }
+  }
+
   /**
    * Retrieve a block from the database (not filled with coins).
    * @param {Hash} block
@@ -2003,19 +2060,22 @@ class Chain extends AsyncEmitter {
     if (this.synced)
       return;
 
+    if (this.options.neutrino && this.getProgress() < 1)
+      return;
     if (this.options.checkpoints) {
       if (this.height < this.network.lastCheckpoint)
         return;
-    }
-
-    if (this.tip.time < util.now() - this.network.block.maxTipAge)
+    } else if (!this.options.neutrino &&
+      this.tip.time < util.now() - this.network.block.maxTipAge)
       return;
 
     if (!this.hasChainwork())
       return;
-
     this.synced = true;
-    this.emit('full');
+    if (this.options.neutrino)
+      this.emit('headersFull');
+    else
+      this.emit('full');
   }
 
   /**
@@ -2616,6 +2676,7 @@ class ChainOptions {
     this.compression = true;
 
     this.spv = false;
+    this.neutrino = false;
     this.bip91 = false;
     this.bip148 = false;
     this.prune = false;
@@ -2662,6 +2723,11 @@ class ChainOptions {
       this.spv = options.spv;
     }
 
+    if (options.neutrino != null) {
+      assert(typeof options.neutrino === 'boolean');
+      this.neutrino = options.neutrino;
+    }
+
     if (options.prefix != null) {
       assert(typeof options.prefix === 'string');
       this.prefix = options.prefix;

lib/blockchain/chaindb.js

@@ -46,6 +46,8 @@ class ChainDB {
     this.state = new ChainState();
     this.pending = null;
     this.current = null;
+    this.neutrinoState = null;
+    this.neutrinoSave = false;
 
     this.cacheHash = new LRU(this.options.entryCache, null, BufferMap);
     this.cacheHeight = new LRU(this.options.entryCache);
@@ -90,6 +92,11 @@ class ChainDB {
       this.logger.info('ChainDB successfully initialized.');
     }
 
+    if (this.options.neutrino) {
+      if (!this.neutrinoState)
+        this.neutrinoState = await this.getNeutrinoState();
+    }
+
     this.logger.info(
       'Chain State: hash=%h tx=%d coin=%d value=%s.',
       this.state.tip,
@@ -1001,7 +1008,7 @@ class ChainDB {
    */
 
   async getRawBlock(block) {
-    if (this.options.spv)
+    if (this.options.spv && !this.options.neutrino)
       return null;
 
     const hash = await this.getHash(block);
@@ -1150,6 +1157,14 @@ class ChainDB {
    * @returns {Promise}
    */
 
+  async updateNeutrinoSave () {
+    if (this.neutrinoSave) {
+      this.neutrinoSave = false;
+    } else {
+      this.neutrinoSave = true;
+    }
+  }
+
   async save(entry, block, view) {
     this.start();
     try {
@@ -1478,7 +1493,7 @@ class ChainDB {
   async saveBlock(entry, block, view) {
     const hash = block.hash();
 
-    if (this.options.spv)
+    if (this.options.spv && !this.neutrinoSave)
       return;
 
     // Write actual block data.
@@ -1670,6 +1685,39 @@ class ChainDB {
     b.put(layout.O.encode(), flags.toRaw());
     return b.write();
   }
+
+  /**
+   * Get Neutrino State
+   * @returns {Promise<NeutrinoState>} - Returns neutrino state
+   */
+
+  async getNeutrinoState() {
+    const data = await this.db.get(layout.N.encode());
+    if (!data)
+      return new NeutrinoState();
+    return NeutrinoState.fromRaw(data);
+  }
+
+  async getCFHeaderHeight() {
+    const state = await this.getNeutrinoState();
+    return state.headerHeight;
+  }
+
+  async getCFilterHeight() {
+    const state = await this.getNeutrinoState();
+    return state.filterHeight;
+  }
+
+  /**
+   * Save Neutrino State
+   * @returns {void}
+   */
+  async saveNeutrinoState() {
+    const state = this.neutrinoState.toRaw();
+    const b = this.db.batch();
+    b.put(layout.N.encode(), state);
+    return b.write();
+  }
 }
 
 /**
@@ -1952,6 +2000,28 @@ function fromU32(num) {
   return data;
 }
 
+class NeutrinoState {
+  constructor() { // TODO: do we add support for multiple filters?
+    this.headerHeight = 0;
+    this.filterHeight = 0;
+  }
+
+  toRaw() {
+    const bw = bio.write(8);
+    bw.writeU32(this.headerHeight);
+    bw.writeU32(this.filterHeight);
+    return bw.render();
+  }
+
+  static fromRaw(data) {
+    const state = new NeutrinoState();
+    const br = bio.read(data);
+    state.headerHeight = br.readU32();
+    state.filterHeight = br.readU32();
+    return state;
+  }
+}
+
 /*
  * Expose
  */

lib/blockchain/layout.js

@@ -14,6 +14,7 @@ const bdb = require('bdb');
  *   O -> chain options
  *   R -> tip hash
  *   D -> versionbits deployments
+ *   N -> neutrino state
  *   e[hash] -> entry
  *   h[hash] -> height
  *   H[height] -> hash
@@ -33,6 +34,8 @@ const layout = {
   O: bdb.key('O'),
   R: bdb.key('R'),
   D: bdb.key('D'),
+  N: bdb.key('N'),
+  F: bdb.key('H', ['hash256']),
   e: bdb.key('e', ['hash256']),
   h: bdb.key('h', ['hash256']),
   H: bdb.key('H', ['uint32']),