@dashevo/dash-spv 0.24.0-dev.6 → 0.25.0-dev.10

package/.ultra.cache.json

@@ -1 +1 @@
-{"files":{".eslintignore":"5772aab4a649e8c99c5b74bd685792cd6a69f9ac",".eslintrc.json":"41aa1d3c1477f203b588dcb5c0015454edd94481",".gitignore":"095d365a56f423d4fab2345c95c137e7c6ea45c0","LICENSE":"95bf3c7cb642fb61c1bbbb319fd3c83e47a5af96","README.md":"3659fd1bfb44b5e6916679ae586ccbff18683e59","config/config.js":"336469b011520eb7ac5b57a3dc439191f2ae3133","index.js":"fefb01f324a8ffbd9f9354c709e8e880eca6f261","lib/blockstore.js":"1ed82a8c1cfb4bc3aa96f0669a27c94d2e76b164","lib/consensus.js":"8ef5fefd0476056e108351de8edfbe8e60e89105","lib/merkleproofs.js":"dca09952c352109795af64f9490209a96e483e2f","lib/spvchain.js":"7f90590769100e132802042ca9f0982297ab242c","lib/utils.js":"c2119b88a67698053e783f09c038a04ae208f232","package.json":"965eab815953776b7a07aede2c73e31e31712864","test/data/headers.js":"eb9cae85ee11027338fbf1f69e373d22388286d6","test/data/merkleproofs.js":"49ea4c29fb1f0cf6378ed7ee46b0a1db3bb555c1","test/data/rawHeaders.js":"03fed6ca2f8c2d1b63cfa13743431a2d551c7ad9","test/index.js":"de1a2b779318fc1d8b66c843baf4e758b0bd805d"},"deps":{}}
+{"files":{".eslintignore":"5772aab4a649e8c99c5b74bd685792cd6a69f9ac",".eslintrc.json":"41aa1d3c1477f203b588dcb5c0015454edd94481",".gitignore":"095d365a56f423d4fab2345c95c137e7c6ea45c0","LICENSE":"95bf3c7cb642fb61c1bbbb319fd3c83e47a5af96","README.md":"3659fd1bfb44b5e6916679ae586ccbff18683e59","config/config.js":"267c3536b5fe54c88080a56241c34d7393a54ac2","index.js":"4413accedb71ffb73ea7ce4ad45a2035c2ce92ca","lib/blockstore.js":"1ed82a8c1cfb4bc3aa96f0669a27c94d2e76b164","lib/consensus.js":"73201c7fec9c62f5f87dba7b2d0d54c08fa4fa6f","lib/errors/SPVError.js":"08b7af972c146bcdf29ffaa06eb90ca2c5660914","lib/merkleproofs.js":"dca09952c352109795af64f9490209a96e483e2f","lib/spvchain.js":"dfb38386a8c0eb1fee0c64e1b1a950125811f6db","lib/utils.js":"c2119b88a67698053e783f09c038a04ae208f232","package.json":"f791420d0f5d19ff4e573545aa19578fd021bd95","test/data/headers.js":"eb9cae85ee11027338fbf1f69e373d22388286d6","test/data/merkleproofs.js":"49ea4c29fb1f0cf6378ed7ee46b0a1db3bb555c1","test/data/rawHeaders.js":"03fed6ca2f8c2d1b63cfa13743431a2d551c7ad9","test/index.js":"e937184e5ee21ba882e09fcd5e5f5228d9b7ef68","test/spvchain.js":"7e6c93b2e623a3ddb93e9f250133e83f28c882e2"},"deps":{}}

package/config/config.js

@@ -30,9 +30,9 @@ module.exports = {
       version: 1,
       previousblockhash: '0000000000000000000000000000000000000000000000000000000000000000',
       merkleroot: 'e0028eb9648db56b1ac77cf090b99048a8007e2bb64b68f092c03c7f56a662c7',
-      time: 1390666206,
-      bits: '1e0ffff0',
-      nonce: 3861367235,
+      time: 1417713337,
+      bits: '207fffff',
+      nonce: 1096447,
     });
   },
   getRegtestGenesis() {
@@ -40,12 +40,19 @@ module.exports = {
       version: 1,
       previousblockhash: '0000000000000000000000000000000000000000000000000000000000000000',
       merkleroot: 'e0028eb9648db56b1ac77cf090b99048a8007e2bb64b68f092c03c7f56a662c7',
-      time: 1390666206,
-      bits: '1e0ffff0',
-      nonce: 3861367235,
+      time: 1417713337,
+      bits: '207fffff',
+      nonce: 1096447,
     });
   },
   getLivenetGenesis() {
-    throw Error('Livenet genesis not yet implemented');
+    return utils.normalizeHeader({
+      version: 1,
+      previousblockhash: '0000000000000000000000000000000000000000000000000000000000000000',
+      merkleroot: 'e0028eb9648db56b1ac77cf090b99048a8007e2bb64b68f092c03c7f56a662c7',
+      time: 1390095618,
+      bits: '1e0ffff0',
+      nonce: 28917698,
+    });
   },
 };

package/index.js

@@ -1,7 +1,11 @@
 const spvChain = require('./lib/spvchain');
 const merkleProof = require('./lib/merkleproofs');
+const genesis = require('./config/config');
+const SPVError = require('./lib/errors/SPVError');
 
 module.exports = {
   SpvChain: spvChain,
   MerkleProof: merkleProof,
+  genesis,
+  SPVError,
 };

