xpi-ts 0.2.0

package/dist/lib/bitcore/address.js

@@ -0,0 +1,407 @@
+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';
+export class Address {
+    static PayToPublicKeyHash = 'pubkeyhash';
+    static PayToScriptHash = 'scripthash';
+    static PayToTaproot = 'taproot';
+    hashBuffer;
+    network;
+    type;
+    constructor(data, network, type) {
+        if (Array.isArray(data) && typeof network === 'number') {
+            return Address.createMultisig(data, network, type);
+        }
+        if (data instanceof Address) {
+            return data;
+        }
+        Preconditions.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".');
+        }
+        const networkExplicitlyProvided = network !== undefined;
+        network ||= defaultNetwork;
+        if (type &&
+            type !== Address.PayToPublicKeyHash &&
+            type !== Address.PayToScriptHash &&
+            type !== Address.PayToTaproot) {
+            throw new TypeError('Third argument must be "pubkeyhash", "scripthash", or "taproot".');
+        }
+        const info = this._classifyArguments(data, network, type, networkExplicitlyProvided);
+        info.network = info.network || getNetwork(network) || defaultNetwork;
+        info.type = info.type || type || Address.PayToPublicKeyHash;
+        JSUtil.defineImmutable(this, {
+            hashBuffer: info.hashBuffer,
+            network: info.network,
+            type: info.type,
+        });
+    }
+    _classifyArguments(data, network, type, networkExplicitlyProvided = true) {
+        if (typeof network === 'string') {
+            const networkObj = getNetwork(network);
+            if (!networkObj) {
+                throw new TypeError('Unknown network');
+            }
+            network = networkObj;
+        }
+        if ((Buffer.isBuffer(data) || data instanceof Uint8Array) &&
+            data.length === 20) {
+            return Address._transformHash(data);
+        }
+        else if ((Buffer.isBuffer(data) || data instanceof Uint8Array) &&
+            data.length === 21) {
+            return Address._transformBuffer(data, network, type);
+        }
+        else if ((Buffer.isBuffer(data) || data instanceof Uint8Array) &&
+            data.length === 33) {
+            return {
+                hashBuffer: Buffer.from(data),
+                network: typeof network === 'string' ? getNetwork(network) : network,
+                type: type || Address.PayToTaproot,
+            };
+        }
+        else if (data instanceof PublicKey) {
+            return Address._transformPublicKey(data, network);
+        }
+        else if (data instanceof Script) {
+            return Address._transformScript(data, network);
+        }
+        else if (typeof data === 'string') {
+            return Address._transformString(data, networkExplicitlyProvided ? network : undefined, type);
+        }
+        else if (Array.isArray(data)) {
+            throw new Error('Multisig addresses should be created with createMultisig');
+        }
+        else if (typeof data === 'object' && data !== null) {
+            return Address._transformObject(data);
+        }
+        else {
+            throw new TypeError('First argument is an unrecognized data format.');
+        }
+    }
+    static _classifyFromVersion(buffer) {
+        const version = {};
+        const pubkeyhashNetwork = getNetwork(buffer[0], 'pubkeyhash');
+        const scripthashNetwork = getNetwork(buffer[0], 'scripthash');
+        if (pubkeyhashNetwork) {
+            version.network = pubkeyhashNetwork;
+            version.type = Address.PayToPublicKeyHash;
+        }
+        else if (scripthashNetwork) {
+            version.network = scripthashNetwork;
+            version.type = Address.PayToScriptHash;
+        }
+        return version;
+    }
+    static _transformString(data, network, type) {
+        if (typeof data !== 'string') {
+            throw new TypeError('data parameter supplied is not a string.');
+        }
+        data = data.trim();
+        const networkObj = getNetwork(network);
+        if (network && !networkObj) {
+            throw new TypeError('Unknown network');
+        }
+        if (data.indexOf(':') !== -1) {
+            const info = Address.decodeCashAddress(data);
+            if (!info.network ||
+                (networkObj && networkObj.name !== info.network.name)) {
+                throw new TypeError('Address has mismatched network type.');
+            }
+            return {
+                hashBuffer: Buffer.from(info.hashBuffer),
+                network: info.network,
+                type: info.type,
+            };
+        }
+        if (Address._isXAddress(data)) {
+            const info = Address._transformXAddressString(data, network, type);
+            if (!info.network ||
+                (networkObj && networkObj.name !== info.network.name)) {
+                throw new TypeError('Address has mismatched network type.');
+            }
+            return info;
+        }
+        const info = Address._transformLegacyString(data, network, type);
+        if (!info.network ||
+            (networkObj && networkObj.name !== info.network.name)) {
+            throw new TypeError('Address has mismatched network type.');
+        }
+        return info;
+    }
+    static _transformLegacyString(data, network, type) {
+        const info = {};
+        const decoded = Base58Check.decode(data);
+        const version = Address._classifyFromVersion(decoded);
+        if (!version.network || !version.type) {
+            throw new TypeError('Address has invalid version.');
+        }
+        info.hashBuffer = decoded.subarray(1);
+        info.network = version.network;
+        info.type = version.type;
+        return info;
+    }
+    static _isXAddress(data) {
+        const match = /[A-Z]|_/.exec(data);
+        return match !== null && match.index > 0;
+    }
+    static _transformXAddressString(data, network, type) {
+        if (typeof network === 'string') {
+            network = getNetwork(network);
+        }
+        network ||= defaultNetwork;
+        const decodedXAddress = XAddress._decode(data);
+        if (!decodedXAddress.hashBuffer) {
+            throw new TypeError('Invalid XAddress.');
+        }
+        let hashBuffer = decodedXAddress.hashBuffer;
+        const decodedNetwork = decodedXAddress.network || network;
+        const decodedType = decodedXAddress.type;
+        if (decodedType === 'taproot' || decodedType === Address.PayToTaproot) {
+            if (hashBuffer.length === 36 &&
+                hashBuffer[0] === 0x62 &&
+                hashBuffer[1] === 0x51 &&
+                hashBuffer[2] === 0x21) {
+                hashBuffer = hashBuffer.subarray(3, 36);
+            }
+            else if (hashBuffer.length === 33) {
+            }
+            else {
+                throw new TypeError(`Taproot address has invalid payload length: ${hashBuffer.length} bytes (expected 33 or 36)`);
+            }
+            return {
+                hashBuffer: hashBuffer,
+                network: decodedNetwork,
+                type: Address.PayToTaproot,
+            };
+        }
+        if (hashBuffer.length === 25 &&
+            hashBuffer[0] === 0x76 &&
+            hashBuffer[1] === 0xa9 &&
+            hashBuffer[2] === 0x14) {
+            hashBuffer = hashBuffer.subarray(3, 23);
+        }
+        else if (hashBuffer.length === 23 &&
+            hashBuffer[0] === 0xa9 &&
+            hashBuffer[1] === 0x14 &&
+            hashBuffer[22] === 0x87) {
+            hashBuffer = hashBuffer.subarray(2, 22);
+            return {
+                hashBuffer: hashBuffer,
+                network: decodedNetwork,
+                type: Address.PayToScriptHash,
+            };
+        }
+        return {
+            hashBuffer: hashBuffer,
+            network: decodedNetwork,
+            type: type ?? Address.PayToPublicKeyHash,
+        };
+    }
+    static _transformHash(hash) {
+        const info = {};
+        if (!Buffer.isBuffer(hash) && !(hash instanceof Uint8Array)) {
+            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);
+        return info;
+    }
+    static _transformBuffer(buffer, network, type) {
+        const info = {};
+        if (!Buffer.isBuffer(buffer) && !(buffer instanceof Uint8Array)) {
+            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));
+        if (network && !networkObj) {
+            throw new TypeError('Unknown network');
+        }
+        if (!bufferVersion.network ||
+            (networkObj && networkObj !== bufferVersion.network)) {
+            throw new TypeError('Address has mismatched network type.');
+        }
+        if (!bufferVersion.type || (type && type !== bufferVersion.type)) {
+            throw new TypeError('Address has mismatched type.');
+        }
+        info.hashBuffer = Buffer.from(buffer).subarray(1);
+        info.network = bufferVersion.network;
+        info.type = bufferVersion.type;
+        return info;
+    }
+    static _transformPublicKey(pubkey, network) {
+        const info = {};
+        if (!(pubkey instanceof PublicKey)) {
+            throw new TypeError('Address must be an instance of PublicKey.');
+        }
+        info.hashBuffer = Hash.sha256ripemd160(pubkey.toBuffer());
+        info.type = Address.PayToPublicKeyHash;
+        info.network = network ?? defaultNetwork;
+        return info;
+    }
+    static _transformScript(script, network) {
+        Preconditions.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');
+        }
+        if (typeof network === 'string') {
+            network = getNetwork(network);
+        }
+        if (network && network !== address.network) {
+            throw new TypeError('Provided network does not match the Address network.');
+        }
+        return {
+            hashBuffer: address.hashBuffer,
+            network: address.network,
+            type: address.type,
+        };
+    }
+    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');
+        return {
+            hashBuffer: data.hashBuffer || Buffer.from(data.hashBuffer.toString(), 'hex'),
+            network: getNetwork(data.network) || defaultNetwork,
+            type: data.type,
+        };
+    }
+    static createMultisig(publicKeys, threshold, network) {
+        const networkObj = network || publicKeys[0].network || defaultNetwork;
+        return Address.payingTo(Script.buildMultisigOut(publicKeys, threshold, {}), networkObj);
+    }
+    static fromPublicKey(data, network) {
+        const networkObj = getNetwork(network) || defaultNetwork;
+        const info = Address._transformPublicKey(data, networkObj);
+        return new Address(info.hashBuffer, info.network, info.type);
+    }
+    static fromPublicKeyHash(hash, network) {
+        const networkObj = getNetwork(network) || defaultNetwork;
+        return new Address(hash, networkObj, Address.PayToPublicKeyHash);
+    }
+    static fromScriptHash(hash, network) {
+        const networkObj = getNetwork(network) || defaultNetwork;
+        return new Address(hash, networkObj, Address.PayToScriptHash);
+    }
+    static fromTaprootCommitment(commitment, network) {
+        const networkObj = getNetwork(network) || defaultNetwork;
+        const commitmentBuf = commitment instanceof PublicKey ? commitment.toBuffer() : commitment;
+        if (commitmentBuf.length !== 33) {
+            throw new Error('Taproot commitment must be 33-byte compressed public key');
+        }
+        return new Address(commitmentBuf, networkObj, Address.PayToTaproot);
+    }
+    static fromBuffer(buffer, network, type) {
+        const info = Address._transformBuffer(buffer, network, type);
+        return new Address(info.hashBuffer, info.network, info.type);
+    }
+    static fromString(str, network) {
+        const info = Address._transformString(str, network);
+        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');
+        return new Address(hashBuffer, obj.network, obj.type);
+    }
+    static fromScript(script, network) {
+        Preconditions.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');
+        return Address.fromScriptHash(Hash.sha256ripemd160(script.toBuffer()), network);
+    }
+    static getValidationError(data, network, type) {
+        try {
+            new Address(data, network, type);
+            return null;
+        }
+        catch (e) {
+            return e;
+        }
+    }
+    static isValid(data, network, type) {
+        return !Address.getValidationError(data, network, type);
+    }
+    isPayToPublicKeyHash() {
+        return this.type === Address.PayToPublicKeyHash;
+    }
+    isPayToScriptHash() {
+        return this.type === Address.PayToScriptHash;
+    }
+    isPayToTaproot() {
+        return this.type === Address.PayToTaproot;
+    }
+    toBuffer() {
+        return this.hashBuffer;
+    }
+    toFullBuffer() {
+        const version = Buffer.from([
+            this.network[this.type],
+        ]);
+        const buf = Buffer.concat([version, this.hashBuffer]);
+        return buf;
+    }
+    toCashBuffer() {
+        return this.toBuffer();
+    }
+    toObject() {
+        return {
+            hash: this.hashBuffer.toString('hex'),
+            type: this.type,
+            network: this.network.toString(),
+        };
+    }
+    toJSON() {
+        return this.toObject();
+    }
+    toString(network) {
+        return this.toXAddress(network);
+    }
+    toLegacyAddress() {
+        return this.toString();
+    }
+    toCashAddress() {
+        return this.toString();
+    }
+    toXAddress(network) {
+        if (this.isPayToTaproot()) {
+            const xaddr = new XAddress(this.hashBuffer, network ?? this.network, this.type);
+            return xaddr.toString();
+        }
+        const script = Script.fromAddress(this);
+        const xaddr = new XAddress(script.toBuffer(), network ?? this.network, this.type);
+        return xaddr.toString();
+    }
+    static decodeCashAddress(address) {
+        const info = Address._transformString(address);
+        return {
+            network: info.network,
+            type: info.type,
+            hashBuffer: info.hashBuffer,
+        };
+    }
+    inspect() {
+        return ('<Address: ' +
+            this.toString() +
+            ', type: ' +
+            this.type +
+            ', network: ' +
+            this.network +
+            '>');
+    }
+}

