@dashevo/dash-spv 0.23.0-alpha.1

package/.eslintignore

@@ -0,0 +1,2 @@
+dist/
+.nyc_output/

package/.eslintrc.json

@@ -0,0 +1,7 @@
+{
+    "extends": "airbnb-base",
+    "env": {
+      "mocha": true,
+      "node": true
+    }
+  }

package/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2017-2022 Dash Core Group, Inc.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

package/README.md

@@ -0,0 +1,7 @@
+# dash-spv
+
+Set of SPV function used by js-dapi-client package
+
+## License
+
+[MIT](LICENSE) © Dash Core Group, Inc.

package/config/config.js

@@ -0,0 +1,51 @@
+const DashUtil = require('@dashevo/dash-util');
+const utils = require('../lib/utils');
+
+module.exports = {
+  getLowDiffGenesis() {
+    // Custom genesis to test with lower difficulty
+    return utils.normalizeHeader({
+      version: 1,
+      previousblockhash: '0000000000000000000000000000000000000000000000000000000000000000',
+      merkleroot: DashUtil.nullHash.toString('hex'),
+      time: 1504510163,
+      bits: '1fffffff',
+      nonce: 2307,
+    });
+  },
+  getTestnetGenesis() {
+    // Custom genesis to test with lower difficulty
+    return utils.normalizeHeader({
+      version: 1,
+      previousblockhash: '0000000000000000000000000000000000000000000000000000000000000000',
+      merkleroot: 'e0028eb9648db56b1ac77cf090b99048a8007e2bb64b68f092c03c7f56a662c7',
+      time: 1390666206,
+      bits: '1e0ffff0',
+      nonce: 3861367235,
+    });
+  },
+  getDevnetGenesis() {
+    // Custom genesis to test with lower difficulty
+    return utils.normalizeHeader({
+      version: 1,
+      previousblockhash: '0000000000000000000000000000000000000000000000000000000000000000',
+      merkleroot: 'e0028eb9648db56b1ac77cf090b99048a8007e2bb64b68f092c03c7f56a662c7',
+      time: 1390666206,
+      bits: '1e0ffff0',
+      nonce: 3861367235,
+    });
+  },
+  getRegtestGenesis() {
+    return utils.normalizeHeader({
+      version: 1,
+      previousblockhash: '0000000000000000000000000000000000000000000000000000000000000000',
+      merkleroot: 'e0028eb9648db56b1ac77cf090b99048a8007e2bb64b68f092c03c7f56a662c7',
+      time: 1390666206,
+      bits: '1e0ffff0',
+      nonce: 3861367235,
+    });
+  },
+  getLivenetGenesis() {
+    throw Error('Livenet genesis not yet implemented');
+  },
+};

package/index.js

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

package/lib/blockstore.js

@@ -0,0 +1,56 @@
+const levelup = require('levelup');
+const memdown = require('memdown');
+const dashcore = require('@dashevo/dashcore-lib');
+
+class BlockStore {
+  constructor() {
+    this.db = levelup(memdown(), {
+      keyAsBuffer: false,
+      valueAsBuffer: false,
+      valueEncoding: 'json',
+    });
+    this.block = dashcore.BlockHeader;
+  }
+
+  put(header) {
+    return new Promise((resolve, reject) => {
+      this.db.put(header.hash, JSON.stringify(header.toObject()), (err) => {
+        if (!err) {
+          resolve(header.hash);
+        } else {
+          reject(err);
+        }
+      });
+    });
+  }
+
+  get(hash) {
+    const self = this;
+
+    return new Promise((resolve, reject) => {
+      self.db.get(hash, (err, data) => {
+        if (err && err.name === 'NotFoundError') {
+          resolve(null);
+        } else if (err) {
+          reject(err.message);
+        } else {
+          resolve(JSON.parse(data.toString()));
+        }
+      });
+    });
+  }
+
+  close() {
+    this.db.close();
+  }
+
+  isClosed() {
+    return this.db.isClosed();
+  }
+
+  isOpen() {
+    return this.db.isOpen();
+  }
+}
+
+module.exports = BlockStore;

package/lib/consensus.js