package/lib/consensus.js

@@ -1,43 +1,46 @@
-const { hasValidTarget } = require('@dashevo/dark-gravity-wave');
+// const { hasValidTarget } = require('@dashevo/dark-gravity-wave');
 const merkleProofs = require('./merkleproofs');
-const utils = require('./utils');
+// const utils = require('./utils');
 
-const MIN_TIMESTAMP_HEADERS = 11;
-const MIN_DGW_HEADERS = 24;
+// const MIN_TIMESTAMP_HEADERS = 11;
+// const MIN_DGW_HEADERS = 24;
 
-function getMedianTimestamp(headers) {
-  const timestamps = headers.map((h) => h.time);
-  const median = (arr) => {
-    const mid = Math.floor(arr.length / 2);
-    const nums = [...arr].sort((a, b) => a - b);
-    return arr.length % 2 !== 0 ? nums[mid] : (nums[mid - 1] + nums[mid]) / 2;
-  };
-  return median(timestamps);
-}
+// function getMedianTimestamp(headers) {
+//   const timestamps = headers.map((h) => h.time);
+//   const median = (arr) => {
+//     const mid = Math.floor(arr.length / 2);
+//     const nums = [...arr].sort((a, b) => a - b);
+//     return arr.length % 2 !== 0 ? nums[mid] : (nums[mid - 1] + nums[mid]) / 2;
+//   };
+//   return median(timestamps);
+// }
 
 // Must be strictly greater than the median time of the previous 11 blocks.
 // https://dash-docs.github.io/en/developer-reference#block-headers
-function hasGreaterThanMedianTimestamp(newHeader, previousHeaders) {
-  if (previousHeaders.length < MIN_TIMESTAMP_HEADERS) return true;
-  const headerNormalised = utils.normalizeHeader(newHeader);
-  const normalizedLatestHeaders = previousHeaders.slice(
-    Math.max(previousHeaders.length - MIN_TIMESTAMP_HEADERS, 0),
-  ).map((h) => utils.normalizeHeader(h));
-  return getMedianTimestamp(normalizedLatestHeaders) < headerNormalised.time;
-}
+// function hasGreaterThanMedianTimestamp(newHeader, previousHeaders) {
+//   if (previousHeaders.length < MIN_TIMESTAMP_HEADERS) return true;
+//   const headerNormalised = utils.normalizeHeader(newHeader);
+//   const normalizedLatestHeaders = previousHeaders.slice(
+//     Math.max(previousHeaders.length - MIN_TIMESTAMP_HEADERS, 0),
+//   ).map((h) => utils.normalizeHeader(h));
+//   return getMedianTimestamp(normalizedLatestHeaders) < headerNormalised.time;
+// }
 
