Source: primitives/filter.js

  1. /*!
  2.  * filters.js - filter object for bcoin
  3.  * Copyright (c) 2019, the bcoin developers (MIT License).
  4.  * https://github.com/bcoin-org/bcoin
  5.  */
  7. 'use strict';
  9. const assert = require('bsert');
  10. const bio = require('bufio');
  11. const util = require('../utils/util');
  12. const consensus = require('../protocol/consensus');
  13. const {inspectSymbol} = require('../utils');
  15. /*
  16.  * Constants
  17.  */
  19. const EMPTY_BUFFER = Buffer.alloc(0);
  21. /**
  22.  * Filter
  23.  * Represents a GCSFilter.
  24.  * @alias module:primitives.Filter
  25.  * @property {Hash} hash
  26.  * @property {Number} index
  27.  */
  29. class Filter {
  30.   /**
  31.    * Create an filter.
  32.    * @constructor
  33.    * @param {Object?} options
  34.    */
  36.   constructor(options) {
  37.     this.header = consensus.ZERO_HASH;
  38.     this.filter = EMPTY_BUFFER;
  40.     if (options)
  41.       this.fromOptions(options);
  42.   }
  44.   /**
  45.    * Inject properties from options object.
  46.    * @private
  47.    * @param {Object} options
  48.    */
  50.   fromOptions(options) {
  51.     assert(options, 'Filter data is required.');
  52.     assert(Buffer.isBuffer(options.header));
  53.     assert(Buffer.isBuffer(options.filter));
  54.     this.header = options.header;
  55.     this.filter = options.filter;
  56.     return this;
  57.   }
  59.   /**
  60.    * Instantate outpoint from options object.
  61.    * @param {Object} options
  62.    * @returns {Filter}
  63.    */
  65.   static fromOptions(options) {
  66.     return new this().fromOptions(options);
  67.   }
  69.   /**
  70.    * Write filter to a buffer writer.
  71.    * @param {BufferWriter} bw
  72.    */
  74.   toWriter(bw) {
  75.     bw.writeHash(this.header);
  76.     bw.writeBytes(this.filter);
  77.     return bw;
  78.   }
  80.   /**
  81.    * Calculate size of filter.
  82.    * @returns {Number}
  83.    */
  85.   getSize() {
  86.     let size = 0;
  87.     size += 32;
  88.     size += this.filter.length;
  89.     return size;
  90.   }
  92.   /**
  93.    * Serialize filter.
  94.    * @returns {Buffer}
  95.    */
  97.   toRaw() {
  98.     const size = this.getSize();
  99.     return this.toWriter(bio.write(size)).render();
  100.   }
  102.   /**
  103.    * Inject properties from buffer reader.
  104.    * @private
  105.    * @param {BufferReader} br
  106.    */
  108.   fromReader(br) {
  109.     this.header = br.readHash();
  110.     this.filter = br.readBytes(br.getSize() - br.offset);
  111.     return this;
  112.   }
  114.   /**
  115.    * Inject properties from serialized data.
  116.    * @private
  117.    * @param {Buffer} data
  118.    */
  120.   fromRaw(data) {
  121.     return this.fromReader(bio.read(data));
  122.   }
  124.   /**
  125.    * Instantiate filter from a buffer reader.
  126.    * @param {BufferReader} br
  127.    * @returns {Filter}
  128.    */
  130.   static fromReader(br) {
  131.     return new this().fromReader(br);
  132.   }
  134.   /**
  135.    * Instantiate filter from serialized data.
  136.    * @param {Buffer} data
  137.    * @returns {Filter}
  138.    */
  140.   static fromRaw(data) {
  141.     return new this().fromRaw(data);
  142.   }
  144.   /**
  145.    * Inject properties from json object.
  146.    * @private
  147.    * @params {Object} json
  148.    */
  150.   fromJSON(json) {
  151.     assert(json, 'Filter data is required.');
  152.     assert(typeof json.filter === 'string', 'Filter must be a string.');
  153.     assert(typeof json.header === 'string', 'Header must be a string.');
  154.     this.filter = Buffer.from(json.filter);
  155.     this.header = Buffer.from(json.header);
  156.     return this;
  157.   }
  159.   /**
  160.    * Convert the filter to an object suitable
  161.    * for JSON serialization.
  162.    * @returns {Object}
  163.    */
  165.   toJSON() {
  166.     return {
  167.       filter: this.filter.toString('hex'),
  168.       header: util.revHex(this.header)
  169.     };
  170.   }
  172.   /**
  173.    * Instantiate filter from json object.
  174.    * @param {Object} json
  175.    * @returns {Filter}
  176.    */
  178.   static fromJSON(json) {
  179.     return new this().fromJSON(json);
  180.   }
  182.   /**
  183.    * Convert the filter to a user-friendly string.
  184.    * @returns {String}
  185.    */
  187.   [inspectSymbol]() {
  188.     return `<Filter: ${this.filter.toString('hex')}>`;
  189.   }
  191.   /**
  192.    * Test an object to see if it is an filter.
  193.    * @param {Object} obj
  194.    * @returns {Boolean}
  195.    */
  197.   static isFilter(obj) {
  198.     return obj instanceof Filter;
  199.   }
  200. }
  202. /*
  203.  * Expose
  204.  */
  206. module.exports = Filter;