@@ -0,0 +1,65 @@
+const { hasValidTarget } = require('@dashevo/dark-gravity-wave');
+const merkleProofs = require('./merkleproofs');
+const utils = require('./utils');
+
+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);
+}
+
+// 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 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);
+}
+
+/**
+ * validates an array of tx hashes or Transaction instances
+ * against a merkleblock and the local header chain
+ * @param {Transaction[]|string[]} transactions
+ * @param {MerkleBlock} merkleBlock - a MerkleBlock instance
+ * @param {SpvChain} headerChain - an instance of an SpvChain
+ * @return {boolean}
+ */
+async function areValidTransactions(transactions, merkleBlock, headerChain) {
+  if (!Array.isArray(transactions) || transactions.length <= 0) {
+    throw new Error('Please check that transactions parameter is a non-empty array');
+  }
+  const localHeader = await headerChain.getHeader(merkleBlock.header.hash);
+  if (!localHeader) {
+    return false;
+  }
+  return merkleProofs.validateTxProofs(merkleBlock, transactions);
+}
+
+module.exports = {
+  isValidBlockHeader,
+  areValidTransactions,
+};

package/lib/merkleproofs.js

@@ -0,0 +1,21 @@
+const DashUtil = require('@dashevo/dash-util');
+
+const merkleproofs = {
+  /**
+   * validates an array of tx hashes or Transaction instances
+   * against a merkleblock
+   * @param {MerkleBlock} merkleBlock - a MerkleBlock instance
+   * @param {Transaction[]|string[]} transactions
+   * @return {boolean}
+   */
+  validateTxProofs: (merkleBlock, transactions) => {
+    let txToFilter = transactions.slice();
+    if (typeof transactions[0] === 'string') {
+      txToFilter = txToFilter.map((tx) => DashUtil.toHash(tx).toString('hex'));
+    }
+    return merkleBlock.validMerkleTree
+      && txToFilter.filter((tx) => merkleBlock.hasTransaction(tx)).length === transactions.length;
+  },
+};
+
+module.exports = merkleproofs;

package/lib/spvchain.js

