@opcat-labs/opcat 1.0.0 → 1.0.2

package/{lib → esm}/block/block.js

@@ -1,13 +1,14 @@
 'use strict';
 
-var _ = require('../util/_');
-var BlockHeader = require('./blockheader');
-var BN = require('../crypto/bn');
-var BufferReader = require('../encoding/bufferreader');
-var BufferWriter = require('../encoding/bufferwriter');
-var Hash = require('../crypto/hash');
-var Transaction = require('../transaction');
-var $ = require('../util/preconditions');
+import _ from '../util/_.js';
+import BlockHeader from './blockheader.js';
+import MerkleBlock from './merkleblock.js';
+import BN from '../crypto/bn.js';
+import BufferReader from '../encoding/bufferreader.js';
+import BufferWriter from '../encoding/bufferwriter.js';
+import Hash from '../crypto/hash.js';
+import Transaction from '../transaction/index.js';
+import $ from '../util/preconditions.js';
 
 /**
  * Instantiate a Block from a Buffer, JSON object, or Object with
@@ -25,11 +26,17 @@ function Block(arg) {
   return this;
 }
 
+/**
+ * The maximum allowed size (in bytes) for a block.
+ * @type {number}
+ */
 Block.MAX_BLOCK_SIZE = 128000000;
 
+
 /**
- * @param {*} - A Buffer, JSON string or Object
- * @returns {Object} - An object representing block data
+ * Creates a Block instance from the given argument.
+ * @param {*} arg - The input to convert into a Block.
+ * @returns {Block} A new Block instance.
  * @throws {TypeError} - If the argument was not recognized
  * @private
  */
@@ -45,9 +52,11 @@ Block._from = function _from(arg) {
   return info;
 };
 