package/dist/lib/bitcore/block/block.d.ts

@@ -0,0 +1,57 @@
+import { BufferReader } from '../encoding/bufferreader.js';
+import { BufferWriter } from '../encoding/bufferwriter.js';
+import { Transaction } from '../transaction/index.js';
+import { BlockHeader, BlockHeaderData, BlockHeaderObject } from './blockheader.js';
+export interface BlockData {
+    header?: BlockHeader | BlockHeaderData;
+    metadata?: number;
+    transactions?: Transaction[];
+}
+export interface BlockObject {
+    id: string;
+    hash: string;
+    header: BlockHeaderObject;
+    metadata: number;
+    transactions: unknown[];
+}
+export declare class Block {
+    static readonly MAX_BLOCK_SIZE: number;
+    static readonly START_OF_BLOCK = 0;
+    static readonly NULL_HASH: Buffer<ArrayBuffer>;
+    static readonly Values: {
+        START_OF_BLOCK: number;
+        NULL_HASH: Buffer<ArrayBuffer>;
+    };
+    header: BlockHeader;
+    metadata: number;
+    transactions: Transaction[];
+    private _id?;
+    constructor(serialized?: BlockData | Block | Buffer | string);
+    static shallowCopy(block: Block): Block;
+    private static _from;
+    static fromObject(obj: BlockData): Block;
+    static fromBufferReader(br: BufferReader): Block;
+    static fromBuffer(buf: Buffer): Block;
+    static fromString(str: string): Block;
+    static fromRawBlock(data: Buffer | string): Block;
+    private static _fromObject;
+    private static _fromBufferReader;
+    private _newBlock;
+    fromBuffer(buf: Buffer): Block;
+    fromString(str: string): Block;
+    fromObject(obj: BlockData): Block;
+    toObject(): BlockObject;
+    toJSON: () => BlockObject;
+    toBuffer(): Buffer;
+    toString(): string;
+    toBufferWriter(bw?: BufferWriter): BufferWriter;
+    getTransactionHashes(): Buffer[];
+    getMerkleTree(): Buffer[];
+    getMerkleRoot(): Buffer;
+    validMerkleRoot(): boolean;
+    private _getHash;
+    get hash(): string;
+    get id(): string;
+    inspect(): string;
+}
+//# sourceMappingURL=block.d.ts.map