-function isValidBlockHeader(newHeader, previousHeaders, network = 'mainnet') {
-  if (previousHeaders.length > MIN_DGW_HEADERS) {
-    return newHeader.validProofOfWork()
-      && newHeader.validTimestamp()
-      && hasGreaterThanMedianTimestamp(newHeader, previousHeaders)
-      && hasValidTarget(
-        utils.getDgwBlock(newHeader), previousHeaders.map((h) => utils.getDgwBlock(h)), network,
-      );
-  }
-  return newHeader.validProofOfWork()
-    && newHeader.validTimestamp()
-    && hasGreaterThanMedianTimestamp(newHeader, previousHeaders);
+function isValidBlockHeader(/* newHeader, previousHeaders, network = 'mainnet' */) {
+  // TODO: implement consensus checks properly for all networks
+  return true;
+  // if (previousHeaders.length > MIN_DGW_HEADERS) {
+  //   return newHeader.validProofOfWork()
+  //     && newHeader.validTimestamp()
+  //     && hasGreaterThanMedianTimestamp(newHeader, previousHeaders)
+  //     && hasValidTarget(
+  //       utils.getDgwBlock(newHeader), previousHeaders.map((h) => utils.getDgwBlock(h)), network,
+  //     );
+  // }
+  // // TODO: eventually this check start failing in dashmate
+  // return newHeader.validProofOfWork()
+  //   && newHeader.validTimestamp()
+  //   && hasGreaterThanMedianTimestamp(newHeader, previousHeaders);
 }
 
 /**

package/lib/errors/SPVError.js

@@ -0,0 +1,8 @@
+class SPVError extends Error {
+  constructor(message) {
+    super(message);
+    this.name = 'SPVError';
+  }
+}
+
+module.exports = SPVError;

package/lib/spvchain.js

@@ -1,17 +1,34 @@
-const BlockStore = require('./blockstore');
 const config = require('../config/config');
 const Consensus = require('./consensus');
 const utils = require('./utils');
+const SPVError = require('./errors/SPVError');
 
 const SpvChain = class {
-  constructor(chainType, confirms = 100, startBlock) {
-    this.root = null;
-    this.allBranches = [];
-    this.orphanBlocks = [];
-    this.orphanChunks = [];
+  // TODO: move chainType and confirms to `options`
+  constructor(chainType, confirms = 100, startBlock, startBlockHeight) {
     this.confirmsBeforeFinal = confirms;
+
+    this.reset(startBlockHeight);
     this.init(chainType, startBlock);
-    this.store = new BlockStore();
+
+    this.hashesByHeight = new Map([[this.startBlockHeight, this.root.hash]]);
+
+    this.heightByHash = new Map([[this.root.hash, this.startBlockHeight]]);
+
+    // TODO: legacy - remove this
+    this.orphanBlocks = [];
+  }
+
+  reset(fromBlockHeight = 0) {
+    this.root = null;
+    this.allBranches = [[]];
+    this.orphanChunks = [];
+    this.prunedHeaders = [];
+
+    this.hashesByHeight = new Map();
+    this.heightByHash = new Map();
+    this.orphansHashes = new Set();
+    this.startBlockHeight = fromBlockHeight < 0 ? 0 : fromBlockHeight;
   }
 
   init(chainType, startBlock) {
@@ -32,6 +49,7 @@ const SpvChain = class {
         }
         this.root = config.getDevnetGenesis();
         break;
+      case 'local':
       case 'regtest':
         this.network = 'regtest';
         if (startBlock) {
@@ -69,24 +87,62 @@ const SpvChain = class {
           this.root = startBlock;
           this.network = 'mainnet';
         } else {
-          throw new Error('Unhandled chaintype or startBlock not provided');
+          throw new SPVError('Unhandled chaintype or startBlock not provided');
         }
         break;
     }
-    this.root.children = [];
+    // this.root.children = [];
     this.setAllBranches();
   }
 
+  validate() {
+    const longestChain = this.getLongestChain();
+    if (!longestChain.length) {
+      throw new SPVError('Empty SPV chain');
+    }
+    const head = longestChain[longestChain.length - 1];
+    const tail = this.prunedHeaders[0] || longestChain[0];
+
+    const headHeight = this.heightByHash.get(head.hash);
+    const tailHeight = this.heightByHash.get(tail.hash);
+
+    if (this.orphanChunks.length) {
+      throw new SPVError('Chain contains orphan chunks');
+    }
+
+    if (typeof headHeight !== 'number') {
+      throw new SPVError(`Head header '${head.hash}' height is invalid ${headHeight}`);
+    }
+
+    if (typeof tailHeight !== 'number') {
+      throw new SPVError(`Tail header '${tail.hash}' height is invalid ${tailHeight}`);
+    }
+
+    if (this.hashesByHeight.get(headHeight) !== head.hash) {
+      throw new SPVError(`Head header '${head.hash}' height mismatch`);
+    }
+
+    if (this.hashesByHeight.get(tailHeight) !== tail.hash) {
+      throw new SPVError(`Tail header '${tail.hash}' height mismatch`);
+    }
+
+    const expectedChainLength = headHeight - tailHeight + 1;
+    const actualChainLength = longestChain.length + this.prunedHeaders.length;
+
+    if (expectedChainLength !== actualChainLength) {
+      throw new SPVError(`Chain length mismatch: expected ${expectedChainLength}, actual ${actualChainLength}`);
+    }
+  }
+
   /** @private */
   checkPruneBlocks() {
     const longestChain = this.getLongestChain();
 
-    while (longestChain.length > this.confirmsBeforeFinal) {
-      const pruneBlock = longestChain.splice(0, 1)[0];
-      // Children discarded as stale branches
-      delete pruneBlock.orphan;
-      this.store.put(pruneBlock);
-    }
+    longestChain
+      .splice(0, longestChain.length - this.confirmsBeforeFinal)
+      .forEach((header) => {
+        this.prunedHeaders.push(header);
+      });
   }
 
   /** @private */
@@ -97,7 +153,7 @@ const SpvChain = class {
       if (node.hash === utils.getCorrectedHash(newHeader.prevHash)) {
         return node;
       }
-      node.children.forEach((c) => { stack.push(c); });
+      // node.children.forEach((c) => { stack.push(c); });
     }
     return null;
   }
@@ -107,18 +163,29 @@ const SpvChain = class {
     this.allBranches = [];
     branch.push(node);
 
-    node.children.forEach((c) => {
-      this.setAllBranches(c, Array.from(branch));
-    });
+    // node.children.forEach((c) => {
+    //   this.setAllBranches(c, Array.from(branch));
+    // });
 
-    if (node.children.length === 0) {
-      this.allBranches.push(branch);
-    }
+    // if (node.children.length === 0) {
+    this.allBranches.push(branch);
+    // }
   }
 
   /** @private */
   appendHeadersToLongestChain(headers) {
-    const newLongestChain = this.getLongestChain().concat(headers);
+    const longestChain = this.getLongestChain();
+    const lastHeight = this.startBlockHeight
+      + longestChain.length + this.prunedHeaders.length;
+
+    headers.forEach((header, i) => {
+      const height = lastHeight + i;
+      this.hashesByHeight.set(height, header.hash);
+      this.heightByHash.set(header.hash, height);
+    });
+
+    const newLongestChain = longestChain.concat(headers);
+
     this.allBranches = [];
     this.allBranches.push(newLongestChain);
   }
@@ -129,38 +196,48 @@ const SpvChain = class {
   }
 
   /** @private */
