xpi-ts 0.2.13 → 0.2.15

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

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Block = 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");
@@ -9,55 +10,34 @@ const hash_js_1 = require("../crypto/hash.js");
 const js_js_1 = require("../util/js.js");
 const index_js_1 = require("../transaction/index.js");
 const bn_js_1 = require("../crypto/bn.js");
+const merkle_js_1 = require("../util/merkle.js");
 const blockheader_js_1 = require("./blockheader.js");
+const merkleblock_js_1 = require("./merkleblock.js");
 class Block {
     static MAX_BLOCK_SIZE = 32 * 1024 * 1024;
-    static START_OF_BLOCK = 0;
-    static NULL_HASH = Buffer.from('0000000000000000000000000000000000000000000000000000000000000000', 'hex');
-    static Values = {
-        START_OF_BLOCK: 0,
-        NULL_HASH: Buffer.from('0000000000000000000000000000000000000000000000000000000000000000', 'hex'),
-    };
+    static NULL_HASH = buffer_js_1.NULL_HASH;
     header;
-    metadata;
     transactions;
     _id;
     constructor(serialized) {
-        if (!(this instanceof Block)) {
-            return new Block(serialized);
-        }
         if (serialized instanceof Block) {
             return Block.shallowCopy(serialized);
         }
         else if (typeof serialized === 'string' && js_js_1.JSUtil.isHexa(serialized)) {
-            this.fromString(serialized);
-        }
-        else if (Buffer.isBuffer(serialized)) {
-            this.fromBuffer(serialized);
+            this._fromString(serialized);
         }
-        else if (serialized && typeof serialized === 'object') {
-            this.fromObject(serialized);
+        else if (buffer_1.Buffer.isBuffer(serialized) ||
+            (serialized && typeof serialized === 'object')) {
+            const info = Block._from(serialized);
+            this.header = info.header;
+            this.transactions = info.transactions;
         }
         else {
-            this._newBlock();
+            this._initEmpty();
         }
     }
     static shallowCopy(block) {
-        const copy = new Block(block.toBuffer());
-        return copy;
-    }
-    static _from(arg) {
-        let info = {};
-        if (Buffer.isBuffer(arg)) {
-            info = Block._fromBufferReader(new bufferreader_js_1.BufferReader(arg));
-        }
-        else if (typeof arg === 'object' && arg !== null) {
-            info = Block._fromObject(arg);
-        }
-        else {
-            throw new TypeError('Unrecognized argument for Block');
-        }
-        return info;
+        return new Block(block.toBuffer());
     }
     static fromObject(obj) {
         const info = Block._fromObject(obj);
@@ -65,97 +45,35 @@ class Block {
     }
     static fromBufferReader(br) {
         preconditions_js_1.Preconditions.checkArgument(br instanceof bufferreader_js_1.BufferReader, 'br is required');
-        const info = Block._fromBufferReader(br);
+        const info = Block._readFromBuffer(br);
         return new Block(info);
     }
     static fromBuffer(buf) {
         return Block.fromBufferReader(new bufferreader_js_1.BufferReader(buf));
     }
     static fromString(str) {
-        const buf = Buffer.from(str, 'hex');
-        return Block.fromBuffer(buf);
+        return Block.fromBuffer(buffer_1.Buffer.from(str, 'hex'));
     }
     static fromRawBlock(data) {
         if (!buffer_js_1.BufferUtil.isBuffer(data)) {
-            data = Buffer.from(data, 'binary');
+            data = buffer_1.Buffer.from(data, 'binary');
         }
         const br = new bufferreader_js_1.BufferReader(data);
-        br.pos = Block.Values.START_OF_BLOCK;
-        const info = Block._fromBufferReader(br);
+        const info = Block._readFromBuffer(br);
         return new Block(info);
     }
-    static _fromObject(data) {
-        const transactions = [];
-        if (data.transactions) {
-            data.transactions.forEach(tx => {
-                if (tx instanceof index_js_1.Transaction) {
-                    transactions.push(tx);
-                }
-                else {
-                    transactions.push(new index_js_1.Transaction(tx));
-                }
-            });
-        }
-        return {
-            header: data.header
-                ? data.header instanceof blockheader_js_1.BlockHeader
-                    ? data.header
-                    : new blockheader_js_1.BlockHeader(data.header)
-                : new blockheader_js_1.BlockHeader(),
-            metadata: data.metadata || 0x00,
-            transactions: transactions,
-        };
-    }
-    static _fromBufferReader(br) {
-        preconditions_js_1.Preconditions.checkState(!br.finished(), 'No block data received');
-        const header = blockheader_js_1.BlockHeader.fromBufferReader(br);
-        const metadata = br.readUInt8();
-        const transactionCount = br.readVarintNum();
-        const transactions = [];
-        for (let i = 0; i < transactionCount; i++) {
-            const tx = new index_js_1.Transaction();
-            transactions.push(tx.fromBufferReader(br));
-        }
-        return {
-            header,
-            metadata,
-            transactions,
-        };
-    }
-    _newBlock() {
-        this.header = new blockheader_js_1.BlockHeader();
-        this.metadata = 0x00;
-        this.transactions = [];
-    }
-    fromBuffer(buf) {
-        const info = Block._fromBufferReader(new bufferreader_js_1.BufferReader(buf));
-        this.header = info.header;
-        this.metadata = info.metadata;
-        this.transactions = info.transactions;
-        return this;
-    }
-    fromString(str) {
-        const buf = Buffer.from(str, 'hex');
-        return this.fromBuffer(buf);
-    }
-    fromObject(obj) {
-        const info = Block._fromObject(obj);
-        this.header = info.header;
-        this.metadata = info.metadata;
-        this.transactions = info.transactions;
-        return this;
-    }
     toObject() {
         const transactions = this.transactions.map(tx => tx.toObject());
         return {
             id: this.id,
             hash: this.hash,
             header: this.header.toObject(),
-            metadata: this.metadata,
-            transactions: transactions,
+            transactions,
         };
     }
-    toJSON = this.toObject;
+    toJSON() {
+        return this.toObject();
+    }
     toBuffer() {
         return this.toBufferWriter().concat();
     }
@@ -167,25 +85,21 @@ class Block {
             bw = new bufferwriter_js_1.BufferWriter();
         }
         bw.write(this.header.toBuffer());
-        bw.writeUInt8(this.metadata);
+        bw.writeVarintNum(0);
         bw.writeVarintNum(this.transactions.length);
-        for (let i = 0; i < this.transactions.length; i++) {
-            this.transactions[i].toBufferWriter(bw);
+        for (const tx of this.transactions) {
+            tx.toBufferWriter(bw);
         }
         return bw;
     }
     getTransactionHashes() {
-        const hashes = [];
         if (this.transactions.length === 0) {
-            return [Block.Values.NULL_HASH];
+            return [Block.NULL_HASH];
         }
-        for (let t = 0; t < this.transactions.length; t++) {
-            const tx = this.transactions[t];
-            const txid = tx._getTxid();
-            const hash = tx._getHash();
-            const buf = Buffer.concat([hash, txid]);
-            const resultHash = hash_js_1.Hash.sha256sha256(buf);
-            hashes.push(resultHash);
+        const hashes = [];
+        for (const tx of this.transactions) {
+            const combined = buffer_1.Buffer.concat([tx.hashBuffer, tx.txidBuffer]);
+            hashes.push(hash_js_1.Hash.sha256sha256(combined));
         }
         return hashes;
     }
@@ -194,12 +108,12 @@ class Block {
         let j = 0;
         for (let size = tree.length; size > 1; size = Math.floor(size / 2)) {
             if (size % 2 === 1) {
-                tree.push(Block.Values.NULL_HASH);
+                tree.push(Block.NULL_HASH);
                 size += 1;
             }
             for (let i = 0; i < size; i += 2) {
-                const buf = Buffer.concat([tree[j + i], tree[j + i + 1]]);
-                tree.push(hash_js_1.Hash.sha256sha256(buf));
+                const combined = buffer_1.Buffer.concat([tree[j + i], tree[j + i + 1]]);
+                tree.push(hash_js_1.Hash.sha256sha256(combined));
             }
             j += size;
         }
@@ -210,16 +124,45 @@ class Block {
         return tree[tree.length - 1];
     }
     validMerkleRoot() {
-        const h = new bn_js_1.BN(this.header.merkleRoot.toString('hex'), 'hex');
-        const c = new bn_js_1.BN(this.getMerkleRoot().toString('hex'), 'hex');
-        if (!h.eq(c)) {
-            return false;
-        }
-        return true;
+        const headerRoot = bn_js_1.BN.fromBuffer(this.header.merkleRoot);
+        const computedRoot = bn_js_1.BN.fromBuffer(this.getMerkleRoot());
+        return headerRoot.eq(computedRoot);
     }
-    _getHash() {
-        const header = this.header;
-        return header._getHash();
+    toMerkleBlock(txids) {
+        if (!Array.isArray(txids) || txids.length === 0) {
+            throw new TypeError('txids must be a non-empty array of transaction IDs');
+        }
+        for (const txid of txids) {
+            if (!/^[0-9a-fA-F]{64}$/.test(txid)) {
+                throw new TypeError(`Invalid transaction ID format: ${txid}`);
+            }
+        }
+        if (this.transactions.length === 0) {
+            throw new Error('Cannot create MerkleBlock from block with no transactions');
+        }
+        const vHashes = [];
+        const vMatch = [];
+        for (const tx of this.transactions) {
+            const txhash = tx.hash;
+            const txid = tx.txid;
+            const txidLower = txid.toLowerCase();
+            vMatch.push(false);
+            vHashes.push(txhash);
+            const isMatch = txids.some(id => id.toLowerCase() === txidLower);
+            vMatch.push(isMatch);
+            vHashes.push(txid);
+        }
+        const nLeaves = vHashes.length;
+        const height = (0, merkle_js_1.calcTreeHeight)(nLeaves);
+        const vBits = [];
+        const vHash = [];
+        (0, merkle_js_1.traverseAndBuild)(height, 0, nLeaves, vHashes, vMatch, vBits, vHash, Block.NULL_HASH);
+        return new merkleblock_js_1.MerkleBlock({
+            header: this.header,
+            numTransactions: this.transactions.length,
+            hashes: vHash,
+            flags: vBits.map(b => (b ? 1 : 0)),
+        });
     }
     get hash() {
         if (!this._id) {
@@ -233,5 +176,60 @@ class Block {
     inspect() {
         return '<Block ' + this.id + '>';
     }
+    static _from(arg) {
+        if (buffer_1.Buffer.isBuffer(arg)) {
+            return Block._readFromBuffer(new bufferreader_js_1.BufferReader(arg));
+        }
+        else if (typeof arg === 'object' && arg !== null) {
+            return Block._fromObject(arg);
+        }
+        throw new TypeError('Unrecognized argument for Block');
+    }
+    static _fromObject(data) {
+        const transactions = [];
+        if (data.transactions) {
+            for (const tx of data.transactions) {
+                transactions.push(tx instanceof index_js_1.Transaction ? tx : new index_js_1.Transaction(tx));
+            }
+        }
+        let header;
+        if (data.header instanceof blockheader_js_1.BlockHeader) {
+            header = data.header;
+        }
+        else if (data.header) {
+            header = new blockheader_js_1.BlockHeader(data.header);
+        }
+        else {
+            header = new blockheader_js_1.BlockHeader();
+        }
+        return { header, transactions };
+    }
+    static _readFromBuffer(br) {
+        preconditions_js_1.Preconditions.checkState(!br.finished(), 'No block data received');
+        const header = blockheader_js_1.BlockHeader.fromBufferReader(br);
+        const metadataCount = br.readVarintNum();
+        for (let i = 0; i < metadataCount; i++) {
+            br.readUInt32LE();
+            const dataLength = br.readVarintNum();
+            br.read(dataLength);
+        }
+        const transactionCount = br.readVarintNum();
+        const transactions = [];
+        for (let i = 0; i < transactionCount; i++) {
+            const tx = new index_js_1.Transaction();
+            transactions.push(tx.fromBufferReader(br));
+        }
+        return { header, transactions };
+    }
+    _initEmpty() {
+        this.header = new blockheader_js_1.BlockHeader();
+        this.transactions = [];
+    }
+    _fromString(str) {
+        const buf = buffer_1.Buffer.from(str, 'hex');
+        const info = Block._readFromBuffer(new bufferreader_js_1.BufferReader(buf));
+        this.header = info.header;
+        this.transactions = info.transactions;
+    }
 }
 exports.Block = Block;