package/dist/lib/bitcore/block/block.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"block.d.ts","sourceRoot":"","sources":["../../../../lib/bitcore/block/block.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,YAAY,EAAE,MAAM,6BAA6B,CAAA;AAC1D,OAAO,EAAE,YAAY,EAAE,MAAM,6BAA6B,CAAA;AAG1D,OAAO,EAAE,WAAW,EAAE,MAAM,yBAAyB,CAAA;AAErD,OAAO,EACL,WAAW,EACX,eAAe,EACf,iBAAiB,EAClB,MAAM,kBAAkB,CAAA;AAEzB,MAAM,WAAW,SAAS;IACxB,MAAM,CAAC,EAAE,WAAW,GAAG,eAAe,CAAA;IACtC,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB,YAAY,CAAC,EAAE,WAAW,EAAE,CAAA;CAC7B;AAED,MAAM,WAAW,WAAW;IAC1B,EAAE,EAAE,MAAM,CAAA;IACV,IAAI,EAAE,MAAM,CAAA;IACZ,MAAM,EAAE,iBAAiB,CAAA;IACzB,QAAQ,EAAE,MAAM,CAAA;IAChB,YAAY,EAAE,OAAO,EAAE,CAAA;CACxB;AAED,qBAAa,KAAK;IAEhB,MAAM,CAAC,QAAQ,CAAC,cAAc,SAAmB;IACjD,MAAM,CAAC,QAAQ,CAAC,cAAc,KAAI;IAClC,MAAM,CAAC,QAAQ,CAAC,SAAS,sBAGxB;IAGD,MAAM,CAAC,QAAQ,CAAC,MAAM;;;MAMrB;IAGD,MAAM,EAAG,WAAW,CAAA;IACpB,QAAQ,EAAG,MAAM,CAAA;IACjB,YAAY,EAAG,WAAW,EAAE,CAAA;IAC5B,OAAO,CAAC,GAAG,CAAC,CAAQ;gBAER,UAAU,CAAC,EAAE,SAAS,GAAG,KAAK,GAAG,MAAM,GAAG,MAAM;IAsB5D,MAAM,CAAC,WAAW,CAAC,KAAK,EAAE,KAAK,GAAG,KAAK;IAQvC,OAAO,CAAC,MAAM,CAAC,KAAK;IAepB,MAAM,CAAC,UAAU,CAAC,GAAG,EAAE,SAAS,GAAG,KAAK;IAQxC,MAAM,CAAC,gBAAgB,CAAC,EAAE,EAAE,YAAY,GAAG,KAAK;IAShD,MAAM,CAAC,UAAU,CAAC,GAAG,EAAE,MAAM,GAAG,KAAK;IAOrC,MAAM,CAAC,UAAU,CAAC,GAAG,EAAE,MAAM,GAAG,KAAK;IAQrC,MAAM,CAAC,YAAY,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,GAAG,KAAK;IAajD,OAAO,CAAC,MAAM,CAAC,WAAW;IA0B1B,OAAO,CAAC,MAAM,CAAC,iBAAiB;IAuBhC,OAAO,CAAC,SAAS;IASjB,UAAU,CAAC,GAAG,EAAE,MAAM,GAAG,KAAK;IAW9B,UAAU,CAAC,GAAG,EAAE,MAAM,GAAG,KAAK;IAQ9B,UAAU,CAAC,GAAG,EAAE,SAAS,GAAG,KAAK;IAWjC,QAAQ,IAAI,WAAW;IAcvB,MAAM,QAdM,WAAW,CAcD;IAKtB,QAAQ,IAAI,MAAM;IAOlB,QAAQ,IAAI,MAAM;IAOlB,cAAc,CAAC,EAAE,CAAC,EAAE,YAAY,GAAG,YAAY;IAgB/C,oBAAoB,IAAI,MAAM,EAAE;IAoBhC,aAAa,IAAI,MAAM,EAAE;IAsBzB,aAAa,IAAI,MAAM;IAQvB,eAAe,IAAI,OAAO;IAc1B,OAAO,CAAC,QAAQ;IAQhB,IAAI,IAAI,IAAI,MAAM,CAKjB;IAKD,IAAI,EAAE,IAAI,MAAM,CAEf;IAKD,OAAO,IAAI,MAAM;CAGlB"}

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

