Source: primitives/memblock.js

  1. /*!
  2.  * memblock.js - memblock block object for bcoin
  3.  * Copyright (c) 2014-2015, Fedor Indutny (MIT License)
  4.  * Copyright (c) 2014-2017, Christopher Jeffrey (MIT License).
  5.  * https://github.com/bcoin-org/bcoin
  6.  */
  8. 'use strict';
  10. const bio = require('bufio');
  11. const AbstractBlock = require('./abstractblock');
  12. const Block = require('./block');
  13. const Headers = require('./headers');
  14. const Script = require('../script/script');
  15. const DUMMY = Buffer.alloc(0);
  17. /**
  18.  * Mem Block
  19.  * A block object which is essentially a "placeholder"
  20.  * for a full {@link Block} object. The v8 garbage
  21.  * collector's head will explode if there is too much
  22.  * data on the javascript heap. Blocks can currently
  23.  * be up to 1mb in size. In the future, they may be
  24.  * 2mb, 8mb, or maybe 20mb, who knows? A MemBlock
  25.  * is an optimization in Bcoin which defers parsing of
  26.  * the serialized transactions (the block Buffer) until
  27.  * the block has passed through the chain queue and
  28.  * is about to enter the chain. This keeps a lot data
  29.  * off of the javascript heap for most of the time a
  30.  * block even exists in memory, and manages to keep a
  31.  * lot of strain off of the garbage collector. Having
  32.  * 500mb of blocks on the js heap would not be a good
  33.  * thing.
  34.  * @alias module:primitives.MemBlock
  35.  * @extends AbstractBlock
  36.  */
  38. class MemBlock extends AbstractBlock {
  39.   /**
  40.    * Create a mem block.
  41.    * @constructor
  42.    */
  44.   constructor() {
  45.     super();
  47.     this._raw = DUMMY;
  48.   }
  50.   /**
  51.    * Test whether the block is a memblock.
  52.    * @returns {Boolean}
  53.    */
  55.   isMemory() {
  56.     return true;
  57.   }
  59.   /**
  60.    * Serialize the block headers.
  61.    * @returns {Buffer}
  62.    */
  64.   toHead() {
  65.     return this._raw.slice(0, 80);
  66.   }
  68.   /**
  69.    * Get the full block size.
  70.    * @returns {Number}
  71.    */
  73.   getSize() {
  74.     return this._raw.length;
  75.   }
  77.   /**
  78.    * Verify the block.
  79.    * @returns {Boolean}
  80.    */
  82.   verifyBody() {
  83.     return true;
  84.   }
  86.   /**
  87.    * Retrieve the coinbase height
  88.    * from the coinbase input script.
  89.    * @returns {Number} height (-1 if not present).
  90.    */
  92.   getCoinbaseHeight() {
  93.     if (this.version < 2)
  94.       return -1;
  96.     try {
  97.       return this.parseCoinbaseHeight();
  98.     } catch (e) {
  99.       return -1;
  100.     }
  101.   }
  103.   /**
  104.    * Parse the coinbase height
  105.    * from the coinbase input script.
  106.    * @private
  107.    * @returns {Number} height (-1 if not present).
  108.    */
  110.   parseCoinbaseHeight() {
  111.     const br = bio.read(this._raw, true);
  113.     br.seek(80);
  115.     const txCount = br.readVarint();
  117.     if (txCount === 0)
  118.       return -1;
  120.     br.seek(4);
  122.     let inCount = br.readVarint();
  124.     if (inCount === 0) {
  125.       if (br.readU8() !== 0)
  126.         inCount = br.readVarint();
  127.     }
  129.     if (inCount === 0)
  130.       return -1;
  132.     br.seek(36);
  134.     const script = br.readVarBytes();
  136.     return Script.getCoinbaseHeight(script);
  137.   }
  139.   /**
  140.    * Inject properties from serialized data.
  141.    * @private
  142.    * @param {Buffer} data
  143.    */
  145.   fromRaw(data) {
  146.     const br = bio.read(data, true);
  148.     this.readHead(br);
  150.     this._raw = br.data;
  152.     return this;
  153.   }
  155.   /**
  156.    * Insantiate a memblock from serialized data.
  157.    * @param {Buffer} data
  158.    * @returns {MemBlock}
  159.    */
  161.   static fromRaw(data) {
  162.     return new this().fromRaw(data);
  163.   }
  165.   /**
  166.    * Return serialized block data.
  167.    * @returns {Buffer}
  168.    */
  170.   toRaw() {
  171.     return this._raw;
  172.   }
  174.   /**
  175.    * Return serialized block data.
  176.    * @returns {Buffer}
  177.    */
  179.   toNormal() {
  180.     return this._raw;
  181.   }
  183.   /**
  184.    * Parse the serialized block data
  185.    * and create an actual {@link Block}.
  186.    * @returns {Block}
  187.    * @throws Parse error
  188.    */
  190.   toBlock() {
  191.     const block = Block.fromRaw(this._raw);
  193.     block._hash = this._hash;
  194.     block._hhash = this._hhash;
  196.     return block;
  197.   }
  199.   /**
  200.    * Convert the block to a headers object.
  201.    * @returns {Headers}
  202.    */
  204.   toHeaders() {
  205.     return Headers.fromBlock(this);
  206.   }
  208.   /**
  209.    * Test whether an object is a MemBlock.
  210.    * @param {Object} obj
  211.    * @returns {Boolean}
  212.    */
  214.   static isMemBlock(obj) {
  215.     return obj instanceof MemBlock;
  216.   }
  217. }
  219. /*
  220.  * Expose
  221.  */
  223. module.exports = MemBlock;