path: root/blockchain.cpp

/*
    This file is part of cpp-ethereum.

    cpp-ethereum is free software: you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation, either version 3 of the License, or
    (at your option) any later version.

    cpp-ethereum is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.

    You should have received a copy of the GNU General Public License
    along with cpp-ethereum.  If not, see <http://www.gnu.org/licenses/>.
*/
/** @file block.cpp
 * @author Christoph Jentzsch <cj@ethdev.com>
 * @date 2015
 * block test functions.
 */

#include <libdevcrypto/FileSystem.h>
#include <libethereum/CanonBlockChain.h>
#include "TestHelper.h"

using namespace std;
using namespace json_spirit;
using namespace dev;
using namespace dev::eth;

namespace dev {  namespace test {

bytes createBlockRLPFromFields(mObject& _tObj);
void overwriteBlockHeader(BlockInfo& _current_BlockHeader, mObject& _blObj);
BlockInfo constructBlock(mObject& _o);
void updatePoW(BlockInfo& _bi);
void writeBlockHeaderToJson(mObject& _o, const BlockInfo& _bi);
RLPStream createFullBlockFromHeader(const BlockInfo& _bi, const bytes& _txs = RLPEmptyList, const bytes& _uncles = RLPEmptyList);

void doBlockchainTests(json_spirit::mValue& _v, bool _fillin)
{
    for (auto& i: _v.get_obj())
    {
        cerr << i.first << endl;
        mObject& o = i.second.get_obj();

        BOOST_REQUIRE(o.count("genesisBlockHeader"));
        BlockInfo biGenesisBlock = constructBlock(o["genesisBlockHeader"].get_obj());

        BOOST_REQUIRE(o.count("pre"));
        ImportTest importer(o["pre"].get_obj());
        State state(Address(), OverlayDB(), BaseState::Empty);
        importer.importState(o["pre"].get_obj(), state);
        state.commit();

        if (_fillin)
            biGenesisBlock.stateRoot = state.rootHash();
        else
            BOOST_CHECK_MESSAGE(biGenesisBlock.stateRoot == state.rootHash(), "root hash does not match");

        if (_fillin)
        {
            // find new valid nonce
            updatePoW(biGenesisBlock);

            //update genesis block in json file
            writeBlockHeaderToJson(o["genesisBlockHeader"].get_obj(), biGenesisBlock);
        }

        // create new "genesis" block
        RLPStream rlpGenesisBlock = createFullBlockFromHeader(biGenesisBlock);
        biGenesisBlock.verifyInternals(&rlpGenesisBlock.out());

        // construct blockchain
        BlockChain bc(rlpGenesisBlock.out(), string(), true);

        if (_fillin)
        {
            BOOST_REQUIRE(o.count("blocks"));
            mArray blArray;
            vector<BlockInfo> vBiBlocks;
            vBiBlocks.push_back(biGenesisBlock);
            for (auto const& bl: o["blocks"].get_array())
            {
                mObject blObj = bl.get_obj();

                // get txs
                TransactionQueue txs;
                BOOST_REQUIRE(blObj.count("transactions"));
                for (auto const& txObj: blObj["transactions"].get_array())
                {
                    mObject tx = txObj.get_obj();
                    importer.importTransaction(tx);
                    if (!txs.attemptImport(importer.m_transaction.rlp()))
                        cnote << "failed importing transaction\n";
                }

                // write uncle list
                BlockQueue uncleBlockQueue;
                mArray aUncleList;
                vector<BlockInfo> vBiUncles;

                for (auto const& uHObj: blObj["uncleHeaders"].get_array())
                {
                    mObject uncleHeaderObj = uHObj.get_obj();
                    BlockInfo uncleBlockFromFields = constructBlock(uncleHeaderObj);

                    // make uncle header valid
                    uncleBlockFromFields.timestamp = (u256)time(0);
                    if (vBiBlocks.size() > 2)
                        uncleBlockFromFields.populateFromParent(vBiBlocks[vBiBlocks.size()-2]);
                    else
                        continue;

                    updatePoW(uncleBlockFromFields);
                    writeBlockHeaderToJson(uncleHeaderObj, uncleBlockFromFields);

                    aUncleList.push_back(uncleHeaderObj);
                    vBiUncles.push_back(uncleBlockFromFields);

                    cnote << "import uncle in blockQueue";
                    RLPStream uncle = createFullBlockFromHeader(uncleBlockFromFields);
                    uncleBlockQueue.import(&uncle.out(), bc);
                }

                blObj["uncleHeaders"] = aUncleList;
                bc.sync(uncleBlockQueue, state.db(), 4);
                state.commitToMine(bc);

                try
                {
                    state.sync(bc);
                    state.sync(bc,txs);
                    state.commitToMine(bc);
                    MineInfo info;
                    for (info.completed = false; !info.completed; info = state.mine()) {}
                    state.completeMine();
                }
                catch (Exception const& _e)
                {
                    cnote << "state sync or mining did throw an exception: " << diagnostic_information(_e);
                    return;
                }
                catch (std::exception const& _e)
                {
                    cnote << "state sync or mining did throw an exception: " << _e.what();
                    return;
                }

                blObj["rlp"] = "0x" + toHex(state.blockData());

                // write valid txs
                mArray txArray;
                Transactions txList;
                for (auto const& txi: txs.transactions())
                {
                    Transaction tx(txi.second, CheckSignature::Sender);
                    txList.push_back(tx);
                    mObject txObject;
                    txObject["nonce"] = toString(tx.nonce());
                    txObject["data"] = "0x" + toHex(tx.data());
                    txObject["gasLimit"] = toString(tx.gas());
                    txObject["gasPrice"] = toString(tx.gasPrice());
                    txObject["r"] = "0x" + toString(tx.signature().r);
                    txObject["s"] = "0x" + toString(tx.signature().s);
                    txObject["v"] = to_string(tx.signature().v + 27);
                    txObject["to"] = tx.isCreation() ? "" : toString(tx.receiveAddress());
                    txObject["value"] = toString(tx.value());

                    txArray.push_back(txObject);
                }

                blObj["transactions"] = txArray;

                BlockInfo current_BlockHeader = state.info();

                if (blObj.count("blockHeader"))
                    overwriteBlockHeader(current_BlockHeader, blObj);

                // write block header
                mObject oBlockHeader;
                writeBlockHeaderToJson(oBlockHeader, current_BlockHeader);
                blObj["blockHeader"] = oBlockHeader;
                vBiBlocks.push_back(current_BlockHeader);

                // compare blocks from state and from rlp
                RLPStream txStream;
                txStream.appendList(txList.size());
                for (unsigned i = 0; i < txList.size(); ++i)
                {
                    RLPStream txrlp;
                    txList[i].streamRLP(txrlp);
                    txStream.appendRaw(txrlp.out());
                }

                RLPStream uncleStream;
                uncleStream.appendList(vBiUncles.size());
                for (unsigned i = 0; i < vBiUncles.size(); ++i)
                {
                    RLPStream uncleRlp;
                    vBiUncles[i].streamRLP(uncleRlp, WithNonce);
                    uncleStream.appendRaw(uncleRlp.out());
                }

                RLPStream block2 = createFullBlockFromHeader(current_BlockHeader, txStream.out(), uncleStream.out());

                blObj["rlp"] = "0x" + toHex(block2.out());

                if (sha3(RLP(state.blockData())[0].data()) != sha3(RLP(block2.out())[0].data()))
                    cnote << "block header mismatch\n";

                if (sha3(RLP(state.blockData())[1].data()) != sha3(RLP(block2.out())[1].data()))
                    cnote << "txs mismatch\n";

                if (sha3(RLP(state.blockData())[2].data()) != sha3(RLP(block2.out())[2].data()))
                    cnote << "uncle list mismatch\n" << RLP(state.blockData())[2].data() << "\n" << RLP(block2.out())[2].data();

                try
                {
                    state.sync(bc);
                    bc.import(block2.out(), state.db());
                    state.sync(bc);
                    state.commit();
                }
                // if exception is thrown, RLP is invalid and no blockHeader, Transaction list, or Uncle list should be given
                catch (...)
                {
                    cnote << "block is invalid!\n";
                    blObj.erase(blObj.find("blockHeader"));
                    blObj.erase(blObj.find("uncleHeaders"));
                    blObj.erase(blObj.find("transactions"));
                }
                blArray.push_back(blObj);
            }
            o["blocks"] = blArray;
        }

        else
        {
            for (auto const& bl: o["blocks"].get_array())
            {
                mObject blObj = bl.get_obj();
                bytes blockRLP;
                try
                {
                    state.sync(bc);
                    blockRLP = importByteArray(blObj["rlp"].get_str());
                    bc.import(blockRLP, state.db());
                    state.sync(bc);
                }
                // if exception is thrown, RLP is invalid and no blockHeader, Transaction list, or Uncle list should be given
                catch (Exception const& _e)
                {
                    cnote << "state sync or block import did throw an exception: " << diagnostic_information(_e);
                    BOOST_CHECK(blObj.count("blockHeader") == 0);
                    BOOST_CHECK(blObj.count("transactions") == 0);
                    BOOST_CHECK(blObj.count("uncleHeaders") == 0);
                    continue;
                }
                catch (std::exception const& _e)
                {
                    cnote << "state sync or block import did throw an exception: " << _e.what();
                    BOOST_CHECK(blObj.count("blockHeader") == 0);
                    BOOST_CHECK(blObj.count("transactions") == 0);
                    BOOST_CHECK(blObj.count("uncleHeaders") == 0);
                    continue;
                }
                catch(...)
                {
                    cnote << "state sync or block import did throw an exception\n";
                    BOOST_CHECK(blObj.count("blockHeader") == 0);
                    BOOST_CHECK(blObj.count("transactions") == 0);
                    BOOST_CHECK(blObj.count("uncleHeaders") == 0);
                    continue;
                }

                BOOST_REQUIRE(blObj.count("blockHeader"));

                mObject tObj = blObj["blockHeader"].get_obj();
                BlockInfo blockHeaderFromFields;
                const bytes c_rlpBytesBlockHeader = createBlockRLPFromFields(tObj);
                const RLP c_blockHeaderRLP(c_rlpBytesBlockHeader);
                blockHeaderFromFields.populateFromHeader(c_blockHeaderRLP, false);

                BlockInfo blockFromRlp = bc.info();

                //Check the fields restored from RLP to original fields
                BOOST_CHECK_MESSAGE(blockHeaderFromFields.headerHash(WithNonce) == blockFromRlp.headerHash(WithNonce), "hash in given RLP not matching the block hash!");
                BOOST_CHECK_MESSAGE(blockHeaderFromFields.parentHash == blockFromRlp.parentHash, "parentHash in given RLP not matching the block parentHash!");
                BOOST_CHECK_MESSAGE(blockHeaderFromFields.sha3Uncles == blockFromRlp.sha3Uncles, "sha3Uncles in given RLP not matching the block sha3Uncles!");
                BOOST_CHECK_MESSAGE(blockHeaderFromFields.coinbaseAddress == blockFromRlp.coinbaseAddress,"coinbaseAddress in given RLP not matching the block coinbaseAddress!");
                BOOST_CHECK_MESSAGE(blockHeaderFromFields.stateRoot == blockFromRlp.stateRoot, "stateRoot in given RLP not matching the block stateRoot!");
                BOOST_CHECK_MESSAGE(blockHeaderFromFields.transactionsRoot == blockFromRlp.transactionsRoot, "transactionsRoot in given RLP not matching the block transactionsRoot!");
                BOOST_CHECK_MESSAGE(blockHeaderFromFields.receiptsRoot == blockFromRlp.receiptsRoot, "receiptsRoot in given RLP not matching the block receiptsRoot!");
                BOOST_CHECK_MESSAGE(blockHeaderFromFields.logBloom == blockFromRlp.logBloom, "logBloom in given RLP not matching the block logBloom!");
                BOOST_CHECK_MESSAGE(blockHeaderFromFields.difficulty == blockFromRlp.difficulty, "difficulty in given RLP not matching the block difficulty!");
                BOOST_CHECK_MESSAGE(blockHeaderFromFields.number == blockFromRlp.number, "number in given RLP not matching the block number!");
                BOOST_CHECK_MESSAGE(blockHeaderFromFields.gasLimit == blockFromRlp.gasLimit,"gasLimit in given RLP not matching the block gasLimit!");
                BOOST_CHECK_MESSAGE(blockHeaderFromFields.gasUsed == blockFromRlp.gasUsed, "gasUsed in given RLP not matching the block gasUsed!");
                BOOST_CHECK_MESSAGE(blockHeaderFromFields.timestamp == blockFromRlp.timestamp, "timestamp in given RLP not matching the block timestamp!");
                BOOST_CHECK_MESSAGE(blockHeaderFromFields.extraData == blockFromRlp.extraData, "extraData in given RLP not matching the block extraData!");
                BOOST_CHECK_MESSAGE(blockHeaderFromFields.mixHash == blockFromRlp.mixHash, "mixHash in given RLP not matching the block mixHash!");
                BOOST_CHECK_MESSAGE(blockHeaderFromFields.seedHash == blockFromRlp.seedHash, "transactionsRoot in given RLP not matching the block transactionsRoot!");
                BOOST_CHECK_MESSAGE(blockHeaderFromFields.nonce == blockFromRlp.nonce, "nonce in given RLP not matching the block nonce!");

                BOOST_CHECK_MESSAGE(blockHeaderFromFields == blockFromRlp, "However, blockHeaderFromFields != blockFromRlp!");

                //Check transaction list

                Transactions txsFromField;

                for (auto const& txObj: blObj["transactions"].get_array())
                {
                    mObject tx = txObj.get_obj();

                    BOOST_REQUIRE(tx.count("nonce"));
                    BOOST_REQUIRE(tx.count("gasPrice"));
                    BOOST_REQUIRE(tx.count("gasLimit"));
                    BOOST_REQUIRE(tx.count("to"));
                    BOOST_REQUIRE(tx.count("value"));
                    BOOST_REQUIRE(tx.count("v"));
                    BOOST_REQUIRE(tx.count("r"));
                    BOOST_REQUIRE(tx.count("s"));
                    BOOST_REQUIRE(tx.count("data"));

                    try
                    {
                        Transaction t(createRLPStreamFromTransactionFields(tx).out(), CheckSignature::Sender);
                        txsFromField.push_back(t);
                    }
                    catch (Exception const& _e)
                    {
                        BOOST_ERROR("Failed transaction constructor with Exception: " << diagnostic_information(_e));
                    }
                    catch (exception const& _e)
                    {
                        cnote << _e.what();
                    }
                }

                Transactions txsFromRlp;
                RLP root(blockRLP);
                for (auto const& tr: root[1])
                {
                    Transaction tx(tr.data(), CheckSignature::Sender);
                    txsFromRlp.push_back(tx);
                }

                BOOST_CHECK_MESSAGE(txsFromRlp.size() == txsFromField.size(), "transaction list size does not match");

                for (size_t i = 0; i < txsFromField.size(); ++i)
                {
                    BOOST_CHECK_MESSAGE(txsFromField[i].data() == txsFromRlp[i].data(), "transaction data in rlp and in field do not match");
                    BOOST_CHECK_MESSAGE(txsFromField[i].gas() == txsFromRlp[i].gas(), "transaction gasLimit in rlp and in field do not match");
                    BOOST_CHECK_MESSAGE(txsFromField[i].gasPrice() == txsFromRlp[i].gasPrice(), "transaction gasPrice in rlp and in field do not match");
                    BOOST_CHECK_MESSAGE(txsFromField[i].nonce() == txsFromRlp[i].nonce(), "transaction nonce in rlp and in field do not match");
                    BOOST_CHECK_MESSAGE(txsFromField[i].signature().r == txsFromRlp[i].signature().r, "transaction r in rlp and in field do not match");
                    BOOST_CHECK_MESSAGE(txsFromField[i].signature().s == txsFromRlp[i].signature().s, "transaction s in rlp and in field do not match");
                    BOOST_CHECK_MESSAGE(txsFromField[i].signature().v == txsFromRlp[i].signature().v, "transaction v in rlp and in field do not match");
                    BOOST_CHECK_MESSAGE(txsFromField[i].receiveAddress() == txsFromRlp[i].receiveAddress(), "transaction receiveAddress in rlp and in field do not match");
                    BOOST_CHECK_MESSAGE(txsFromField[i].value() == txsFromRlp[i].value(), "transaction receiveAddress in rlp and in field do not match");

                    BOOST_CHECK_MESSAGE(txsFromField[i] == txsFromRlp[i], "transactions from  rlp and transaction from field do not match");
                    BOOST_CHECK_MESSAGE(txsFromField[i].rlp() == txsFromRlp[i].rlp(), "transactions rlp do not match");

                }

                // check uncle list

                // uncles from uncle list field
                vector<BlockInfo> uBlHsFromField;
                if (blObj["uncleHeaders"].type() != json_spirit::null_type)
                    for (auto const& uBlHeaderObj: blObj["uncleHeaders"].get_array())
                    {
                        mObject uBlH = uBlHeaderObj.get_obj();
                        cout << "uBlH.size(): " << uBlH.size() << endl;
                        BOOST_REQUIRE(uBlH.size() == 17);
                        bytes uncleRLP = createBlockRLPFromFields(uBlH);
                        const RLP c_uRLP(uncleRLP);
                        BlockInfo uncleBlockHeader;
                        try
                        {
                            uncleBlockHeader.populateFromHeader(c_uRLP, true);
                        }
                        catch(...)
                        {
                            BOOST_ERROR("invalid uncle header");
                        }
                        uBlHsFromField.push_back(uncleBlockHeader);
                    }

                // uncles from block RLP
                vector<BlockInfo> uBlHsFromRlp;
                for (auto const& uRLP: root[2])
                {
                    BlockInfo uBl;
                    uBl.populateFromHeader(uRLP, true);
                    uBlHsFromRlp.push_back(uBl);
                }

                BOOST_REQUIRE_EQUAL(uBlHsFromField.size(), uBlHsFromRlp.size());

                for (size_t i = 0; i < uBlHsFromField.size(); ++i)
                    BOOST_CHECK_MESSAGE(uBlHsFromField[i] == uBlHsFromRlp[i], "block header in rlp and in field do not match");
            }
        }
    }
}

// helping functions

bytes createBlockRLPFromFields(mObject& _tObj)
{
    RLPStream rlpStream;
    rlpStream.appendList(_tObj.count("hash") > 0 ? (_tObj.size() - 1) : _tObj.size());

    if (_tObj.count("parentHash"))
        rlpStream << importByteArray(_tObj["parentHash"].get_str());

    if (_tObj.count("uncleHash"))
        rlpStream << importByteArray(_tObj["uncleHash"].get_str());

    if (_tObj.count("coinbase"))
        rlpStream << importByteArray(_tObj["coinbase"].get_str());

    if (_tObj.count("stateRoot"))
        rlpStream << importByteArray(_tObj["stateRoot"].get_str());

    if (_tObj.count("transactionsTrie"))
        rlpStream << importByteArray(_tObj["transactionsTrie"].get_str());

    if (_tObj.count("receiptTrie"))
        rlpStream << importByteArray(_tObj["receiptTrie"].get_str());

    if (_tObj.count("bloom"))
        rlpStream << importByteArray(_tObj["bloom"].get_str());

    if (_tObj.count("difficulty"))
        rlpStream << bigint(_tObj["difficulty"].get_str());

    if (_tObj.count("number"))
        rlpStream << bigint(_tObj["number"].get_str());

    if (_tObj.count("gasLimit"))
        rlpStream << bigint(_tObj["gasLimit"].get_str());

    if (_tObj.count("gasUsed"))
        rlpStream << bigint(_tObj["gasUsed"].get_str());

    if (_tObj.count("timestamp"))
        rlpStream << bigint(_tObj["timestamp"].get_str());

    if (_tObj.count("extraData"))
        rlpStream << fromHex(_tObj["extraData"].get_str());

    if (_tObj.count("seedHash"))
        rlpStream << importByteArray(_tObj["seedHash"].get_str());

    if (_tObj.count("mixHash"))
        rlpStream << importByteArray(_tObj["mixHash"].get_str());

    if (_tObj.count("nonce"))
        rlpStream << importByteArray(_tObj["nonce"].get_str());

    return rlpStream.out();
}

void overwriteBlockHeader(BlockInfo& _current_BlockHeader, mObject& _blObj)
{
    if (_blObj["blockHeader"].get_obj().size() != 14)
    {

        BlockInfo tmp = _current_BlockHeader;

        if (_blObj["blockHeader"].get_obj().count("parentHash"))
            tmp.parentHash = h256(_blObj["blockHeader"].get_obj()["parentHash"].get_str());

        if (_blObj["blockHeader"].get_obj().count("uncleHash"))
            tmp.sha3Uncles = h256(_blObj["blockHeader"].get_obj()["uncleHash"].get_str());

        if (_blObj["blockHeader"].get_obj().count("coinbase"))
            tmp.coinbaseAddress = Address(_blObj["blockHeader"].get_obj()["coinbase"].get_str());

        if (_blObj["blockHeader"].get_obj().count("stateRoot"))
            tmp.stateRoot = h256(_blObj["blockHeader"].get_obj()["stateRoot"].get_str());

        if (_blObj["blockHeader"].get_obj().count("transactionsTrie"))
            tmp.transactionsRoot = h256(_blObj["blockHeader"].get_obj()["transactionsTrie"].get_str());

        if (_blObj["blockHeader"].get_obj().count("receiptTrie"))
            tmp.receiptsRoot = h256(_blObj["blockHeader"].get_obj()["receiptTrie"].get_str());

        if (_blObj["blockHeader"].get_obj().count("bloom"))
            tmp.logBloom = LogBloom(_blObj["blockHeader"].get_obj()["bloom"].get_str());

        if (_blObj["blockHeader"].get_obj().count("difficulty"))
            tmp.difficulty = toInt(_blObj["blockHeader"].get_obj()["difficulty"]);

        if (_blObj["blockHeader"].get_obj().count("number"))
            tmp.number = toInt(_blObj["blockHeader"].get_obj()["number"]);

        if (_blObj["blockHeader"].get_obj().count("gasLimit"))
            tmp.gasLimit = toInt(_blObj["blockHeader"].get_obj()["gasLimit"]);

        if (_blObj["blockHeader"].get_obj().count("gasUsed"))
            tmp.gasUsed = toInt(_blObj["blockHeader"].get_obj()["gasUsed"]);

        if (_blObj["blockHeader"].get_obj().count("timestamp"))
            tmp.timestamp = toInt(_blObj["blockHeader"].get_obj()["timestamp"]);

        if (_blObj["blockHeader"].get_obj().count("extraData"))
            tmp.extraData = importByteArray(_blObj["blockHeader"].get_obj()["extraData"].get_str());

        if (_blObj["blockHeader"].get_obj().count("mixHash"))
            tmp.mixHash = h256(_blObj["blockHeader"].get_obj()["mixHash"].get_str());

        if (_blObj["blockHeader"].get_obj().count("seedHash"))
            tmp.seedHash = h256(_blObj["blockHeader"].get_obj()["seedHash"].get_str());

        // find new valid nonce

        if (tmp != _current_BlockHeader)
        {
            _current_BlockHeader = tmp;

            ProofOfWork pow;
            std::pair<MineInfo, Ethash::Proof> ret;
            while (!ProofOfWork::verify(_current_BlockHeader))
            {
                ret = pow.mine(_current_BlockHeader, 1000, true, true); // tie(ret, blockFromFields.nonce)
                Ethash::assignResult(ret.second, _current_BlockHeader);
            }
        }
    }
    else
    {
        // take the blockheader as is
        const bytes c_blockRLP = createBlockRLPFromFields(_blObj["blockHeader"].get_obj());
        const RLP c_bRLP(c_blockRLP);
        _current_BlockHeader.populateFromHeader(c_bRLP, false);
    }
}

BlockInfo constructBlock(mObject& _o)
{

    BlockInfo ret;
    try
    {
        // construct genesis block
        const bytes c_blockRLP = createBlockRLPFromFields(_o);
        const RLP c_bRLP(c_blockRLP);
        ret.populateFromHeader(c_bRLP, false);
    }
    catch (Exception const& _e)
    {
        cnote << "block population did throw an exception: " << diagnostic_information(_e);
        BOOST_ERROR("Failed block population with Exception: " << _e.what());
    }
    catch (std::exception const& _e)
    {
        BOOST_ERROR("Failed block population with Exception: " << _e.what());
    }
    catch(...)
    {
        BOOST_ERROR("block population did throw an unknown exception\n");
    }
    return ret;
}

void updatePoW(BlockInfo& _bi)
{
    ProofOfWork pow;
    std::pair<MineInfo, Ethash::Proof> ret;
    while (!ProofOfWork::verify(_bi))
    {
        ret = pow.mine(_bi, 10000, true, true); // tie(ret, blockFromFields.nonce)
        Ethash::assignResult(ret.second, _bi);
    }
}

void writeBlockHeaderToJson(mObject& _o, const BlockInfo& _bi)
{
    _o["parentHash"] = toString(_bi.parentHash);
    _o["uncleHash"] = toString(_bi.sha3Uncles);
    _o["coinbase"] = toString(_bi.coinbaseAddress);
    _o["stateRoot"] = toString(_bi.stateRoot);
    _o["transactionsTrie"] = toString(_bi.transactionsRoot);
    _o["receiptTrie"] = toString(_bi.receiptsRoot);
    _o["bloom"] = toString(_bi.logBloom);
    _o["difficulty"] = toString(_bi.difficulty);
    _o["number"] = toString(_bi.number);
    _o["gasLimit"] = toString(_bi.gasLimit);
    _o["gasUsed"] = toString(_bi.gasUsed);
    _o["timestamp"] = toString(_bi.timestamp);
    _o["extraData"] ="0x" + toHex(_bi.extraData);
    _o["mixHash"] = toString(_bi.mixHash);
    _o["seedHash"] = toString(_bi.seedHash);
    _o["nonce"] = toString(_bi.nonce);
    _o["hash"] = toString(_bi.hash);
}

RLPStream createFullBlockFromHeader(const BlockInfo& _bi,const bytes& _txs, const bytes& _uncles )
{
    RLPStream rlpStream;
    _bi.streamRLP(rlpStream, WithNonce);

    RLPStream ret(3);
    ret.appendRaw(rlpStream.out());
    ret.appendRaw(_txs);
    ret.appendRaw(_uncles);

    return ret;
}
} }// Namespace Close


BOOST_AUTO_TEST_SUITE(BlockChainTests)

BOOST_AUTO_TEST_CASE(bcBlockChainTest)
{
    dev::test::executeTests("bcBlockChainTest", "/BlockTests", dev::test::doBlockchainTests);
}

BOOST_AUTO_TEST_CASE(bcValidBlockTest)
{
    dev::test::executeTests("bcValidBlockTest", "/BlockTests", dev::test::doBlockchainTests);
}

BOOST_AUTO_TEST_CASE(bcInvalidHeaderTest)
{
    dev::test::executeTests("bcInvalidHeaderTest", "/BlockTests", dev::test::doBlockchainTests);
}

BOOST_AUTO_TEST_CASE(bcUncleTest)
{
    dev::test::executeTests("bcUncleTest", "/BlockTests", dev::test::doBlockchainTests);
}

BOOST_AUTO_TEST_CASE(userDefinedFileBc)
{
    dev::test::userDefinedTest("--bctest", dev::test::doBlockchainTests);
}

BOOST_AUTO_TEST_SUITE_END()