@@ -0,0 +1,339 @@
+const BlockStore = require('./blockstore');
+const config = require('../config/config');
+const Consensus = require('./consensus');
+const utils = require('./utils');
+
+const SpvChain = class {
+  constructor(chainType, confirms = 100, startBlock) {
+    this.root = null;
+    this.allBranches = [];
+    this.orphanBlocks = [];
+    this.orphanChunks = [];
+    this.confirmsBeforeFinal = confirms;
+    this.init(chainType, startBlock);
+    this.store = new BlockStore();
+  }
+
+  init(chainType, startBlock) {
+    switch (chainType) {
+      case 'testnet':
+        this.network = 'testnet';
+        if (startBlock) {
+          this.root = startBlock;
+          break;
+        }
+        this.root = config.getTestnetGenesis();
+        break;
+      case 'devnet':
+        this.network = 'devnet';
+        if (startBlock) {
+          this.root = startBlock;
+          break;
+        }
+        this.root = config.getDevnetGenesis();
+        break;
+      case 'regtest':
+        this.network = 'regtest';
+        if (startBlock) {
+          this.root = startBlock;
+          break;
+        }
+        this.root = config.getRegtestGenesis();
+        break;
+      case 'livenet':
+        this.network = 'mainnet';
+        if (startBlock) {
+          this.root = startBlock;
+          break;
+        }
+        this.root = config.getLivenetGenesis();
+        break;
+      case 'mainnet':
+        this.network = 'mainnet';
+        if (startBlock) {
+          this.root = startBlock;
+          break;
+        }
+        this.root = config.getLivenetGenesis();
+        break;
+      case 'lowdiff':
+        this.network = 'regtest';
+        if (startBlock) {
+          this.root = startBlock;
+          break;
+        }
+        this.root = config.getLowDiffGenesis();
+        break;
+      default:
+        if (startBlock) {
+          this.root = startBlock;
+          this.network = 'mainnet';
+        } else {
+          throw new Error('Unhandled chaintype or startBlock not provided');
+        }
+        break;
+    }
+    this.root.children = [];
+    this.setAllBranches();
+  }
+
+  /** @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);
+    }
+  }
+
+  /** @private */
+  findConnection(newHeader) {
+    const stack = [this.root];
+    while (stack.length > 0) {
+      const node = stack.pop();
+      if (node.hash === utils.getCorrectedHash(newHeader.prevHash)) {
+        return node;
+      }
+      node.children.forEach((c) => { stack.push(c); });
+    }
+    return null;
+  }
+
+  /** @private */
+  setAllBranches(node = this.root, branch = []) {
+    this.allBranches = [];
+    branch.push(node);
+
+    node.children.forEach((c) => {
+      this.setAllBranches(c, Array.from(branch));
+    });
+
+    if (node.children.length === 0) {
+      this.allBranches.push(branch);
+    }
+  }
+
+  /** @private */
+  appendHeadersToLongestChain(headers) {
+    const newLongestChain = this.getLongestChain().concat(headers);
+    this.allBranches = [];
+    this.allBranches.push(newLongestChain);
+  }
+
+  /** @private */
+  getAllBranches() {
+    return this.allBranches;
+  }
+
+  /** @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;
+  }
+
+  /** @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);
+      }
+    }
+  }
+
+  /** @private */
+  orphanChunksReconnect() {
+    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)) {
+        this.appendHeadersToLongestChain(chunk);
+        this.orphanChunks.splice(index, 1);
+      }
+    });
+  }
+
+  /** @private */
+  getOrphans() {
+    return this.orphanBlocks;
+  }
+
+  /** @private */
+  getOrphanChunks() {
+    return this.orphanChunks;
+  }
+
+  /** @private */
+  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
+   *
+   * @param {Object} header
+   * @param {Object[]} previousHeaders
+   * @return {boolean}
+   */
+  isValid(header, previousHeaders) {
+    return !!(Consensus.isValidBlockHeader(header, previousHeaders, this.network)
+      && !this.isDuplicate(header.hash));
+  }
+
+  /* eslint-disable no-param-reassign */
+  /**
+   * verifies the parent child connection
+   * between two adjacent dashcore.BlockHeader objects
+   *
+   * @param {Object} header
+   * @param {Object} previousHeader
+   * @return {boolean}
+   */
+  static isParentChild(header, previousHeader) {
+    if (utils.getCorrectedHash(header.prevHash) !== previousHeader.hash) {
+      return false;
+    }
+    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[]}
+   */
+  getLongestChain() {
+    return this.allBranches.sort((b1, b2) => b1 < b2)[0];
+  }
+
+  /**
+   * gets the block hash of the longest chain tip
+   *
+   * @return {string} hash
+   */
+  getTipHash() {
+    return this.getLongestChain().slice(-1)[0].hash;
+  }
+
+  /**
+   * gets the dashcore.BlockHeader object the longest chain tip
+   *
+   * @return {Object} header
+   */
+  getTipHeader() {
+    return this.getLongestChain().slice(-1)[0];
+  }
+
+  /**
+   * gets the dashcore.BlockHeader object for a specific block hash
+   *
+   * @param {string} hash
+   * @return {Object} header
+   */
+  getHeader(hash) {
+    return this.store.get(hash)
+      .then((blockInDB) => {
+        if (blockInDB) {
+          return blockInDB;
+        }
+
+        return this.getLongestChain().filter((h) => h.hash === hash)[0];
+      });
+  }
+
+  /**
+   * adds a valid header to the tip of the longest spv chain.
+   * If it cannot be connected to the tip it gets temporarily
+   * added to an orphan array for possible later reconnection
+   *
+   * @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;
+  }
+
+  /**
+   * adds an array of valid headers to the longest spv chain.
+   * If they cannot be connected to last tip they get temporarily
+   * added to an orphan array for possible later reconnection
+   *
+   * @param {Object[]|string[]|buffer[]} headers
+   * @return {boolean}
+   */
+  addHeaders(headers) {
+    if (headers.length === 1) {
+      if (!this.addHeader(headers[0])) {
+        throw new Error('Some headers are invalid');
+      } else {
+        return true;
+      }
+    }
+    const normalizedHeaders = headers.map((h) => utils.normalizeHeader(h));
+    const isOrphan = !SpvChain.isParentChild(normalizedHeaders[0], this.getTipHeader());
+
+    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');
+          }
+          return acc && true;
+        }
+        if (isOrphan) {
+          if (!this.isValid(header, previousHeaders)) {
+            throw new Error('Some headers are invalid');
+          }
+          return acc && true;
+        }
+        if (!this.isValid(header, this.getLongestChain())) {
+          throw new Error('Some headers are invalid');
+        }
+        return acc && true;
+      }, true,
+    );
+    if (!allValid) {
+      throw new Error('Some headers are invalid');
+    }
+    if (isOrphan) {
+      this.orphanChunks.push(normalizedHeaders);
+    } else {
+      this.appendHeadersToLongestChain(normalizedHeaders);
+    }
+    if (this.orphanChunks.length > 0) {
+      this.orphanChunksReconnect();
+    }
+    this.checkPruneBlocks();
+    return true;
+  }
+};
+
+module.exports = SpvChain;