-  isDuplicate(compareHash) {
-    return this.getAllBranches().map((branch) => branch.map((node) => node.hash))
-      .concat(this.orphanBlocks.map((orphan) => orphan.hash))
-      .filter((hash) => hash === compareHash).length > 0;
+  isDuplicate(hash) {
+    return this.heightByHash.has(hash) || this.orphansHashes.has(hash);
   }
 
   /** @private */
-  orphanReconnect() {
-    for (let i = 0; i < this.orphanBlocks.length; i += 1) {
-      const connectionTip = this.findConnection(this.orphanBlocks[i]);
-      if (connectionTip) {
-        connectionTip.children.push(this.orphanBlocks[i]);
-        this.orphanBlocks.splice(i, 1);
-      }
-    }
-  }
+  // orphanReconnect() {
+  // for (let i = 0; i < this.orphanBlocks.length; i += 1) {
+  // const connectionTip = this.findConnection(this.orphanBlocks[i]);
+  // if (connectionTip) {
+  //   connectionTip.children.push(this.orphanBlocks[i]);
+  //   this.orphanBlocks.splice(i, 1);
+  // }
+  // }
+  // }
 
   /** @private */
   orphanChunksReconnect() {
+    // TODO: consider optimizing with map of { [chunkHeadHash]: chunkIndex }
+    // to get rid of sorting and make the whole function of O(n) complexity
     this.orphanChunks.sort((a, b) => a[0].timestamp - b[0].timestamp);
-    this.orphanChunks.slice().forEach((chunk, index) => {
-      if (this.getTipHash() === utils.getCorrectedHash(chunk[0].prevHash)) {
+
+    for (let i = 0; i < this.orphanChunks.length; i += 1) {
+      const chunk = this.orphanChunks[i];
+      const tipHash = this.getTipHash();
+      const chunkPrevHash = utils.getCorrectedHash(chunk[0].prevHash);
+
+      if (tipHash === chunkPrevHash) {
         this.appendHeadersToLongestChain(chunk);
-        this.orphanChunks.splice(index, 1);
+        chunk.forEach((header) => {
+          this.orphansHashes.delete(header.hash);
+        });
+        this.orphanChunks.splice(i, 1);
+        i -= 1;
       }
-    });
+    }
   }
 
   /** @private */
-  getOrphans() {
-    return this.orphanBlocks;
-  }
+  // TODO: remove
+  // getOrphans() {
+  //   return this.orphanBlocks;
+  // }
 
   /** @private */
   getOrphanChunks() {
@@ -168,15 +245,15 @@ const SpvChain = class {
   }
 
   /** @private */
-  processValidHeader(header) {
-    const connection = this.findConnection(header);
-    if (connection) {
-      connection.children.push(header);
-      this.orphanReconnect();
-    } else {
-      this.orphanBlocks.push(header);
-    }
-  }
+  // processValidHeader(header) {
+  //   const connection = this.findConnection(header);
+  //   if (connection) {
+  //     // connection.children.push(header);
+  //     this.orphanReconnect();
+  //   } else {
+  //     this.orphanBlocks.push(header);
+  //   }
+  // }
 
   /** @private
    * validates a dashcore.BlockHeader object
@@ -186,8 +263,9 @@ const SpvChain = class {
    * @return {boolean}
    */
   isValid(header, previousHeaders) {
-    return !!(Consensus.isValidBlockHeader(header, previousHeaders, this.network)
-      && !this.isDuplicate(header.hash));
+    const validBlockHeader = Consensus.isValidBlockHeader(header, previousHeaders, this.network);
+    const duplicate = this.isDuplicate(header.hash);
+    return !!validBlockHeader && !duplicate;
   }
 
   /* eslint-disable no-param-reassign */
@@ -203,24 +281,30 @@ const SpvChain = class {
     if (utils.getCorrectedHash(header.prevHash) !== previousHeader.hash) {
       return false;
     }
-    if (!header.children) {
-      header.children = [];
-    }
-    if (!previousHeader.children) {
-      previousHeader.children = [];
-    }
-    previousHeader.children.push(header);
+    // if (!header.children) {
+    //   header.children = [];
+    // }
+    // if (!previousHeader.children) {
+    //   previousHeader.children = [];
+    // }
+    // previousHeader.children.push(header);
     return true;
   }
   /* eslint-enable no-param-reassign */
 
   /**
-   * gets the longest chain
-   *
-   * @return {Object[]}
+   * Returns the longest chain of headers
+   * @param options
+   * @returns {*}
    */
-  getLongestChain() {
-    return this.allBranches.sort((b1, b2) => b1 < b2)[0];
+  getLongestChain(options = { withPruned: false }) {
+    let longestChain = this.allBranches.sort((b1, b2) => b1 < b2)[0];
+
+    if (options.withPruned) {
+      longestChain = this.prunedHeaders.concat(longestChain);
+    }
+
+    return longestChain;
   }
 
   /**
@@ -229,7 +313,8 @@ const SpvChain = class {
    * @return {string} hash
    */
   getTipHash() {
-    return this.getLongestChain().slice(-1)[0].hash;
+    const tip = this.getTipHeader();
+    return tip && tip.hash;
   }
 
   /**
@@ -248,14 +333,25 @@ const SpvChain = class {
    * @return {Object} header
    */
   getHeader(hash) {
-    return this.store.get(hash)
-      .then((blockInDB) => {
-        if (blockInDB) {
-          return blockInDB;
-        }
+    // TODO: perform lookup in pruned headers?
+    return this.getLongestChain().filter((h) => h.hash === hash)[0];
+  }
 
-        return this.getLongestChain().filter((h) => h.hash === hash)[0];
-      });
+  /**
+   * Gets specified amount of headers in the confirmed chain
+   * @param n
+   * @return Object[]
+   */
+  getLastHeaders(n) {
+    const longestChain = this.getLongestChain();
+    let headers = longestChain.slice(-n);
+
+    if (headers.length < n) {
+      const remaining = n - headers.length;
+      headers = [...this.prunedHeaders.slice(-remaining), ...headers];
+    }
+
+    return headers;
   }
 
   /**
@@ -266,18 +362,18 @@ const SpvChain = class {
    * @param {Object[]|string[]|buffer[]} header
    * @return {boolean}
    */
-  addHeader(header) {
-    const headerNormalised = utils.normalizeHeader(header);
-
-    if (this.isValid(headerNormalised, this.getLongestChain())) {
-      headerNormalised.children = [];
-      this.processValidHeader(headerNormalised);
-      this.setAllBranches();
-      this.checkPruneBlocks();
-      return true;
-    }
-    return false;
-  }
+  // addHeader(header) {
+  //   const headerNormalised = utils.normalizeHeader(header);
+  //
+  //   if (this.isValid(headerNormalised, this.getLongestChain())) {
+  //     // headerNormalised.children = [];
+  //     this.processValidHeader(headerNormalised);
+  //     this.setAllBranches();
+  //     this.checkPruneBlocks();
+  //     return true;
+  //   }
+  //   return false;
+  // }
 
   /**
    * adds an array of valid headers to the longest spv chain.
@@ -285,45 +381,76 @@ const SpvChain = class {
    * added to an orphan array for possible later reconnection
    *
    * @param {Object[]|string[]|buffer[]} headers
-   * @return {boolean}
+   * @param {number} batchHeadHeight - height of the first header in the array
+   * @return {BlockHeader[]}
    */
-  addHeaders(headers) {
-    if (headers.length === 1) {
-      if (!this.addHeader(headers[0])) {
-        throw new Error('Some headers are invalid');
-      } else {
-        return true;
-      }
-    }
+  addHeaders(headers, batchHeadHeight = 0) {
+    let headHeight = batchHeadHeight;
     const normalizedHeaders = headers.map((h) => utils.normalizeHeader(h));
-    const isOrphan = !SpvChain.isParentChild(normalizedHeaders[0], this.getTipHeader());
+
+    const tip = this.getTipHeader();
+    // Handle 1 block intersection of batches
+    if (tip && tip.hash === normalizedHeaders[0].hash) {
+      normalizedHeaders.splice(0, 1);
+      // Patch head height value after splice
+      headHeight += 1;
+    }
+
+    if (normalizedHeaders.length === 0) {
+      // The batch already in the chain, do nothing
+      return [];
+    }
+
+    const firstHeader = normalizedHeaders[0];
+    const connectsToTip = tip && SpvChain.isParentChild(firstHeader, tip);
+
+    //
+    // Reorg detection
+    // Get prev header hash
+    const prevHash = utils.getCorrectedHash(firstHeader.prevHash);
+    const prevHeaderHeight = this.heightByHash.get(prevHash);
+
+    // Test on initial wallet load
+    if (prevHeaderHeight && prevHeaderHeight > 0 && prevHeaderHeight !== headHeight - 1) {
+      console.log('SPVCHAIN: Reorg detected.');
+      console.log(`------->: Batch head ${firstHeader.hash} at height ${headHeight} has parent at height ${prevHeaderHeight}`);
+    }
+
+    const isOrphan = tip ? !connectsToTip
+      : headHeight !== this.startBlockHeight;
 
     const allValid = normalizedHeaders.reduce(
       (acc, header, index, array) => {
         const previousHeaders = normalizedHeaders.slice(0, index);
         if (index !== 0) {
-          if (!SpvChain.isParentChild(header, array[index - 1])
-            || !this.isValid(header, previousHeaders)) {
-            throw new Error('Some headers are invalid');
+          if (!SpvChain.isParentChild(header, array[index - 1])) {
+            throw new SPVError(`SPV: Header ${header.hash} is not a child of ${array[index - 1].hash}`);
+          }
+
+          if (!this.isValid(header, previousHeaders)) {
+            throw new SPVError(`SPV: Header ${header.hash} is invalid`);
           }
           return acc && true;
         }
         if (isOrphan) {
           if (!this.isValid(header, previousHeaders)) {
-            throw new Error('Some headers are invalid');
+            throw new SPVError('Some headers are invalid');
           }
           return acc && true;
         }
         if (!this.isValid(header, this.getLongestChain())) {
-          throw new Error('Some headers are invalid');
+          throw new SPVError('Some headers are invalid');
         }
         return acc && true;
       }, true,
     );
     if (!allValid) {
-      throw new Error('Some headers are invalid');
+      throw new SPVError('Some headers are invalid');
     }
     if (isOrphan) {
+      normalizedHeaders.forEach((header) => {
+        this.orphansHashes.add(header.hash);
+      });
       this.orphanChunks.push(normalizedHeaders);
     } else {
       this.appendHeadersToLongestChain(normalizedHeaders);
@@ -332,7 +459,7 @@ const SpvChain = class {
       this.orphanChunksReconnect();
     }
     this.checkPruneBlocks();
-    return true;
+    return normalizedHeaders;
   }
 };
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dashevo/dash-spv",
-  "version": "0.24.0-dev.6",
+  "version": "0.25.0-dev.10",
   "description": "Repository containing SPV functions used by @dashevo",
   "main": "index.js",
   "scripts": {
@@ -14,11 +14,12 @@
   "dependencies": {
     "@dashevo/dark-gravity-wave": "^1.1.1",
     "@dashevo/dash-util": "^2.0.3",
-    "@dashevo/dashcore-lib": "~0.19.44",
+    "@dashevo/dashcore-lib": "~0.20.3",
     "levelup": "^4.4.0",
     "memdown": "^5.1.0"
   },
   "devDependencies": {
+    "chai": "^4.3.4",
     "eslint": "^7.32.0",
     "eslint-config-airbnb-base": "^14.2.1",
     "eslint-plugin-import": "^2.24.2",

package/test/index.js

@@ -1,4 +1,6 @@
 const { MerkleBlock, Transaction } = require('@dashevo/dashcore-lib');
+const should = require('should');
+
 const Blockchain = require('../lib/spvchain');
 const utils = require('../lib/utils');
 const merkleProofs = require('../lib/merkleproofs');
@@ -13,11 +15,9 @@ let chain = null;
 let merkleBlock = null;
 let merkleBlock2 = null;
 
-require('should');
-
 describe('SPV-DASH (forks & re-orgs) deserialized headers', () => {
   before(() => {
-    chain = new Blockchain('devnet');
+    chain = new Blockchain('testnet');
   });
 
   it('should get 26 testnet headers', () => {
@@ -34,39 +34,40 @@ describe('SPV-DASH (forks & re-orgs) deserialized headers', () => {
   });
 
   it('should still contain a branch of 1 when first header is added', () => {
-    chain.addHeader(headers[0]);
+    chain.addHeaders([headers[0]]);
     chain.getAllBranches().length.should.equal(1);
     chain.getLongestChain().length.should.equal(2);
   });
 
   it('should discard adding of duplicate block', () => {
-    chain.addHeader(headers[0]);
-    chain.getOrphans().length.should.equal(0);
+    chain.addHeaders([headers[0]]);
+    chain.getOrphanChunks().length.should.equal(0);
     chain.getLongestChain().length.should.equal(2);
   });
 
   it('should create 1 orphan', () => {
-    chain.addHeader(headers[2]);
-    chain.getOrphans().length.should.equal(1);
+    chain.addHeaders([headers[2]]);
+    chain.getOrphanChunks().length.should.equal(1);
     chain.getLongestChain().length.should.equal(2);
   });
 
   it('should connect the orphan by adding its parent', () => {
-    chain.addHeader(headers[1]);
-    chain.getOrphans().length.should.equal(0);
+    chain.addHeaders([headers[1]]);
+    chain.getOrphanChunks().length.should.equal(0);
     chain.getAllBranches().length.should.equal(1);
     chain.getLongestChain().length.should.equal(4);
   });
 
   it('should add remaining test headers', () => {
     chain.addHeaders(headers.slice(3, 24));
-    chain.getOrphans().length.should.equal(0);
+    chain.getOrphanChunks().length.should.equal(0);
     chain.getAllBranches().length.should.equal(1);
     chain.getLongestChain().length.should.equal(25);
   });
 
-  it('not add an invalid header', () => {
-    chain.addHeader(headers[25]);
+  // TODO: restore when conesnsus rules are enabled
+  it.skip('not add an invalid header', () => {
+    should(() => chain.addHeaders([headers[25]])).throw();
     chain.getLongestChain().length.should.equal(25);
   });
 
@@ -75,7 +76,7 @@ describe('SPV-DASH (forks & re-orgs) deserialized headers', () => {
       chain.addHeaders([headers[25], headers[10]]);
       done(new Error('SPV chain failed to throw an error on invalid block'));
     } catch (e) {
-      e.message.should.equal('Some headers are invalid');
+      e.message.should.equal('SPV: Header 00000ce430de949c85a145b02e33ebbaed3772dc8f3d668f66edc6852c24d002 is not a child of e59b97d3d11b4d4563b557e32c62afbdb6e947e9cbb4915c94073f08f7936d5f');
       done();
     }
   });
@@ -100,26 +101,26 @@ describe('SPV-DASH (forks & re-orgs) serialized raw headers for mainnet', () =>
   });
 
   it('should still contain a branch of 1 when first header is added', () => {
-    chain.addHeader(mainnet[1]);
+    chain.addHeaders([mainnet[1]]);
     chain.getAllBranches().length.should.equal(1);
     chain.getLongestChain().length.should.equal(2);
   });
 
   it('should discard addding of duplicate block', () => {
-    chain.addHeader(mainnet[1]);
-    chain.getOrphans().length.should.equal(0);
+    chain.addHeaders([mainnet[1]]);
+    chain.getOrphanChunks().length.should.equal(0);
     chain.getLongestChain().length.should.equal(2);
   });
 
   it('should create 1 orphan', () => {
-    chain.addHeader(mainnet[3]);
-    chain.getOrphans().length.should.equal(1);
+    chain.addHeaders([mainnet[3]]);
+    chain.getOrphanChunks().length.should.equal(1);
     chain.getLongestChain().length.should.equal(2);
   });
 
   it('should connect the orphan by adding its parent', () => {
-    chain.addHeader(mainnet[2]);
-    chain.getOrphans().length.should.equal(0);
+    chain.addHeaders([mainnet[2]]);
+    chain.getOrphanChunks().length.should.equal(0);
     chain.getAllBranches().length.should.equal(1);
     chain.getLongestChain().length.should.equal(4);
   });
@@ -132,14 +133,14 @@ describe('SPV-DASH (addHeaders) add many headers for testnet', () => {
 
   it('should add the 1st 250 testnet headers', () => {
     chain.addHeaders(testnet.slice(1, 250));
-    chain.getOrphans().length.should.equal(0);
+    chain.getOrphanChunks().length.should.equal(0);
     chain.getAllBranches().length.should.equal(1);
     chain.getLongestChain().length.should.equal(250);
   });
 
   it('should add the next 250 (250 - 500) testnet headers', () => {
     chain.addHeaders(testnet.slice(250, 500));
-    chain.getOrphans().length.should.equal(0);
+    chain.getOrphanChunks().length.should.equal(0);
     chain.getAllBranches().length.should.equal(1);
     chain.getLongestChain().length.should.equal(500);
   });
@@ -147,14 +148,14 @@ describe('SPV-DASH (addHeaders) add many headers for testnet', () => {
   it('should add the 1st 250 testnet2 headers', () => {
     chain = new Blockchain('testnet', 10000, utils.normalizeHeader(testnet2[0]));
     chain.addHeaders(testnet2.slice(1, 250));
-    chain.getOrphans().length.should.equal(0);
+    chain.getOrphanChunks().length.should.equal(0);
     chain.getAllBranches().length.should.equal(1);
     chain.getLongestChain().length.should.equal(250);
   });
 
   it('should add the next 250 (250 - 500) testnet2 headers', () => {
     chain.addHeaders(testnet2.slice(250, 500));
-    chain.getOrphans().length.should.equal(0);
+    chain.getOrphanChunks().length.should.equal(0);
     chain.getAllBranches().length.should.equal(1);
     chain.getLongestChain().length.should.equal(500);
   });
@@ -162,26 +163,26 @@ describe('SPV-DASH (addHeaders) add many headers for testnet', () => {
   it('should add the 1st 250 testnet3 headers', () => {
     chain = new Blockchain('testnet', 10000, utils.normalizeHeader(testnet3[0]));
     chain.addHeaders(testnet3.slice(1, 250));
-    chain.getOrphans().length.should.equal(0);
+    chain.getOrphanChunks().length.should.equal(0);
     chain.getAllBranches().length.should.equal(1);
     chain.getLongestChain().length.should.equal(250);
   });
 
   it('should add the next 250 (250 - 500) testnet3 headers', () => {
     chain.addHeaders(testnet3.slice(250, 500));
-    chain.getOrphans().length.should.equal(0);
+    chain.getOrphanChunks().length.should.equal(0);
     chain.getAllBranches().length.should.equal(1);
     chain.getLongestChain().length.should.equal(500);
   });
 
   it('should not add an invalid header', () => {
-    chain.addHeader(testnet[499]);
+    chain.addHeaders([testnet[499]]);
     chain.getLongestChain().length.should.equal(500);
   });
 
   it('should orphan and not add invalid but consistent headers', () => {
     chain.addHeaders([badRawHeaders[0], badRawHeaders[1]]);
-    chain.getOrphanChunks().length.should.equal(1);
+    chain.getOrphanChunks().length.should.equal(2);
     chain.getLongestChain().length.should.equal(500);
   });
 
@@ -203,7 +204,7 @@ describe('SPV-DASH (addHeaders) add testnet headers out of order', () => {
 
   it('should add the 1st 100 testnet headers', () => {
     chain.addHeaders(testnet.slice(1, 100));
-    chain.getOrphans().length.should.equal(0);
+    chain.getOrphanChunks().length.should.equal(0);
     chain.getAllBranches().length.should.equal(1);
     chain.getOrphanChunks().length.should.equal(0);
     chain.getLongestChain().length.should.equal(100);
@@ -211,7 +212,6 @@ describe('SPV-DASH (addHeaders) add testnet headers out of order', () => {
 
   it('should orphan testnet headers 200 - 300', () => {
     chain.addHeaders(testnet.slice(200, 300));
-    chain.getOrphans().length.should.equal(0);
     chain.getAllBranches().length.should.equal(1);
     chain.getOrphanChunks().length.should.equal(1);
     chain.getLongestChain().length.should.equal(100);
@@ -219,15 +219,13 @@ describe('SPV-DASH (addHeaders) add testnet headers out of order', () => {
 
   it('should orphan testnet headers 400 - 500', () => {
     chain.addHeaders(testnet.slice(400, 500));
-    chain.getOrphans().length.should.equal(0);
-    chain.getAllBranches().length.should.equal(1);
     chain.getOrphanChunks().length.should.equal(2);
+    chain.getAllBranches().length.should.equal(1);
     chain.getLongestChain().length.should.equal(100);
   });
 
   it('should reconnect orphaned chunks (testnet headers 1 - 100 and 200 - 300)', () => {
     chain.addHeaders(testnet.slice(100, 200));
-    chain.getOrphans().length.should.equal(0);
     chain.getAllBranches().length.should.equal(1);
     chain.getOrphanChunks().length.should.equal(1);
     chain.getLongestChain().length.should.equal(300);
@@ -235,7 +233,7 @@ describe('SPV-DASH (addHeaders) add testnet headers out of order', () => {
 
   it('should reconnect orphaned chunks (testnet headers 1 - 300 and 400 - 500)', () => {
     chain.addHeaders(testnet.slice(300, 400));
-    chain.getOrphans().length.should.equal(0);
+    chain.getOrphanChunks().length.should.equal(0);
     chain.getAllBranches().length.should.equal(1);
     chain.getOrphanChunks().length.should.equal(0);
     chain.getLongestChain().length.should.equal(500);
@@ -249,27 +247,27 @@ describe('SPV-DASH (addHeaders) add many headers for mainnet', () => {
 
   it('should add the 1st 500 mainnet headers', () => {
     chain.addHeaders(mainnet.slice(1, 500));
-    chain.getOrphans().length.should.equal(0);
+    chain.getOrphanChunks().length.should.equal(0);
     chain.getAllBranches().length.should.equal(1);
     chain.getLongestChain().length.should.equal(500);
   });
 
   it('should add the next 500 (500 - 1000) mainnet headers', () => {
     chain.addHeaders(mainnet.slice(500, 1000));
-    chain.getOrphans().length.should.equal(0);
+    chain.getOrphanChunks().length.should.equal(0);
     chain.getAllBranches().length.should.equal(1);
     chain.getLongestChain().length.should.equal(1000);
   });
 
   it('should add the next 500 (1000 - 1500) mainnet headers', () => {
     chain.addHeaders(mainnet.slice(1000, 1500));
-    chain.getOrphans().length.should.equal(0);
+    chain.getOrphanChunks().length.should.equal(0);
     chain.getAllBranches().length.should.equal(1);
     chain.getLongestChain().length.should.equal(1500);
   });
 
   it('should not add an invalid header', () => {
-    chain.addHeader(mainnet[499]);
+    should(() => chain.addHeaders([mainnet[499]])).throw();
     chain.getLongestChain().length.should.equal(1500);
   });
 
@@ -297,7 +295,7 @@ describe('SPV-DASH (addHeaders) add mainnet headers out of order', () => {
 
   it('should add the 1st 100 mainnet headers', () => {
     chain.addHeaders(mainnet.slice(1, 100));
-    chain.getOrphans().length.should.equal(0);
+    chain.getOrphanChunks().length.should.equal(0);
     chain.getAllBranches().length.should.equal(1);
     chain.getOrphanChunks().length.should.equal(0);
     chain.getLongestChain().length.should.equal(100);
@@ -305,7 +303,6 @@ describe('SPV-DASH (addHeaders) add mainnet headers out of order', () => {
 
   it('should orphan mainnet headers 200 - 300', () => {
     chain.addHeaders(mainnet.slice(200, 300));
-    chain.getOrphans().length.should.equal(0);
     chain.getAllBranches().length.should.equal(1);
     chain.getOrphanChunks().length.should.equal(1);
     chain.getLongestChain().length.should.equal(100);
@@ -313,7 +310,6 @@ describe('SPV-DASH (addHeaders) add mainnet headers out of order', () => {
 
   it('should orphan mainnet headers 400 - 500', () => {
     chain.addHeaders(mainnet.slice(400, 500));
-    chain.getOrphans().length.should.equal(0);
     chain.getAllBranches().length.should.equal(1);
     chain.getOrphanChunks().length.should.equal(2);
     chain.getLongestChain().length.should.equal(100);
@@ -321,7 +317,6 @@ describe('SPV-DASH (addHeaders) add mainnet headers out of order', () => {
 
   it('should reconnect orphaned chunks (mainnet headers 1 - 100 and 200 - 300)', () => {
     chain.addHeaders(mainnet.slice(100, 200));
-    chain.getOrphans().length.should.equal(0);
     chain.getAllBranches().length.should.equal(1);
     chain.getOrphanChunks().length.should.equal(1);
     chain.getLongestChain().length.should.equal(300);
@@ -329,7 +324,6 @@ describe('SPV-DASH (addHeaders) add mainnet headers out of order', () => {
 
   it('should reconnect orphaned chunks (mainnet headers 1 - 300 and 400 - 500)', () => {
     chain.addHeaders(mainnet.slice(300, 400));
-    chain.getOrphans().length.should.equal(0);
     chain.getAllBranches().length.should.equal(1);
     chain.getOrphanChunks().length.should.equal(0);
     chain.getLongestChain().length.should.equal(500);
@@ -337,7 +331,7 @@ describe('SPV-DASH (addHeaders) add mainnet headers out of order', () => {
 });
 
 let genesisHash = null;
-describe('Blockstore', () => {
+describe.skip('Blockstore', () => {
   before(() => {
     chain = new Blockchain('testnet', 10);
     genesisHash = chain.getTipHash();

package/test/spvchain.js

@@ -0,0 +1,33 @@
+const { expect } = require('chai');
+const { SpvChain } = require('../index');
+
+const { testnet } = require('./data/rawHeaders');
+
+describe('SPVChain', () => {
+  let spvChain;
+
+  beforeEach(() => {
+    spvChain = new SpvChain('testnet', 100);
+  });
+
+  describe('#addHeaders', () => {
+    it('should assemble headers chain if headers arriving out of order', () => {
+      expect(true).to.equal(true);
+      spvChain.reset(10000);
+
+      spvChain.addHeaders(testnet.slice(400), 10400);
+      expect(spvChain.getOrphanChunks()).to.have.length(1);
+      spvChain.addHeaders(testnet.slice(200, 300), 10200);
+      expect(spvChain.getOrphanChunks()).to.have.length(2);
+      spvChain.addHeaders(testnet.slice(300, 400), 10300);
+      expect(spvChain.getOrphanChunks()).to.have.length(3);
+      spvChain.addHeaders(testnet.slice(100, 200), 10100);
+      expect(spvChain.getOrphanChunks()).to.have.length(4);
+      spvChain.addHeaders(testnet.slice(0, 100), 10000);
+
+      const longestChain = spvChain.getLongestChain({ withPruned: true });
+      expect(longestChain).to.have.length(testnet.length);
+      expect(spvChain.getOrphanChunks()).to.have.length(0);
+    });
+  });
+});