@@ -0,0 +1,233 @@
+import { Preconditions } 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 { Transaction } from '../transaction/index.js';
+import { BN } from '../crypto/bn.js';
+import { BlockHeader, } from './blockheader.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'),
+    };
+    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);
+        }
+        else if (serialized && typeof serialized === 'object') {
+            this.fromObject(serialized);
+        }
+        else {
+            this._newBlock();
+        }
+    }
+    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;
+    }
+    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);
+        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);
+    }
+    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);
+        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,
+        };
+    }
+    toJSON = this.toObject;
+    toBuffer() {
+        return this.toBufferWriter().concat();
+    }
+    toString() {
+        return this.toBuffer().toString('hex');
+    }
+    toBufferWriter(bw) {
+        if (!bw) {
+            bw = new BufferWriter();
+        }
+        bw.write(this.header.toBuffer());
+        bw.writeUInt8(this.metadata);
+        bw.writeVarintNum(this.transactions.length);
+        for (let i = 0; i < this.transactions.length; i++) {
+            this.transactions[i].toBufferWriter(bw);
+        }
+        return bw;
+    }
+    getTransactionHashes() {
+        const hashes = [];
+        if (this.transactions.length === 0) {
+            return [Block.Values.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);
+        }
+        return hashes;
+    }
+    getMerkleTree() {
+        const tree = this.getTransactionHashes();
+        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);
+                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));
+            }
+            j += size;
+        }
+        return tree;
+    }
+    getMerkleRoot() {
+        const tree = this.getMerkleTree();
+        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;
+    }
+    _getHash() {
+        const header = this.header;
+        return header._getHash();
+    }
+    get hash() {
+        if (!this._id) {
+            this._id = this.header.id;
+        }
+        return this._id;
+    }
+    get id() {
+        return this.hash;
+    }
+    inspect() {
+        return '<Block ' + this.id + '>';
+    }
+}