diff options
Diffstat (limited to 'blockchain.cpp')
| -rw-r--r-- | blockchain.cpp | 648 |
1 files changed, 648 insertions, 0 deletions
diff --git a/blockchain.cpp b/blockchain.cpp new file mode 100644 index 00000000..ccbc8495 --- /dev/null +++ b/blockchain.cpp @@ -0,0 +1,648 @@ +/* + 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; + GasPricer gp(10000); + 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, gp); + 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, IgnoreNonce); + + 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); + } + 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); + 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, IgnoreNonce); + } +} + +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, IgnoreNonce); + } + 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() + |