xpi-ts 0.2.13 → 0.2.15

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

@@ -1,20 +1,24 @@
-import { Preconditions } from '../util/preconditions.js';
+import { Buffer } from 'buffer/';
+import { Preconditions as $ } from '../util/preconditions.js';
 import { BufferUtil } from '../util/buffer.js';
 import { BufferReader } from '../encoding/bufferreader.js';
 import { BufferWriter } from '../encoding/bufferwriter.js';
 import { Hash } from '../crypto/hash.js';
-import { JSUtil } from '../util/js.js';
 import { BN } from '../crypto/bn.js';
+const EPOCH_NUM_BLOCKS = 5040;
 const GENESIS_BITS = 0x1d00ffff;
+const HEADER_SIZE = 160;
 export class BlockHeader {
+    static START_OF_HEADER = 0;
+    static MAX_TIME_OFFSET = 2 * 60 * 60;
+    static LARGEST_HASH = new 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('10000000000000000000000000000000000000000000000000000000000000000', 'hex'),
     };
-    static START_OF_HEADER = 0;
-    static MAX_TIME_OFFSET = 2 * 60 * 60;
-    static LARGEST_HASH = BigInt('0x10000000000000000000000000000000000000000000000000000000000000000');
     prevHash;
     bits;
     time;
@@ -32,165 +36,71 @@ export 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(0);
-        this.version = 0;
-        this.size = new 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.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(arg));
-        }
-        else if (typeof arg === 'string' && JSUtil.isHexa(arg)) {
-            const buf = Buffer.from(arg, 'hex');
-            info = BlockHeader._fromBufferReader(new 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.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 = BufferUtil.reverse(Buffer.from(data.prevHash, 'hex'));
-        }
-        else if (!Buffer.isBuffer(data.prevHash)) {
-            prevHash = Buffer.alloc(32);
-        }
-        if (typeof data.merkleRoot === 'string') {
-            merkleRoot = 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) {
+            $.checkState(this.hash === data.hash, 'Argument object hash property does not match block hash.');
         }
-        if (typeof data.epochBlock === 'string') {
-            epochBlock = BufferUtil.reverse(Buffer.from(data.epochBlock, 'hex'));
-        }
-        else if (!Buffer.isBuffer(data.epochBlock)) {
-            epochBlock = Buffer.alloc(32);
-        }
-        if (typeof data.extendedMetadata === 'string') {
-            extendedMetadata = 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(data.nonce, 10);
-        }
-        else if (typeof data.nonce === 'number') {
-            nonce = new BN(data.nonce);
-        }
-        else if (data.nonce instanceof BN) {
-            nonce = data.nonce;
-        }
-        else {
-            nonce = new BN(0);
-        }
-        if (typeof data.size === 'string') {
-            size = new BN(data.size, 10);
-        }
-        else if (typeof data.size === 'number') {
-            size = new BN(data.size);
-        }
-        else if (data.size instanceof BN) {
-            size = data.size;
-        }
-        else {
-            size = new 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);
+        $.checkArgument(typeof obj === 'object' && obj !== null, 'data', 'data is required');
+        const prevHash = obj.prevHash
+            ? BufferUtil.reverse(Buffer.from(obj.prevHash, 'hex'))
+            : Buffer.alloc(32);
+        const merkleRoot = obj.merkleRoot
+            ? BufferUtil.reverse(Buffer.from(obj.merkleRoot, 'hex'))
+            : Buffer.alloc(32);
+        const epochBlock = obj.epochBlock
+            ? BufferUtil.reverse(Buffer.from(obj.epochBlock, 'hex'))
+            : Buffer.alloc(32);
+        const extendedMetadata = obj.extendedMetadata
+            ? BufferUtil.reverse(Buffer.from(obj.extendedMetadata, 'hex'))
+            : 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(obj.nonce, 10),
+            version: obj.version || 0,
+            size: new BN(obj.size),
+            height: obj.height || 0,
+            epochBlock,
+            merkleRoot,
+            extendedMetadata,
+        });
     }
     static fromRawBlock(data) {
         if (!Buffer.isBuffer(data)) {
             data = Buffer.from(data, 'binary');
         }
         const br = new 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(buf));
