xpi-ts 0.2.13 → 0.2.15

package/dist/cjs/lib/bitcore/block/blockheader.js

@@ -1,23 +1,27 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.BlockHeader = void 0;
+const buffer_1 = require("buffer/");
 const preconditions_js_1 = require("../util/preconditions.js");
 const buffer_js_1 = require("../util/buffer.js");
 const bufferreader_js_1 = require("../encoding/bufferreader.js");
 const bufferwriter_js_1 = require("../encoding/bufferwriter.js");
 const hash_js_1 = require("../crypto/hash.js");
-const js_js_1 = require("../util/js.js");
 const bn_js_1 = require("../crypto/bn.js");
+const EPOCH_NUM_BLOCKS = 5040;
 const GENESIS_BITS = 0x1d00ffff;
+const HEADER_SIZE = 160;
 class BlockHeader {
+    static START_OF_HEADER = 0;
+    static MAX_TIME_OFFSET = 2 * 60 * 60;
+    static LARGEST_HASH = new bn_js_1.BN('10000000000000000000000000000000000000000000000000000000000000000', 'hex');
+    static HEADER_SIZE = HEADER_SIZE;
+    static EPOCH_NUM_BLOCKS = EPOCH_NUM_BLOCKS;
     static Constants = {
         START_OF_HEADER: 0,
         MAX_TIME_OFFSET: 2 * 60 * 60,
         LARGEST_HASH: new bn_js_1.BN('10000000000000000000000000000000000000000000000000000000000000000', 'hex'),
     };
-    static START_OF_HEADER = 0;
-    static MAX_TIME_OFFSET = 2 * 60 * 60;
-    static LARGEST_HASH = BigInt('0x10000000000000000000000000000000000000000000000000000000000000000');
     prevHash;
     bits;
     time;
@@ -35,165 +39,71 @@ class BlockHeader {
         if (arg instanceof BlockHeader) {
             return arg;
         }
-        this.prevHash = Buffer.alloc(32);
-        this.bits = 0;
-        this.time = 0;
-        this.timestamp = 0;
-        this.reserved = 0;
-        this.nonce = new bn_js_1.BN(0);
-        this.version = 0;
-        this.size = new bn_js_1.BN(0);
-        this.height = 0;
-        this.epochBlock = Buffer.alloc(32);
-        this.merkleRoot = Buffer.alloc(32);
-        this.extendedMetadata = Buffer.alloc(32);
-        if (arg && typeof arg === 'object') {
-            const info = BlockHeader._from(arg);
-            this.prevHash = info.prevHash;
-            this.bits = info.bits;
-            this.time = info.time;
-            this.timestamp = info.time;
-            this.reserved = info.reserved || 0;
-            this.nonce = info.nonce;
-            this.version = info.version;
-            this.size = info.size;
-            this.height = info.height;
-            this.epochBlock = info.epochBlock;
-            this.merkleRoot = info.merkleRoot;
-            this.extendedMetadata = info.extendedMetadata;
-            if (info.hash) {
-                preconditions_js_1.Preconditions.checkState(this.hash === info.hash, 'Argument object hash property does not match block hash.');
-            }
-        }
-    }
-    static _from(arg) {
-        let info = {};
-        if (Buffer.isBuffer(arg)) {
-            info = BlockHeader._fromBufferReader(new bufferreader_js_1.BufferReader(arg));
-        }
-        else if (typeof arg === 'string' && js_js_1.JSUtil.isHexa(arg)) {
-            const buf = Buffer.from(arg, 'hex');
-            info = BlockHeader._fromBufferReader(new bufferreader_js_1.BufferReader(buf));
-        }
-        else if (typeof arg === 'object' && arg !== null) {
-            info = BlockHeader._fromObject(arg);
-        }
-        else {
-            throw new TypeError('Unrecognized argument for BlockHeader');
-        }
-        return info;
-    }
-    static _fromObject(data) {
-        preconditions_js_1.Preconditions.checkArgument(typeof data === 'object' && data !== null, 'data is required');
-        let prevHash = data.prevHash;
-        let merkleRoot = data.merkleRoot;
-        let epochBlock = data.epochBlock;
-        let extendedMetadata = data.extendedMetadata;
-        let nonce = data.nonce;
-        let size = data.size;
-        if (typeof data.prevHash === 'string') {
-            prevHash = buffer_js_1.BufferUtil.reverse(Buffer.from(data.prevHash, 'hex'));
-        }
-        else if (!Buffer.isBuffer(data.prevHash)) {
-            prevHash = Buffer.alloc(32);
-        }
-        if (typeof data.merkleRoot === 'string') {
-            merkleRoot = buffer_js_1.BufferUtil.reverse(Buffer.from(data.merkleRoot, 'hex'));
-        }
-        else if (!Buffer.isBuffer(data.merkleRoot)) {
-            merkleRoot = Buffer.alloc(32);
+        const data = arg
+            ? BlockHeader._normalizeData(arg)
+            : BlockHeader._defaultData();
+        this.prevHash = data.prevHash;
+        this.bits = data.bits;
+        this.time = data.time;
+        this.timestamp = data.time;
+        this.reserved = data.reserved;
+        this.nonce = data.nonce;
+        this.version = data.version;
+        this.size = data.size;
+        this.height = data.height;
+        this.epochBlock = data.epochBlock;
+        this.merkleRoot = data.merkleRoot;
+        this.extendedMetadata = data.extendedMetadata;
+        if (data.hash) {
+            preconditions_js_1.Preconditions.checkState(this.hash === data.hash, 'Argument object hash property does not match block hash.');
         }
-        if (typeof data.epochBlock === 'string') {
-            epochBlock = buffer_js_1.BufferUtil.reverse(Buffer.from(data.epochBlock, 'hex'));
-        }
-        else if (!Buffer.isBuffer(data.epochBlock)) {
-            epochBlock = Buffer.alloc(32);
-        }
-        if (typeof data.extendedMetadata === 'string') {
-            extendedMetadata = buffer_js_1.BufferUtil.reverse(Buffer.from(data.extendedMetadata, 'hex'));
-        }
-        else if (!Buffer.isBuffer(data.extendedMetadata)) {
-            extendedMetadata = Buffer.alloc(32);
-        }
-        if (typeof data.nonce === 'string') {
-            nonce = new bn_js_1.BN(data.nonce, 10);
-        }
-        else if (typeof data.nonce === 'number') {
-            nonce = new bn_js_1.BN(data.nonce);
-        }
-        else if (data.nonce instanceof bn_js_1.BN) {
-            nonce = data.nonce;
-        }
-        else {
-            nonce = new bn_js_1.BN(0);
-        }
-        if (typeof data.size === 'string') {
-            size = new bn_js_1.BN(data.size, 10);
-        }
-        else if (typeof data.size === 'number') {
-            size = new bn_js_1.BN(data.size);
-        }
-        else if (data.size instanceof bn_js_1.BN) {
-            size = data.size;
-        }
-        else {
-            size = new bn_js_1.BN(0);
-        }
-        return {
-            hash: data.hash,
-            prevHash: prevHash,
-            bits: data.bits || 0,
-            timestamp: data.time || data.timestamp || 0,
-            reserved: data.reserved || 0,
-            nonce: nonce,
-            version: data.version || 0,
-            size: size,
-            height: data.height || 0,
-            epochBlock: epochBlock,
-            merkleRoot: merkleRoot,
-            extendedMetadata: extendedMetadata,
-            time: data.time || data.timestamp || 0,
-        };
     }
     static fromObject(obj) {
-        const info = BlockHeader._fromObject(obj);
-        return new BlockHeader(info);
+        preconditions_js_1.Preconditions.checkArgument(typeof obj === 'object' && obj !== null, 'data', 'data is required');
+        const prevHash = obj.prevHash
+            ? buffer_js_1.BufferUtil.reverse(buffer_1.Buffer.from(obj.prevHash, 'hex'))
+            : buffer_1.Buffer.alloc(32);
+        const merkleRoot = obj.merkleRoot
+            ? buffer_js_1.BufferUtil.reverse(buffer_1.Buffer.from(obj.merkleRoot, 'hex'))
+            : buffer_1.Buffer.alloc(32);
+        const epochBlock = obj.epochBlock
+            ? buffer_js_1.BufferUtil.reverse(buffer_1.Buffer.from(obj.epochBlock, 'hex'))
+            : buffer_1.Buffer.alloc(32);
+        const extendedMetadata = obj.extendedMetadata
+            ? buffer_js_1.BufferUtil.reverse(buffer_1.Buffer.from(obj.extendedMetadata, 'hex'))
+            : buffer_1.Buffer.alloc(32);
+        return new BlockHeader({
+            hash: obj.hash,
+            prevHash,
+            bits: obj.bits || 0,
+            time: obj.time || 0,
+            reserved: obj.reserved || 0,
+            nonce: new bn_js_1.BN(obj.nonce, 10),
+            version: obj.version || 0,
+            size: new bn_js_1.BN(obj.size),
+            height: obj.height || 0,
+            epochBlock,
+            merkleRoot,
+            extendedMetadata,
+        });
     }
     static fromRawBlock(data) {
-        if (!Buffer.isBuffer(data)) {
-            data = Buffer.from(data, 'binary');
+        if (!buffer_1.Buffer.isBuffer(data)) {
+            data = buffer_1.Buffer.from(data, 'binary');
         }
         const br = new bufferreader_js_1.BufferReader(data);
-        br.pos = BlockHeader.Constants.START_OF_HEADER;
-        const info = BlockHeader._fromBufferReader(br);
-        return new BlockHeader(info);
+        br.pos = BlockHeader.START_OF_HEADER;
+        return BlockHeader.fromBufferReader(br);
     }
     static fromBuffer(buf) {
-        const info = BlockHeader._fromBufferReader(new bufferreader_js_1.BufferReader(buf));
-        return new BlockHeader(info);
+        return BlockHeader.fromBufferReader(new bufferreader_js_1.BufferReader(buf));
     }
     static fromString(str) {
-        const buf = Buffer.from(str, 'hex');
-        return BlockHeader.fromBuffer(buf);
-    }
-    static _fromBufferReader(br) {
-        return {
-            prevHash: br.read(32),
-            bits: br.readUInt32LE(),
-            time: br.readUInt48LE(),
-            reserved: br.readUInt16LE(),
-            nonce: br.readUInt64LEBN(),
-            version: br.readUInt8(),
-            size: br.readUInt56LEBN(),
-            height: br.readUInt32LE(),
-            epochBlock: br.read(32),
-            merkleRoot: br.read(32),
-            extendedMetadata: br.read(32),
-        };
+        return BlockHeader.fromBuffer(buffer_1.Buffer.from(str, 'hex'));
     }
     static fromBufferReader(br) {
-        const info = BlockHeader._fromBufferReader(br);
-        return new BlockHeader(info);
+        const data = BlockHeader._readFromBuffer(br);
+        return new BlockHeader(data);
     }
     toObject() {
         return {
@@ -211,7 +121,9 @@ class BlockHeader {
             extendedMetadata: buffer_js_1.BufferUtil.reverse(this.extendedMetadata).toString('hex'),
         };
     }
-    toJSON = this.toObject;
+    toJSON() {
+        return this.toObject();
+    }
     toBuffer() {
         return this.toBufferWriter().toBuffer();
     }
@@ -235,6 +147,16 @@ class BlockHeader {
         bw.write(this.extendedMetadata);
         return bw;
     }
+    get hash() {
+        if (!this._id) {
+            const hashBuffer = this._computeHash();
+            this._id = buffer_js_1.BufferUtil.reverse(hashBuffer).toString('hex');
+        }
+        return this._id;
+    }
+    get id() {
+        return this.hash;
+    }
     getTargetDifficulty(bits) {
         bits = bits || this.bits;
         let target = new bn_js_1.BN(bits & 0xffffff);
@@ -256,72 +178,84 @@ class BlockHeader {
             difficultyString.slice(decimalPos);
         return parseFloat(formattedDifficulty);
     }
-    _getHash() {
-        const layer3Hash = this._getLayer3Hash();
-        const layer2Hash = this._getLayer2Hash(layer3Hash);
-        const bw = new bufferwriter_js_1.BufferWriter();
-        bw.write(this.prevHash);
-        bw.write(layer2Hash);
-        return hash_js_1.Hash.sha256(bw.toBuffer());
-    }
-    _timeToBytes() {
-        const buf = Buffer.alloc(6);
-        buf.writeUIntLE(this.time, 0, 6);
-        return buf;
-    }
-    _sizeToBytes() {
-        const buf = Buffer.alloc(7);
-        const sizeBuffer = this.size.toArrayLike(Buffer, 'le', 7);
-        sizeBuffer.copy(buf);
-        return buf;
-    }
-    _getLayer3Hash() {
-        const bw = new bufferwriter_js_1.BufferWriter();
-        bw.writeUInt8(this.version);
-        bw.writeUInt56LEBN(this.size);
-        bw.writeUInt32LE(this.height);
-        bw.write(this.epochBlock);
-        bw.write(this.merkleRoot);
-        bw.write(this.extendedMetadata);
-        return hash_js_1.Hash.sha256(bw.toBuffer());
-    }
-    _getLayer2Hash(layer3Hash) {
-        const bw = new bufferwriter_js_1.BufferWriter();
-        bw.writeUInt32LE(this.bits);
-        bw.writeUInt48LE(this.time);
-        bw.writeUInt16LE(this.reserved);
-        bw.writeUInt64LEBN(this.nonce);
-        bw.write(layer3Hash);
-        return hash_js_1.Hash.sha256(bw.toBuffer());
-    }
-    get hash() {
-        if (!this._id) {
-            const hashBuffer = this._getHash();
-            const reader = new bufferreader_js_1.BufferReader(hashBuffer);
-            this._id = reader.readReverse(32).toString('hex');
-        }
-        return this._id;
-    }
-    get id() {
-        return this.hash;
-    }
     validTimestamp() {
         const currentTime = Math.round(new Date().getTime() / 1000);
-        if (this.time > currentTime + BlockHeader.Constants.MAX_TIME_OFFSET) {
-            return false;
-        }
-        return true;
+        return this.time <= currentTime + BlockHeader.MAX_TIME_OFFSET;
     }
     validProofOfWork() {
         const pow = new bn_js_1.BN(this.id, 'hex');
         const target = this.getTargetDifficulty();
-        if (pow.gt(target)) {
-            return false;
-        }
-        return true;
+        return !pow.gt(target);
     }
     inspect() {
         return '<BlockHeader ' + this.id + '>';
     }
+    _computeHash() {
+        const bw3 = new bufferwriter_js_1.BufferWriter();
+        bw3.writeUInt8(this.version);
+        bw3.writeUInt56LEBN(this.size);
+        bw3.writeUInt32LE(this.height);
+        bw3.write(this.epochBlock);
+        bw3.write(this.merkleRoot);
+        bw3.write(this.extendedMetadata);
+        const layer3Hash = hash_js_1.Hash.sha256(bw3.toBuffer());
+        const bw2 = new bufferwriter_js_1.BufferWriter();
+        bw2.writeUInt32LE(this.bits);
+        bw2.writeUInt48LE(this.time);
+        bw2.writeUInt16LE(this.reserved);
+        bw2.writeUInt64LEBN(this.nonce);
+        bw2.write(layer3Hash);
+        const layer2Hash = hash_js_1.Hash.sha256(bw2.toBuffer());
+        const bw1 = new bufferwriter_js_1.BufferWriter();
+        bw1.write(this.prevHash);
+        bw1.write(layer2Hash);
+        return hash_js_1.Hash.sha256(bw1.toBuffer());
+    }
+    static _normalizeData(data) {
+        return {
+            hash: data.hash,
+            prevHash: data.prevHash || buffer_1.Buffer.alloc(32),
+            bits: data.bits || 0,
+            time: data.time || 0,
+            reserved: data.reserved || 0,
+            nonce: data.nonce || new bn_js_1.BN(0),
+            version: data.version || 0,
+            size: data.size || new bn_js_1.BN(0),
+            height: data.height || 0,
+            epochBlock: data.epochBlock || buffer_1.Buffer.alloc(32),
+            merkleRoot: data.merkleRoot || buffer_1.Buffer.alloc(32),
+            extendedMetadata: data.extendedMetadata || buffer_1.Buffer.alloc(32),
+        };
+    }
+    static _defaultData() {
+        return {
+            prevHash: buffer_1.Buffer.alloc(32),
+            bits: 0,
+            time: 0,
+            reserved: 0,
+            nonce: new bn_js_1.BN(0),
+            version: 0,
+            size: new bn_js_1.BN(0),
+            height: 0,
+            epochBlock: buffer_1.Buffer.alloc(32),
+            merkleRoot: buffer_1.Buffer.alloc(32),
+            extendedMetadata: buffer_1.Buffer.alloc(32),
+        };
+    }
+    static _readFromBuffer(br) {
+        return {
+            prevHash: br.read(32),
+            bits: br.readUInt32LE(),
+            time: br.readUInt48LE(),
+            reserved: br.readUInt16LE(),
+            nonce: br.readUInt64LEBN(),
+            version: br.readUInt8(),
+            size: br.readUInt56LEBN(),
+            height: br.readUInt32LE(),
+            epochBlock: br.read(32),
+            merkleRoot: br.read(32),
+            extendedMetadata: br.read(32),
+        };
+    }
 }
 exports.BlockHeader = BlockHeader;

package/dist/cjs/lib/bitcore/block/index.js

@@ -1,7 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.BlockHeader = exports.Block = void 0;
+exports.MerkleBlock = exports.BlockHeader = exports.Block = void 0;
 var block_js_1 = require("./block.js");
 Object.defineProperty(exports, "Block", { enumerable: true, get: function () { return block_js_1.Block; } });
 var blockheader_js_1 = require("./blockheader.js");
 Object.defineProperty(exports, "BlockHeader", { enumerable: true, get: function () { return blockheader_js_1.BlockHeader; } });
+var merkleblock_js_1 = require("./merkleblock.js");
+Object.defineProperty(exports, "MerkleBlock", { enumerable: true, get: function () { return merkleblock_js_1.MerkleBlock; } });