+
 /**
- * @param {Object} - A plain JavaScript object
- * @returns {Object} - An object representing block data
+ * Creates a Block instance from a plain object.
+ * @param {Object} data - The plain object containing block data.
+ * @returns {Block} The created Block instance.
  * @private
  */
 Block._fromObject = function _fromObject(data) {
@@ -66,19 +75,23 @@ Block._fromObject = function _fromObject(data) {
   return info;
 };
 
+
 /**
- * @param {Object} - A plain JavaScript object
- * @returns {Block} - An instance of block
+ * Creates a Block instance from a plain JavaScript object.
+ * @param {Object} obj - The source object to convert to a Block.
+ * @returns {Block} A new Block instance.
  */
 Block.fromObject = function fromObject(obj) {
   var info = Block._fromObject(obj);
   return new Block(info);
 };
 
+
 /**
- * @param {BufferReader} - Block data
- * @returns {Object} - An object representing the block data
+ * Creates a Block instance from a BufferReader.
  * @private
+ * @param {BufferReader} br - The buffer reader containing block data
+ * @returns {Block} The parsed Block instance
  */
 Block._fromBufferReader = function _fromBufferReader(br) {
   var info = {};
@@ -92,9 +105,11 @@ Block._fromBufferReader = function _fromBufferReader(br) {
   return info;
 };
 
+
 /**
- * @param {BufferReader} - A buffer reader of the block
- * @returns {Block} - An instance of block
+ * Creates a Block instance from a BufferReader.
+ * @param {BufferReader} br - The buffer reader containing block data.
+ * @returns {Block} The parsed Block instance.
  */
 Block.fromBufferReader = function fromBufferReader(br) {
   $.checkArgument(br, 'br is required');
@@ -102,26 +117,32 @@ Block.fromBufferReader = function fromBufferReader(br) {
   return new Block(info);
 };
 
+
 /**
- * @param {Buffer} - A buffer of the block
- * @returns {Block} - An instance of block
+ * Creates a Block instance from a buffer.
+ * @param {Buffer} buf - The input buffer to create the block from.
+ * @returns {Block} The created Block instance.
  */
 Block.fromBuffer = function fromBuffer(buf) {
   return Block.fromBufferReader(new BufferReader(buf));
 };
 
+
 /**
- * @param {string} - str - A hex encoded string of the block
- * @returns {Block} - A hex encoded string of the block
+ * Creates a Block instance from a string representation.
+ * @param {string} str - The string to parse into a Block.
+ * @returns {Block} The parsed Block instance.
  */
 Block.fromString = function fromString(str) {
   var buf = Buffer.from(str, 'hex');
   return Block.fromBuffer(buf);
 };
 
+
 /**
- * @param {Binary} - Raw block binary data or buffer
- * @returns {Block} - An instance of block
+ * Creates a Block instance from raw block data.
+ * @param {Object} data - The raw block data to convert.
+ * @returns {Block} A new Block instance.
  */
 Block.fromRawBlock = function fromRawBlock(data) {
   if (!Buffer.isBuffer(data)) {
@@ -133,8 +154,10 @@ Block.fromRawBlock = function fromRawBlock(data) {
   return new Block(info);
 };
 
+
 /**
- * @returns {Object} - A plain object with the block properties
+ * Converts the Block instance to a plain object (also aliased as toJSON).
+ * @returns {Object} The plain object representation of the Block.
  */
 Block.prototype.toObject = Block.prototype.toJSON = function toObject() {
   var transactions = [];
@@ -147,14 +170,17 @@ Block.prototype.toObject = Block.prototype.toJSON = function toObject() {
   };
 };
 
+
 /**
- * @returns {Buffer} - A buffer of the block
+ * Converts the block to a buffer representation.
+ * @returns {Buffer} The buffer containing the block data.
  */
 Block.prototype.toBuffer = function toBuffer() {
   return this.toBufferWriter().concat();
 };
 
 /**
+ * Returns the string representation of the Block instance.
  * @returns {string} - A hex encoded string of the block
  */
 Block.prototype.toString = function toString() {
@@ -259,7 +285,17 @@ var idProperty = {
   },
   set: _.noop,
 };
+/**
+ * Defines the `id` property on the Block prototype using the provided `idProperty` descriptor.
+ * @memberof Block.prototype
+ * @name id
+ */
 Object.defineProperty(Block.prototype, 'id', idProperty);
+/**
+ * Defines a property 'hash' on Block.prototype using idProperty as the descriptor.
+ * @memberof Block.prototype
+ * @name hash
+ */
 Object.defineProperty(Block.prototype, 'hash', idProperty);
 
 /**
@@ -269,9 +305,28 @@ Block.prototype.inspect = function inspect() {
   return '<Block ' + this.id + '>';
 };
 
+/**
+ * Object containing constant values used by the Block module.
+ * @namespace Block.Values
+ */
 Block.Values = {
   START_OF_BLOCK: 8, // Start of block in raw block data
   NULL_HASH: Buffer.from('0000000000000000000000000000000000000000000000000000000000000000', 'hex'),
 };
 
-module.exports = Block;
+
+/**
+ * Assigns the BlockHeader class to the Block namespace.
+ * @memberof Block
+ * @name BlockHeader
+ */
+Block.BlockHeader = BlockHeader;
+
+/**
+ * Assigns the MerkleBlock class to the Block namespace.
+ * @memberof Block
+ * @name MerkleBlock
+ */
+Block.MerkleBlock = MerkleBlock;
+
+export default Block;

package/esm/block/blockheader.js

@@ -0,0 +1,296 @@
+'use strict';
+
+import _ from '../util/_.js';
+import BN from '../crypto/bn.js';
+import BufferReader from '../encoding/bufferreader.js';
+import BufferWriter from '../encoding/bufferwriter.js';
+import Hash from '../crypto/hash.js';
+import $ from '../util/preconditions.js';
+
+var GENESIS_BITS = 0x1d00ffff;
+
+/**
+ * Instantiate a BlockHeader from a Buffer, JSON object, or Object with
+ * the properties of the BlockHeader
+ *
+ * @param {*} - A Buffer, JSON string, or Object
+ * @returns {BlockHeader} - An instance of block header
+ * @constructor
+ */
+function BlockHeader(arg) {
+  if (!(this instanceof BlockHeader)) {
+    return new BlockHeader(arg);
+  }
+  var info = BlockHeader._from(arg);
+  this.version = info.version;
+  this.prevHash = info.prevHash;
+  this.merkleRoot = info.merkleRoot;
+  this.time = info.time;
+  this.timestamp = info.time;
+  this.bits = info.bits;
+  this.nonce = info.nonce;
+
+  if (info.hash) {
+    $.checkState(
+      this.hash === info.hash,
+      'Argument object hash property does not match block hash.',
+    );
+  }
+
+  return this;
+}
+
+/**
+ * @param {*} - A Buffer, JSON string or Object
+ * @returns {Object} - An object representing block header data
+ * @throws {TypeError} - If the argument was not recognized
+ * @private
+ */
+BlockHeader._from = function _from(arg) {
+  var info = {};
+  if (Buffer.isBuffer(arg)) {
+    info = BlockHeader._fromBufferReader(BufferReader(arg));
+  } else if (_.isObject(arg)) {
+    info = BlockHeader._fromObject(arg);
+  } else {
+    throw new TypeError('Unrecognized argument for BlockHeader');
+  }
+  return info;
+};
+
+/**
+ * @param {Object} - A JSON string
+ * @returns {Object} - An object representing block header data
+ * @private
+ */
+BlockHeader._fromObject = function _fromObject(data) {
+  $.checkArgument(data, 'data is required');
+  var prevHash = data.prevHash;
+  var merkleRoot = data.merkleRoot;
+  if (_.isString(data.prevHash)) {
+    prevHash = Buffer.from(data.prevHash, 'hex').reverse();
+  }
+  if (_.isString(data.merkleRoot)) {
+    merkleRoot = Buffer.from(data.merkleRoot, 'hex').reverse();
+  }
+  var info = {
+    hash: data.hash,
+    version: data.version,
+    prevHash: prevHash,
+    merkleRoot: merkleRoot,
+    time: data.time,
+    timestamp: data.time,
+    bits: data.bits,
+    nonce: data.nonce,
+  };
+  return info;
+};
+
+/**
+ * @param {Object} - A plain JavaScript object
+ * @returns {BlockHeader} - An instance of block header
+ */
+BlockHeader.fromObject = function fromObject(obj) {
+  var info = BlockHeader._fromObject(obj);
+  return new BlockHeader(info);
+};
+
+/**
+ * @param {Binary} - Raw block binary data or buffer
+ * @returns {BlockHeader} - An instance of block header
+ */
+BlockHeader.fromRawBlock = function fromRawBlock(data) {
+  if (!Buffer.isBuffer(data)) {
+    data = Buffer.from(data, 'binary');
+  }
+  var br = BufferReader(data);
+  br.pos = BlockHeader.Constants.START_OF_HEADER;
+  var info = BlockHeader._fromBufferReader(br);
+  return new BlockHeader(info);
+};
+
+/**
+ * @param {Buffer} - A buffer of the block header
+ * @returns {BlockHeader} - An instance of block header
+ */
+BlockHeader.fromBuffer = function fromBuffer(buf) {
+  var info = BlockHeader._fromBufferReader(BufferReader(buf));
+  return new BlockHeader(info);
+};
+
+/**
+ * @param {string} - A hex encoded buffer of the block header
+ * @returns {BlockHeader} - An instance of block header
+ */
+BlockHeader.fromString = function fromString(str) {
+  var buf = Buffer.from(str, 'hex');
+  return BlockHeader.fromBuffer(buf);
+};
+
+/**
+ * @param {BufferReader} - A BufferReader of the block header
+ * @returns {Object} - An object representing block header data
+ * @private
+ */
+BlockHeader._fromBufferReader = function _fromBufferReader(br) {
+  var info = {};
+  info.version = br.readInt32LE();
+  info.prevHash = br.read(32);
+  info.merkleRoot = br.read(32);
+  info.time = br.readUInt32LE();
+  info.bits = br.readUInt32LE();
+  info.nonce = br.readUInt32LE();
+  return info;
+};
+
+/**
+ * @param {BufferReader} - A BufferReader of the block header
+ * @returns {BlockHeader} - An instance of block header
+ */
+BlockHeader.fromBufferReader = function fromBufferReader(br) {
+  var info = BlockHeader._fromBufferReader(br);
+  return new BlockHeader(info);
+};
+
+/**
+ * @returns {Object} - A plain object of the BlockHeader
+ */
+BlockHeader.prototype.toObject = BlockHeader.prototype.toJSON = function toObject() {
+  return {
+    hash: this.hash,
+    version: this.version,
+    prevHash: Buffer.from(this.prevHash).reverse().toString('hex'),
+    merkleRoot: Buffer.from(this.merkleRoot).reverse().toString('hex'),
+    time: this.time,
+    bits: this.bits,
+    nonce: this.nonce,
+  };
+};
+
+/**
+ * @returns {Buffer} - A Buffer of the BlockHeader
+ */
+BlockHeader.prototype.toBuffer = function toBuffer() {
+  return this.toBufferWriter().concat();
+};
+
+/**
+ * @returns {string} - A hex encoded string of the BlockHeader
+ */
+BlockHeader.prototype.toString = function toString() {
+  return this.toBuffer().toString('hex');
+};
+
+/**
+ * @param {BufferWriter} - An existing instance BufferWriter
+ * @returns {BufferWriter} - An instance of BufferWriter representation of the BlockHeader
+ */
+BlockHeader.prototype.toBufferWriter = function toBufferWriter(bw) {
+  if (!bw) {
+    bw = new BufferWriter();
+  }
+  bw.writeInt32LE(this.version);
+  bw.write(this.prevHash);
+  bw.write(this.merkleRoot);
+  bw.writeUInt32LE(this.time);
+  bw.writeUInt32LE(this.bits);
+  bw.writeUInt32LE(this.nonce);
+  return bw;
+};
+
+/**
+ * Returns the target difficulty for this block
+ * @param {Number} bits
+ * @returns {BN} An instance of BN with the decoded difficulty bits
+ */
+BlockHeader.prototype.getTargetDifficulty = function getTargetDifficulty(bits) {
+  bits = bits || this.bits;
+
+  var target = new BN(bits & 0xffffff);
+  var mov = 8 * ((bits >>> 24) - 3);
+  while (mov-- > 0) {
+    target = target.mul(new BN(2));
+  }
+  return target;
+};
+
+/**
+ * @link https://en.bitcoin.it/wiki/Difficulty
+ * @return {Number}
+ */
+BlockHeader.prototype.getDifficulty = function getDifficulty() {
+  var difficulty1TargetBN = this.getTargetDifficulty(GENESIS_BITS).mul(new BN(Math.pow(10, 8)));
+  var currentTargetBN = this.getTargetDifficulty();
+
+  var difficultyString = difficulty1TargetBN.div(currentTargetBN).toString(10);
+  var decimalPos = difficultyString.length - 8;
+  difficultyString =
+    difficultyString.slice(0, decimalPos) + '.' + difficultyString.slice(decimalPos);
+
+  return parseFloat(difficultyString);
+};
+
+/**
+ * @returns {Buffer} - The little endian hash buffer of the header
+ * @private
+ */
+BlockHeader.prototype._getHash = function hash() {
+  var buf = this.toBuffer();
+  return Hash.sha256sha256(buf);
+};
+
+var idProperty = {
+  configurable: false,
+  enumerable: true,
+  /**
+   * @returns {string} - The big endian hash buffer of the header
+   */
+  get: function () {
+    if (!this._id) {
+      this._id = BufferReader(this._getHash()).readReverse().toString('hex');
+    }
+    return this._id;
+  },
+  set: _.noop,
+};
+Object.defineProperty(BlockHeader.prototype, 'id', idProperty);
+Object.defineProperty(BlockHeader.prototype, 'hash', idProperty);
+
+/**
+ * @returns {Boolean} - If timestamp is not too far in the future
+ */
+BlockHeader.prototype.validTimestamp = function validTimestamp() {
+  var currentTime = Math.round(new Date().getTime() / 1000);
+  if (this.time > currentTime + BlockHeader.Constants.MAX_TIME_OFFSET) {
+    return false;
+  }
+  return true;
+};
+
+/**
+ * @returns {Boolean} - If the proof-of-work hash satisfies the target difficulty
+ */
+BlockHeader.prototype.validProofOfWork = function validProofOfWork() {
+  var pow = new BN(this.id, 'hex');
+  var target = this.getTargetDifficulty();
+
+  if (pow.cmp(target) > 0) {
+    return false;
+  }
+  return true;
+};
+
+/**
+ * @returns {string} - A string formatted for the console
+ */
+BlockHeader.prototype.inspect = function inspect() {
+  return '<BlockHeader ' + this.id + '>';
+};
+
+BlockHeader.Constants = {
+  START_OF_HEADER: 8, // Start buffer position in raw block data
+  MAX_TIME_OFFSET: 2 * 60 * 60, // The max a timestamp can be in the future
+  LARGEST_HASH: new BN('10000000000000000000000000000000000000000000000000000000000000000', 'hex'),
+};
+
+export default BlockHeader;

package/esm/block/index.js

@@ -0,0 +1,2 @@
+import Block from './block.js';
+export default Block;