package/lib/utils.js

@@ -0,0 +1,62 @@
+/* eslint no-underscore-dangle: ["error", { "allow": ["_getHash"] }] */
+/* eslint-disable no-bitwise */
+const DashUtil = require('@dashevo/dash-util');
+const dashcore = require('@dashevo/dashcore-lib');
+
+module.exports = {
+
+  getCorrectedHash(reversedHashObj) {
+    const clone = Buffer.alloc(32);
+    reversedHashObj.copy(clone);
+    return clone.reverse().toString('hex');
+  },
+  normalizeHeader(header) {
+    if (header instanceof dashcore.BlockHeader) {
+      return header;
+    }
+    if (Buffer.isBuffer(header) && header.length === 80) {
+      return new dashcore.BlockHeader(header);
+    }
+    if (typeof header === 'string' && header.length === 160) {
+      const buffer = Buffer.from(header, 'hex');
+      return new dashcore.BlockHeader(buffer);
+    }
+
+    const el = JSON.parse(JSON.stringify(header));
+
+    return new dashcore.BlockHeader({
+      version: el.version,
+      prevHash: DashUtil.toHash(el.previousblockhash || el.prevHash),
+      merkleRoot: (el.merkleroot || el.merkleRoot),
+      time: el.time,
+      bits: parseInt(el.bits, 16),
+      nonce: el.nonce,
+    });
+  },
+  getDgwBlock(header) {
+    return {
+      timestamp: header.timestamp,
+      target: header.bits,
+    };
+  },
+  validProofOfWork(header) {
+    const target = DashUtil.expandTarget(header.bits);
+    const hash = header._getHash().reverse();
+    return hash.compare(target) === -1;
+  },
+  createBlock(prev, bits) {
+    let i = 0;
+    let header = null;
+    do {
+      header = new dashcore.BlockHeader({
+        version: 2,
+        prevHash: prev ? prev._getHash() : DashUtil.nullHash,
+        merkleRoot: DashUtil.nullHash,
+        time: prev ? (prev.time + 1) : Math.floor(Date.now() / 1000),
+        bits,
+        nonce: i += 1,
+      });
+    } while (!this.validProofOfWork(header));
+    return header;
+  },
+};

package/package.json

@@ -0,0 +1,27 @@
+{
+  "name": "@dashevo/dash-spv",
+  "version": "0.23.0-alpha.1",
+  "description": "Repository containing SPV functions used by @dashevo",
+  "main": "index.js",
+  "scripts": {
+    "test": "mocha test/ --no-timeouts --recursive",
+    "lint": "eslint .",
+    "lint:fix": "eslint . --fix"
+  },
+  "author": "",
+  "license": "MIT",
+  "dependencies": {
+    "@dashevo/dark-gravity-wave": "^1.1.1",
+    "@dashevo/dash-util": "^2.0.3",
+    "@dashevo/dashcore-lib": "~0.19.44",
+    "levelup": "^4.4.0",
+    "memdown": "^5.1.0"
+  },
+  "devDependencies": {
+    "eslint": "^7.32.0",
+    "eslint-config-airbnb-base": "^14.2.1",
+    "eslint-plugin-import": "^2.24.2",
+    "mocha": "^9.1.2",
+    "should": "^13.2.3"
+  }
+}