-        return new BlockHeader(info);
+        return BlockHeader.fromBufferReader(new 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.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 {
@@ -208,7 +118,9 @@ export class BlockHeader {
             extendedMetadata: BufferUtil.reverse(this.extendedMetadata).toString('hex'),
         };
     }
-    toJSON = this.toObject;
+    toJSON() {
+        return this.toObject();
+    }
     toBuffer() {
         return this.toBufferWriter().toBuffer();
     }
@@ -232,6 +144,16 @@ export class BlockHeader {
         bw.write(this.extendedMetadata);
         return bw;
     }
+    get hash() {
+        if (!this._id) {
+            const hashBuffer = this._computeHash();
+            this._id = BufferUtil.reverse(hashBuffer).toString('hex');
+        }
+        return this._id;
+    }
+    get id() {
+        return this.hash;
+    }
     getTargetDifficulty(bits) {
         bits = bits || this.bits;
         let target = new BN(bits & 0xffffff);
@@ -253,71 +175,83 @@ export class BlockHeader {
             difficultyString.slice(decimalPos);
         return parseFloat(formattedDifficulty);
     }
-    _getHash() {
-        const layer3Hash = this._getLayer3Hash();
-        const layer2Hash = this._getLayer2Hash(layer3Hash);
-        const bw = new BufferWriter();
-        bw.write(this.prevHash);
-        bw.write(layer2Hash);
-        return 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();
-        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.sha256(bw.toBuffer());
-    }
-    _getLayer2Hash(layer3Hash) {
-        const bw = new BufferWriter();
-        bw.writeUInt32LE(this.bits);
-        bw.writeUInt48LE(this.time);
-        bw.writeUInt16LE(this.reserved);
-        bw.writeUInt64LEBN(this.nonce);
-        bw.write(layer3Hash);
-        return Hash.sha256(bw.toBuffer());
-    }
-    get hash() {
-        if (!this._id) {
-            const hashBuffer = this._getHash();
-            const reader = new 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(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();
+        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.sha256(bw3.toBuffer());
+        const bw2 = new BufferWriter();
+        bw2.writeUInt32LE(this.bits);
+        bw2.writeUInt48LE(this.time);
+        bw2.writeUInt16LE(this.reserved);
+        bw2.writeUInt64LEBN(this.nonce);
+        bw2.write(layer3Hash);
+        const layer2Hash = Hash.sha256(bw2.toBuffer());
+        const bw1 = new BufferWriter();
+        bw1.write(this.prevHash);
+        bw1.write(layer2Hash);
+        return Hash.sha256(bw1.toBuffer());
+    }
+    static _normalizeData(data) {
+        return {
+            hash: data.hash,
+            prevHash: data.prevHash || Buffer.alloc(32),
+            bits: data.bits || 0,
+            time: data.time || 0,
+            reserved: data.reserved || 0,
+            nonce: data.nonce || new BN(0),
+            version: data.version || 0,
+            size: data.size || new BN(0),
+            height: data.height || 0,
+            epochBlock: data.epochBlock || Buffer.alloc(32),
+            merkleRoot: data.merkleRoot || Buffer.alloc(32),
+            extendedMetadata: data.extendedMetadata || Buffer.alloc(32),
+        };
+    }
+    static _defaultData() {
+        return {
+            prevHash: Buffer.alloc(32),
+            bits: 0,
+            time: 0,
+            reserved: 0,
+            nonce: new BN(0),
+            version: 0,
+            size: new BN(0),
+            height: 0,
+            epochBlock: Buffer.alloc(32),
+            merkleRoot: Buffer.alloc(32),
+            extendedMetadata: 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),
+        };
+    }
 }

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

@@ -1,2 +1,3 @@
 export { Block } from './block.js';
 export { BlockHeader } from './blockheader.js';
+export { MerkleBlock } from './merkleblock.js';