mempool: classify.

lib/mempool/fees.js

@@ -38,15 +38,17 @@ const PRI_SPACING = 2;
 /**
  * Confirmation stats.
  * @alias module:mempool.ConfirmStats
+ */
+
+class ConfirmStats {
+  /**
+   * Create confirmation stats.
    * @constructor
    * @param {String} type
    * @param {Logger?} logger
    */
 
-function ConfirmStats(type, logger) {
+  constructor(type, logger) {
-  if (!(this instanceof ConfirmStats))
-    return new ConfirmStats(type, logger);
-
     this.logger = Logger.global;
 
     this.type = type;
@@ -70,9 +72,9 @@ function ConfirmStats(type, logger) {
       assert(typeof logger === 'object');
       this.logger = logger.context('fees');
     }
-}
+  }
 
-/**
+  /**
    * Initialize stats.
    * @param {Array} buckets
    * @param {Number} maxConfirms
@@ -80,7 +82,7 @@ function ConfirmStats(type, logger) {
    * @private
    */
 
-ConfirmStats.prototype.init = function init(buckets, maxConfirms, decay) {
+  init(buckets, maxConfirms, decay) {
     this.maxConfirms = maxConfirms;
     this.decay = decay;
 
@@ -107,14 +109,14 @@ ConfirmStats.prototype.init = function init(buckets, maxConfirms, decay) {
     this.txAvg = new Float64Array(buckets.length);
     this.curBlockVal = new Float64Array(buckets.length);
     this.avg = new Float64Array(buckets.length);
-};
+  }
 
-/**
+  /**
    * Clear data for the current block.
    * @param {Number} height
    */
 
-ConfirmStats.prototype.clearCurrent = function clearCurrent(height) {
+  clearCurrent(height) {
     for (let i = 0; i < this.buckets.length; i++) {
       this.oldUnconfTX[i] = this.unconfTX[height % this.unconfTX.length][i];
       this.unconfTX[height % this.unconfTX.length][i] = 0;
@@ -123,15 +125,15 @@ ConfirmStats.prototype.clearCurrent = function clearCurrent(height) {
       this.curBlockTX[i] = 0;
       this.curBlockVal[i] = 0;
     }
-};
+  }
 
-/**
+  /**
    * Record a rate or priority based on number of blocks to confirm.
    * @param {Number} blocks - Blocks to confirm.
    * @param {Rate|Number} val - Rate or priority.
    */
 
-ConfirmStats.prototype.record = function record(blocks, val) {
+  record(blocks, val) {
     if (blocks < 1)
       return;
 
@@ -142,13 +144,13 @@ ConfirmStats.prototype.record = function record(blocks, val) {
 
     this.curBlockTX[bucketIndex]++;
     this.curBlockVal[bucketIndex] += val;
-};
+  }
 
-/**
+  /**
    * Update moving averages.
    */
 
-ConfirmStats.prototype.updateAverages = function updateAverages() {
+  updateAverages() {
     for (let i = 0; i < this.buckets.length; i++) {
       for (let j = 0; j < this.confAvg.length; j++) {
         this.confAvg[j][i] =
@@ -157,9 +159,9 @@ ConfirmStats.prototype.updateAverages = function updateAverages() {
       this.avg[i] = this.avg[i] * this.decay + this.curBlockVal[i];
       this.txAvg[i] = this.txAvg[i] * this.decay + this.curBlockTX[i];
     }
-};
+  }
 
-/**
+  /**
    * Estimate the median value for rate or priority.
    * @param {Number} target - Confirmation target.
    * @param {Number} needed - Sufficient tx value.
@@ -169,7 +171,7 @@ ConfirmStats.prototype.updateAverages = function updateAverages() {
    * @returns {Rate|Number} Returns -1 on error.
    */
 
-ConfirmStats.prototype.estimateMedian = function estimateMedian(target, needed, breakpoint, greater, height) {
+  estimateMedian(target, needed, breakpoint, greater, height) {
     const max = this.buckets.length - 1;
     const start = greater ? max : 0;
     const step = greater ? -1 : 1;
@@ -233,31 +235,31 @@ ConfirmStats.prototype.estimateMedian = function estimateMedian(target, needed,
     }
 
     return median;
-};
+  }
 
-/**
+  /**
    * Add a transaction's rate/priority to be tracked.
    * @param {Number} height - Block height.
    * @param {Number} val
    * @returns {Number} Bucket index.
    */
 
-ConfirmStats.prototype.addTX = function addTX(height, val) {
+  addTX(height, val) {
     const bucketIndex = this.bucketMap.search(val);
     const blockIndex = height % this.unconfTX.length;
     this.unconfTX[blockIndex][bucketIndex]++;
     this.logger.spam('Adding tx to %s.', this.type);
     return bucketIndex;
-};
+  }
 
-/**
+  /**
    * Remove a transaction from tracking.
    * @param {Number} entryHeight
    * @param {Number} bestHeight
    * @param {Number} bucketIndex
    */
 
-ConfirmStats.prototype.removeTX = function removeTX(entryHeight, bestHeight, bucketIndex) {
+  removeTX(entryHeight, bestHeight, bucketIndex) {
     let blocksAgo = bestHeight - entryHeight;
 
     if (bestHeight === 0)
@@ -284,14 +286,14 @@ ConfirmStats.prototype.removeTX = function removeTX(entryHeight, bestHeight, buc
          blockIndex, bucketIndex);
       }
     }
-};
+  }
 
-/**
+  /**
    * Get serialization size.
    * @returns {Number}
    */
 
-ConfirmStats.prototype.getSize = function getSize() {
+  getSize() {
     let size = 0;
 
     size += 8;
@@ -306,14 +308,14 @@ ConfirmStats.prototype.getSize = function getSize() {
       size += sizeArray(this.confAvg[i]);
 
     return size;
-};
+  }
 
-/**
+  /**
    * Serialize confirm stats.
    * @returns {Buffer}
    */
 
-ConfirmStats.prototype.toRaw = function toRaw() {
+  toRaw() {
     const size = this.getSize();
     const bw = bio.write(size);
 
@@ -327,16 +329,16 @@ ConfirmStats.prototype.toRaw = function toRaw() {
       writeArray(bw, this.confAvg[i]);
 
     return bw.render();
-};
+  }
 
-/**
+  /**
    * Inject properties from serialized data.
    * @private
    * @param {Buffer} data
    * @returns {ConfirmStats}
    */
 
-ConfirmStats.prototype.fromRaw = function fromRaw(data) {
+  fromRaw(data) {
     const br = bio.read(data);
     const decay = br.readDouble();
     const buckets = readArray(br);
@@ -375,9 +377,9 @@ ConfirmStats.prototype.fromRaw = function fromRaw(data) {
     this.confAvg = confAvg;
 
     return this;
-};
+  }
 
-/**
+  /**
    * Instantiate confirm stats from serialized data.
    * @param {Buffer} data
    * @param {String} type
@@ -385,21 +387,25 @@ ConfirmStats.prototype.fromRaw = function fromRaw(data) {
    * @returns {ConfirmStats}
    */
 
-ConfirmStats.fromRaw = function fromRaw(data, type, logger) {
+  static fromRaw(data, type, logger) {
     return new ConfirmStats(type, logger).fromRaw(data);
-};
+  }
+}
 
 /**
+ * Policy Estimator
  * Estimator for fees and priority.
  * @alias module:mempool.PolicyEstimator
+ */
+
+class PolicyEstimator {
+  /**
+   * Create an estimator.
    * @constructor
    * @param {Logger?} logger
    */
 
-function PolicyEstimator(logger) {
+  constructor(logger) {
-  if (!(this instanceof PolicyEstimator))
-    return new PolicyEstimator(logger);
-
     this.logger = Logger.global;
 
     this.minTrackedFee = MIN_FEERATE;
@@ -428,22 +434,14 @@ function PolicyEstimator(logger) {
       this.feeStats.logger = this.logger;
       this.priStats.logger = this.logger;
     }
-}
+  }
 
-/**
+  /**
- * Serialization version.
- * @const {Number}
- * @default
- */
-
-PolicyEstimator.VERSION = 0;
-
-/**
    * Initialize the estimator.
    * @private
    */
 
-PolicyEstimator.prototype.init = function init() {
+  init() {
     const minFee = this.minTrackedFee;
     const minPri = this.minTrackedPri;
 
@@ -463,13 +461,13 @@ PolicyEstimator.prototype.init = function init() {
 
     this.feeStats.init(fee, MAX_BLOCK_CONFIRMS, DEFAULT_DECAY);
     this.priStats.init(priority, MAX_BLOCK_CONFIRMS, DEFAULT_DECAY);
-};
+  }
 
-/**
+  /**
    * Reset the estimator.
    */
 
-PolicyEstimator.prototype.reset = function reset() {
+  reset() {
     this.feeUnlikely = 0;
     this.feeLikely = INF_FEERATE;
     this.priUnlikely = 0;
@@ -479,14 +477,14 @@ PolicyEstimator.prototype.reset = function reset() {
     this.bestHeight = 0;
 
     this.init();
-};
+  }
 
-/**
+  /**
    * Stop tracking a tx. Remove from map.
    * @param {Hash} hash
    */
 
-PolicyEstimator.prototype.removeTX = function removeTX(hash) {
+  removeTX(hash) {
     const item = this.map.get(hash);
 
     if (!item) {
@@ -497,45 +495,45 @@ PolicyEstimator.prototype.removeTX = function removeTX(hash) {
     this.feeStats.removeTX(item.blockHeight, this.bestHeight, item.bucketIndex);
 
     this.map.delete(hash);
-};
+  }
 
-/**
+  /**
    * Test whether a fee should be used for calculation.
    * @param {Amount} fee
    * @param {Number} priority
    * @returns {Boolean}
    */
 
-PolicyEstimator.prototype.isFeePoint = function isFeePoint(fee, priority) {
+  isFeePoint(fee, priority) {
     if ((priority < this.minTrackedPri && fee >= this.minTrackedFee)
         || (priority < this.priUnlikely && fee > this.feeLikely)) {
       return true;
     }
     return false;
-};
+  }
 
-/**
+  /**
    * Test whether a priority should be used for calculation.
    * @param {Amount} fee
    * @param {Number} priority
    * @returns {Boolean}
    */
 
-PolicyEstimator.prototype.isPriPoint = function isPriPoint(fee, priority) {
+  isPriPoint(fee, priority) {
     if ((fee < this.minTrackedFee && priority >= this.minTrackedPri)
         || (fee < this.feeUnlikely && priority > this.priLikely)) {
       return true;
     }
     return false;
-};
+  }
 
-/**
+  /**
    * Process a mempool entry.
    * @param {MempoolEntry} entry
    * @param {Boolean} current - Whether the chain is synced.
    */
 
-PolicyEstimator.prototype.processTX = function processTX(entry, current) {
+  processTX(entry, current) {
     const height = entry.height;
     const hash = entry.hash('hex');
 
@@ -575,15 +573,15 @@ PolicyEstimator.prototype.processTX = function processTX(entry, current) {
     } else {
       this.logger.spam('Not adding tx %s.', entry.txid());
     }
-};
+  }
 
-/**
+  /**
    * Process an entry being removed from the mempool.
    * @param {Number} height - Block height.
    * @param {MempoolEntry} entry
    */
 
-PolicyEstimator.prototype.processBlockTX = function processBlockTX(height, entry) {
+  processBlockTX(height, entry) {
     // Requires other mempool txs in order to be confirmed. Ignore.
     if (entry.dependencies)
       return;
@@ -607,16 +605,16 @@ PolicyEstimator.prototype.processBlockTX = function processBlockTX(height, entry
       this.priStats.record(blocks, priority);
     else if (this.isFeePoint(rate, priority))
       this.feeStats.record(blocks, rate);
-};
+  }
 
-/**
+  /**
    * Process a block of transaction entries being removed from the mempool.
    * @param {Number} height - Block height.
    * @param {MempoolEntry[]} entries
    * @param {Boolean} current - Whether the chain is synced.
    */
 
-PolicyEstimator.prototype.processBlock = function processBlock(height, entries, current) {
+  processBlock(height, entries, current) {
     // Ignore reorgs.
     if (height <= this.bestHeight)
       return;
@@ -674,16 +672,16 @@ PolicyEstimator.prototype.processBlock = function processBlock(height, entries,
       entries.length, this.map.size);
 
     this.logger.debug('New fee rate: %d.', this.estimateFee());
-};
+  }
 
-/**
+  /**
    * Estimate a fee rate.
    * @param {Number} [target=1] - Confirmation target.
    * @param {Boolean} [smart=true] - Smart estimation.
    * @returns {Rate}
    */
 
-PolicyEstimator.prototype.estimateFee = function estimateFee(target, smart) {
+  estimateFee(target, smart) {
     if (!target)
       target = 1;
 
@@ -718,16 +716,16 @@ PolicyEstimator.prototype.estimateFee = function estimateFee(target, smart) {
       return 0;
 
     return Math.floor(rate);
-};
+  }
 
-/**
+  /**
    * Estimate a priority.
    * @param {Number} [target=1] - Confirmation target.
    * @param {Boolean} [smart=true] - Smart estimation.
    * @returns {Number}
    */
 
-PolicyEstimator.prototype.estimatePriority = function estimatePriority(target, smart) {
+  estimatePriority(target, smart) {
     if (!target)
       target = 1;
 
@@ -758,26 +756,26 @@ PolicyEstimator.prototype.estimatePriority = function estimatePriority(target, s
       return 0;
 
     return Math.floor(priority);
-};
+  }
 
-/**
+  /**
    * Get serialization size.
    * @returns {Number}
    */
 
-PolicyEstimator.prototype.getSize = function getSize() {
+  getSize() {
     let size = 0;
     size += 5;
     size += encoding.sizeVarlen(this.feeStats.getSize());
     return size;
-};
+  }
 
-/**
+  /**
    * Serialize the estimator.
    * @returns {Buffer}
    */
 
-PolicyEstimator.prototype.toRaw = function toRaw() {
+  toRaw() {
     const size = this.getSize();
     const bw = bio.write(size);
 
@@ -786,16 +784,16 @@ PolicyEstimator.prototype.toRaw = function toRaw() {
     bw.writeVarBytes(this.feeStats.toRaw());
 
     return bw.render();
-};
+  }
 
-/**
+  /**
    * Inject properties from serialized data.
    * @private
    * @param {Buffer} data
    * @returns {PolicyEstimator}
    */
 
-PolicyEstimator.prototype.fromRaw = function fromRaw(data) {
+  fromRaw(data) {
     const br = bio.read(data);
 
     if (br.readU8() !== PolicyEstimator.VERSION)
@@ -805,65 +803,85 @@ PolicyEstimator.prototype.fromRaw = function fromRaw(data) {
     this.feeStats.fromRaw(br.readVarBytes());
 
     return this;
-};
+  }
 
-/**
+  /**
    * Instantiate a policy estimator from serialized data.
    * @param {Buffer} data
    * @param {Logger?} logger
    * @returns {PolicyEstimator}
    */
 
-PolicyEstimator.fromRaw = function fromRaw(data, logger) {
+  static fromRaw(data, logger) {
     return new PolicyEstimator(logger).fromRaw(data);
-};
+  }
 
-/**
+  /**
    * Inject properties from estimator.
    * @param {PolicyEstimator} estimator
    * @returns {PolicyEstimator}
    */
 
-PolicyEstimator.prototype.inject = function inject(estimator) {
+  inject(estimator) {
     this.bestHeight = estimator.bestHeight;
     this.feeStats = estimator.feeStats;
     return this;
-};
+  }
+}
 
 /**
- * StatEntry
+ * Serialization version.
+ * @const {Number}
+ * @default
+ */
+
+PolicyEstimator.VERSION = 0;
+
+/**
+ * Stat Entry
  * @alias module:mempool.StatEntry
  * @ignore
  */
 
-function StatEntry() {
+class StatEntry {
+  /**
+   * StatEntry
+   * @constructor
+   */
+
+  constructor() {
     this.blockHeight = -1;
     this.bucketIndex = -1;
+  }
 }
 
 /**
- * DoubleMap
+ * Double Map
  * @alias module:mempool.DoubleMap
  * @ignore
  */
 
-function DoubleMap() {
+class DoubleMap {
-  if (!(this instanceof DoubleMap))
+  /**
-    return new DoubleMap();
+   * DoubleMap
+   * @constructor
+   */
 
+  constructor() {
     this.buckets = [];
-}
+  }
 
-DoubleMap.prototype.insert = function insert(key, value) {
+  insert(key, value) {
     const i = binary.search(this.buckets, key, compare, true);
     this.buckets.splice(i, 0, [key, value]);
-};
+  }
 
-DoubleMap.prototype.search = function search(key) {
+  search(key) {
     assert(this.buckets.length !== 0, 'Cannot search.');
     const i = binary.search(this.buckets, key, compare, true);
     return this.buckets[i][1];
-};
+  }
+}
 
 /*
  * Helpers
@@ -898,8 +916,4 @@ function readArray(br) {
  * Expose
  */
 
-exports = PolicyEstimator;
+module.exports = PolicyEstimator;
-exports.PolicyEstimator = PolicyEstimator;
-exports.ConfirmStats = ConfirmStats;
-
-module.exports = exports;