xpi-ts 0.2.13 → 0.2.15

package/dist/esm/lib/bitcore/address.js

@@ -1,12 +1,13 @@
-import { Preconditions } from './util/preconditions.js';
-import { BitcoreError } from './errors.js';
-import { Base58Check } from './encoding/base58check.js';
-import { get as getNetwork, defaultNetwork, } from './networks.js';
-import { Hash } from './crypto/hash.js';
-import { JSUtil } from './util/js.js';
-import { PublicKey } from './publickey.js';
-import { XAddress } from './xaddress.js';
-import { Script } from './script.js';
+import { Preconditions as $ } from './util/preconditions';
+import { BitcoreError } from './errors';
+import { Base58Check } from './encoding/base58check';
+import { get as getNetwork, defaultNetwork, } from './networks';
+import { Hash } from './crypto/hash';
+import { JSUtil, BufferUtil } from './util';
+import { PublicKey } from './publickey';
+import { XAddress } from './xaddress';
+import { Script } from './script';
+import { Opcode } from './opcode';
 export class Address {
     static PayToPublicKeyHash = 'pubkeyhash';
     static PayToScriptHash = 'scripthash';
@@ -18,7 +19,7 @@ export class Address {
         if (data instanceof Address) {
             return data;
         }
-        Preconditions.checkArgument(data !== undefined, 'data', 'First argument is required, please include address data.', 'guide/address.html');
+        $.checkArgument(data !== undefined, 'data', 'First argument is required, please include address data.', 'guide/address.html');
         if (network && !getNetwork(network)) {
             throw new TypeError('Second argument must be "livenet", "testnet", or "regtest".');
         }
@@ -47,18 +48,18 @@ export class Address {
             }
             network = networkObj;
         }
-        if ((Buffer.isBuffer(data) || data instanceof Uint8Array) &&
+        if ((BufferUtil.isBuffer(data) || data instanceof Uint8Array) &&
             data.length === 20) {
             return Address._transformHash(data);
         }
-        else if ((Buffer.isBuffer(data) || data instanceof Uint8Array) &&
+        else if ((BufferUtil.isBuffer(data) || data instanceof Uint8Array) &&
             data.length === 21) {
             return Address._transformBuffer(data, network, type);
         }
-        else if ((Buffer.isBuffer(data) || data instanceof Uint8Array) &&
+        else if ((BufferUtil.isBuffer(data) || data instanceof Uint8Array) &&
             data.length === 33) {
             return {
-                hashBuffer: Buffer.from(data),
+                hashBuffer: BufferUtil.from(data),
                 network: typeof network === 'string' ? getNetwork(network) : network,
                 type: type || Address.PayToTaproot,
             };
@@ -112,7 +113,7 @@ export class Address {
                 throw new TypeError('Address has mismatched network type.');
             }
             return {
-                hashBuffer: Buffer.from(info.hashBuffer),
+                hashBuffer: BufferUtil.from(info.hashBuffer),
                 network: info.network,
                 type: info.type,
             };
@@ -139,7 +140,7 @@ export class Address {
         if (!version.network || !version.type) {
             throw new TypeError('Address has invalid version.');
         }
-        info.hashBuffer = decoded.subarray(1);
+        info.hashBuffer = decoded.slice(1);
         info.network = version.network;
         info.type = version.type;
         return info;
@@ -162,10 +163,10 @@ export class Address {
         const decodedType = decodedXAddress.type;
         if (decodedType === 'taproot' || decodedType === Address.PayToTaproot) {
             if (hashBuffer.length === 36 &&
-                hashBuffer[0] === 0x62 &&
-                hashBuffer[1] === 0x51 &&
+                hashBuffer[0] === Opcode.OP_SCRIPTTYPE &&
+                hashBuffer[1] === Opcode.OP_1 &&
                 hashBuffer[2] === 0x21) {
-                hashBuffer = hashBuffer.subarray(3, 36);
+                hashBuffer = hashBuffer.slice(3, 36);
             }
             else if (hashBuffer.length === 33) {
             }
@@ -179,16 +180,16 @@ export class Address {
             };
         }
         if (hashBuffer.length === 25 &&
-            hashBuffer[0] === 0x76 &&
-            hashBuffer[1] === 0xa9 &&
+            hashBuffer[0] === Opcode.OP_DUP &&
+            hashBuffer[1] === Opcode.OP_HASH160 &&
             hashBuffer[2] === 0x14) {
-            hashBuffer = hashBuffer.subarray(3, 23);
+            hashBuffer = hashBuffer.slice(3, 23);
         }
         else if (hashBuffer.length === 23 &&
-            hashBuffer[0] === 0xa9 &&
+            hashBuffer[0] === Opcode.OP_HASH160 &&
             hashBuffer[1] === 0x14 &&
-            hashBuffer[22] === 0x87) {
-            hashBuffer = hashBuffer.subarray(2, 22);
+            hashBuffer[22] === Opcode.OP_EQUAL) {
+            hashBuffer = hashBuffer.slice(2, 22);
             return {
                 hashBuffer: hashBuffer,
                 network: decodedNetwork,
@@ -203,25 +204,25 @@ export class Address {
     }
     static _transformHash(hash) {
         const info = {};
-        if (!Buffer.isBuffer(hash) && !(hash instanceof Uint8Array)) {
+        if (!BufferUtil.isBuffer(hash)) {
             throw new TypeError('Address supplied is not a buffer.');
         }
         if (hash.length !== 20) {
             throw new TypeError('Address hashbuffers must be exactly 20 bytes.');
         }
-        info.hashBuffer = Buffer.from(hash);
+        info.hashBuffer = BufferUtil.from(hash);
         return info;
     }
     static _transformBuffer(buffer, network, type) {
         const info = {};
-        if (!Buffer.isBuffer(buffer) && !(buffer instanceof Uint8Array)) {
+        if (!BufferUtil.isBuffer(buffer)) {
             throw new TypeError('Address supplied is not a buffer.');
         }
         if (buffer.length !== 21) {
             throw new TypeError('Address buffers must be exactly 21 bytes.');
         }
         const networkObj = getNetwork(network);
-        const bufferVersion = Address._classifyFromVersion(Buffer.from(buffer));
+        const bufferVersion = Address._classifyFromVersion(BufferUtil.from(buffer));
         if (network && !networkObj) {
             throw new TypeError('Unknown network');
         }
@@ -232,7 +233,7 @@ export class Address {
         if (!bufferVersion.type || (type && type !== bufferVersion.type)) {
             throw new TypeError('Address has mismatched type.');
         }
-        info.hashBuffer = Buffer.from(buffer).subarray(1);
+        info.hashBuffer = BufferUtil.from(buffer).slice(1);
         info.network = bufferVersion.network;
         info.type = bufferVersion.type;
         return info;
@@ -248,7 +249,7 @@ export class Address {
         return info;
     }
     static _transformScript(script, network) {
-        Preconditions.checkArgument(script instanceof Script, 'script', 'script must be a Script instance');
+        $.checkArgument(script instanceof Script, 'script', 'script must be a Script instance');
         const address = script.getAddressInfo();
         if (!address) {
             throw new BitcoreError.Script.CantDeriveAddress('Cannot derive address from script');
@@ -263,10 +264,10 @@ export class Address {
         };
     }
     static _transformObject(data) {
-        Preconditions.checkArgument(data.hashBuffer !== undefined, 'data', 'Must provide a `hash` or `hashBuffer` property');
-        Preconditions.checkArgument(data.type !== undefined, 'data', 'Must provide a `type` property');
+        $.checkArgument(data.hashBuffer !== undefined, 'data', 'Must provide a `hash` or `hashBuffer` property');
+        $.checkArgument(data.type !== undefined, 'data', 'Must provide a `type` property');
         return {
-            hashBuffer: data.hashBuffer || Buffer.from(data.hashBuffer.toString(), 'hex'),
+            hashBuffer: data.hashBuffer || BufferUtil.from(data.hashBuffer.toString(), 'hex'),
             network: getNetwork(data.network) || defaultNetwork,
             type: data.type,
         };
@@ -305,18 +306,18 @@ export class Address {
         return new Address(info.hashBuffer, info.network, info.type);
     }
     static fromObject(obj) {
-        Preconditions.checkState(JSUtil.isHexa(obj.hash), 'Unexpected hash property, "' + obj.hash + '", expected to be hex.');
-        const hashBuffer = Buffer.from(obj.hash, 'hex');
+        $.checkState(JSUtil.isHexa(obj.hash), 'Unexpected hash property, "' + obj.hash + '", expected to be hex.');
+        const hashBuffer = BufferUtil.from(obj.hash, 'hex');
         return new Address(hashBuffer, obj.network, obj.type);
     }
     static fromScript(script, network) {
-        Preconditions.checkArgument(script instanceof Script, 'script', 'script must be a Script instance');
+        $.checkArgument(script instanceof Script, 'script', 'script must be a Script instance');
         const info = Address._transformScript(script, network);
         return new Address(info.hashBuffer, network, info.type);
     }
     static payingTo(script, network) {
-        Preconditions.checkArgument(script !== null, 'script', 'script is required');
-        Preconditions.checkArgument(script instanceof Script, 'script', 'script must be instance of Script');
+        $.checkArgument(script !== null, 'script', 'script is required');
+        $.checkArgument(script instanceof Script, 'script', 'script must be instance of Script');
         return Address.fromScriptHash(Hash.sha256ripemd160(script.toBuffer()), network);
     }
     static getValidationError(data, network, type) {
@@ -344,10 +345,10 @@ export class Address {
         return this.hashBuffer;
     }
     toFullBuffer() {
-        const version = Buffer.from([
+        const version = BufferUtil.from([
             this.network[this.type],
         ]);
-        const buf = Buffer.concat([version, this.hashBuffer]);
+        const buf = BufferUtil.concat([version, this.hashBuffer]);
         return buf;
     }
     toCashBuffer() {

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

@@ -1,158 +1,76 @@
-import { Preconditions } from '../util/preconditions.js';
-import { BufferUtil } from '../util/buffer.js';
+import { Buffer } from 'buffer/';
+import { Preconditions as $ } from '../util/preconditions.js';
+import { BufferUtil, NULL_HASH } 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 { Transaction } from '../transaction/index.js';
 import { BN } from '../crypto/bn.js';
+import { calcTreeHeight, traverseAndBuild } from '../util/merkle.js';
 import { BlockHeader, } from './blockheader.js';
+import { MerkleBlock } from './merkleblock.js';
 export 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 = 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' && 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.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(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);
         return new Block(info);
     }
     static fromBufferReader(br) {
-        Preconditions.checkArgument(br instanceof BufferReader, 'br is required');
-        const info = Block._fromBufferReader(br);
+        $.checkArgument(br instanceof BufferReader, 'br is required');
+        const info = Block._readFromBuffer(br);
         return new Block(info);
     }
     static fromBuffer(buf) {
         return Block.fromBufferReader(new BufferReader(buf));
     }
     static fromString(str) {
-        const buf = Buffer.from(str, 'hex');
-        return Block.fromBuffer(buf);
+        return Block.fromBuffer(Buffer.from(str, 'hex'));
     }
     static fromRawBlock(data) {
         if (!BufferUtil.isBuffer(data)) {
             data = Buffer.from(data, 'binary');
         }
         const br = new 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 Transaction) {
-                    transactions.push(tx);
-                }
-                else {
-                    transactions.push(new Transaction(tx));
-                }
-            });
-        }
-        return {
-            header: data.header
-                ? data.header instanceof BlockHeader
-                    ? data.header
-                    : new BlockHeader(data.header)
-                : new BlockHeader(),
-            metadata: data.metadata || 0x00,
-            transactions: transactions,
-        };
-    }
-    static _fromBufferReader(br) {
-        Preconditions.checkState(!br.finished(), 'No block data received');
-        const header = BlockHeader.fromBufferReader(br);
-        const metadata = br.readUInt8();
-        const transactionCount = br.readVarintNum();
-        const transactions = [];
-        for (let i = 0; i < transactionCount; i++) {
-            const tx = new Transaction();
-            transactions.push(tx.fromBufferReader(br));
-        }
-        return {
-            header,
-            metadata,
-            transactions,
-        };
-    }
-    _newBlock() {
-        this.header = new BlockHeader();
-        this.metadata = 0x00;
-        this.transactions = [];
-    }
-    fromBuffer(buf) {
-        const info = Block._fromBufferReader(new 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();
     }
@@ -164,25 +82,21 @@ export class Block {
             bw = new 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.sha256sha256(buf);
-            hashes.push(resultHash);
+        const hashes = [];
+        for (const tx of this.transactions) {
+            const combined = Buffer.concat([tx.hashBuffer, tx.txidBuffer]);
+            hashes.push(Hash.sha256sha256(combined));
         }
         return hashes;
     }
@@ -191,12 +105,12 @@ export 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.sha256sha256(buf));
+                const combined = Buffer.concat([tree[j + i], tree[j + i + 1]]);
+                tree.push(Hash.sha256sha256(combined));
             }
             j += size;
         }
@@ -207,16 +121,45 @@ export class Block {
         return tree[tree.length - 1];
     }
     validMerkleRoot() {
-        const h = new BN(this.header.merkleRoot.toString('hex'), 'hex');
-        const c = new BN(this.getMerkleRoot().toString('hex'), 'hex');
-        if (!h.eq(c)) {
-            return false;
-        }
-        return true;
+        const headerRoot = BN.fromBuffer(this.header.merkleRoot);
+        const computedRoot = 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 = calcTreeHeight(nLeaves);
+        const vBits = [];
+        const vHash = [];
+        traverseAndBuild(height, 0, nLeaves, vHashes, vMatch, vBits, vHash, Block.NULL_HASH);
+        return new MerkleBlock({
+            header: this.header,
+            numTransactions: this.transactions.length,
+            hashes: vHash,
+            flags: vBits.map(b => (b ? 1 : 0)),
+        });
     }
     get hash() {
         if (!this._id) {
@@ -230,4 +173,59 @@ export class Block {
     inspect() {
         return '<Block ' + this.id + '>';
     }
+    static _from(arg) {
+        if (Buffer.isBuffer(arg)) {
+            return Block._readFromBuffer(new 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 Transaction ? tx : new Transaction(tx));
+            }
+        }
+        let header;
+        if (data.header instanceof BlockHeader) {
+            header = data.header;
+        }
+        else if (data.header) {
+            header = new BlockHeader(data.header);
+        }
+        else {
+            header = new BlockHeader();
+        }
+        return { header, transactions };
+    }
+    static _readFromBuffer(br) {
+        $.checkState(!br.finished(), 'No block data received');
+        const header = 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 Transaction();
+            transactions.push(tx.fromBufferReader(br));
+        }
+        return { header, transactions };
+    }
+    _initEmpty() {
+        this.header = new BlockHeader();
+        this.transactions = [];
+    }
+    _fromString(str) {
+        const buf = Buffer.from(str, 'hex');
+        const info = Block._readFromBuffer(new BufferReader(buf));
+        this.header = info.header;
+        this.transactions = info.transactions;
+    }
 }