Browse Source
Continuation of State split. libethereum building again. Compile fixes galore. Remove a lot of code redundancy. mix using new state/block classescl-refactor
Gav Wood
9 years ago
56 changed files with 1659 additions and 2177 deletions
@ -0,0 +1,810 @@ |
|||
/*
|
|||
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 Gav Wood <i@gavwood.com> |
|||
* @date 2014 |
|||
*/ |
|||
|
|||
#include "Block.h" |
|||
|
|||
#include <ctime> |
|||
#include <random> |
|||
#include <boost/filesystem.hpp> |
|||
#include <boost/timer.hpp> |
|||
#include <libdevcore/CommonIO.h> |
|||
#include <libdevcore/Assertions.h> |
|||
#include <libdevcore/StructuredLogger.h> |
|||
#include <libdevcore/TrieHash.h> |
|||
#include <libevmcore/Instruction.h> |
|||
#include <libethcore/Exceptions.h> |
|||
#include <libevm/VMFactory.h> |
|||
#include "BlockChain.h" |
|||
#include "Defaults.h" |
|||
#include "ExtVM.h" |
|||
#include "Executive.h" |
|||
#include "CachedAddressState.h" |
|||
#include "CanonBlockChain.h" |
|||
#include "TransactionQueue.h" |
|||
using namespace std; |
|||
using namespace dev; |
|||
using namespace dev::eth; |
|||
namespace fs = boost::filesystem; |
|||
|
|||
#define ctrace clog(BlockTrace) |
|||
#define ETH_TIMED_ENACTMENTS 0 |
|||
|
|||
static const u256 c_blockReward = c_network == Network::Olympic ? (1500 * finney) : (5 * ether); |
|||
static const unsigned c_maxSyncTransactions = 256; |
|||
|
|||
const char* BlockSafeExceptions::name() { return EthViolet "⚙" EthBlue " ℹ"; } |
|||
const char* BlockDetail::name() { return EthViolet "⚙" EthWhite " ◌"; } |
|||
const char* BlockTrace::name() { return EthViolet "⚙" EthGray " ◎"; } |
|||
const char* BlockChat::name() { return EthViolet "⚙" EthWhite " ◌"; } |
|||
|
|||
Block::Block(OverlayDB const& _db, BaseState _bs, Address _coinbaseAddress): |
|||
m_state(_db, _bs), |
|||
m_beneficiary(_coinbaseAddress), |
|||
m_blockReward(c_blockReward) |
|||
{ |
|||
m_previousBlock.clear(); |
|||
m_currentBlock.clear(); |
|||
// assert(m_state.root() == m_previousBlock.stateRoot());
|
|||
} |
|||
|
|||
Block::Block(Block const& _s): |
|||
m_state(_s.m_state), |
|||
m_transactions(_s.m_transactions), |
|||
m_receipts(_s.m_receipts), |
|||
m_transactionSet(_s.m_transactionSet), |
|||
m_previousBlock(_s.m_previousBlock), |
|||
m_currentBlock(_s.m_currentBlock), |
|||
m_beneficiary(_s.m_beneficiary), |
|||
m_blockReward(_s.m_blockReward) |
|||
{ |
|||
m_precommit = m_state; |
|||
m_committedToMine = false; |
|||
} |
|||
|
|||
Block& Block::operator=(Block const& _s) |
|||
{ |
|||
m_state = _s.m_state; |
|||
m_transactions = _s.m_transactions; |
|||
m_receipts = _s.m_receipts; |
|||
m_transactionSet = _s.m_transactionSet; |
|||
m_previousBlock = _s.m_previousBlock; |
|||
m_currentBlock = _s.m_currentBlock; |
|||
m_beneficiary = _s.m_beneficiary; |
|||
m_blockReward = _s.m_blockReward; |
|||
|
|||
m_precommit = m_state; |
|||
m_committedToMine = false; |
|||
return *this; |
|||
} |
|||
|
|||
void Block::resetCurrent() |
|||
{ |
|||
m_transactions.clear(); |
|||
m_receipts.clear(); |
|||
m_transactionSet.clear(); |
|||
m_currentBlock = BlockInfo(); |
|||
m_currentBlock.setCoinbaseAddress(m_beneficiary); |
|||
m_currentBlock.setTimestamp(max(m_previousBlock.timestamp() + 1, (u256)time(0))); |
|||
m_currentBlock.populateFromParent(m_previousBlock); |
|||
|
|||
// TODO: check.
|
|||
|
|||
m_state.setRoot(m_previousBlock.stateRoot()); |
|||
m_precommit = m_state; |
|||
m_committedToMine = false; |
|||
} |
|||
|
|||
PopulationStatistics Block::populateFromChain(BlockChain const& _bc, h256 const& _h, ImportRequirements::value _ir) |
|||
{ |
|||
PopulationStatistics ret { 0.0, 0.0 }; |
|||
|
|||
if (!_bc.isKnown(_h)) |
|||
{ |
|||
// Might be worth throwing here.
|
|||
cwarn << "Invalid block given for state population: " << _h; |
|||
BOOST_THROW_EXCEPTION(BlockNotFound() << errinfo_target(_h)); |
|||
} |
|||
|
|||
auto b = _bc.block(_h); |
|||
BlockInfo bi(b); |
|||
if (bi.number()) |
|||
{ |
|||
// Non-genesis:
|
|||
|
|||
// 1. Start at parent's end state (state root).
|
|||
BlockInfo bip(_bc.block(bi.parentHash())); |
|||
sync(_bc, bi.parentHash(), bip); |
|||
|
|||
// 2. Enact the block's transactions onto this state.
|
|||
m_beneficiary = bi.beneficiary(); |
|||
Timer t; |
|||
auto vb = _bc.verifyBlock(&b, function<void(Exception&)>(), _ir); |
|||
ret.verify = t.elapsed(); |
|||
t.restart(); |
|||
enact(vb, _bc); |
|||
ret.enact = t.elapsed(); |
|||
} |
|||
else |
|||
{ |
|||
// Genesis required:
|
|||
// We know there are no transactions, so just populate directly.
|
|||
m_state = State(m_state.db(), BaseState::Empty); // TODO: try with PreExisting.
|
|||
sync(_bc, _h, bi); |
|||
} |
|||
|
|||
return ret; |
|||
} |
|||
|
|||
bool Block::sync(BlockChain const& _bc) |
|||
{ |
|||
return sync(_bc, _bc.currentHash()); |
|||
} |
|||
|
|||
bool Block::sync(BlockChain const& _bc, h256 const& _block, BlockInfo const& _bi) |
|||
{ |
|||
bool ret = false; |
|||
// BLOCK
|
|||
BlockInfo bi = _bi ? _bi : _bc.info(_block); |
|||
#if ETH_PARANOIA |
|||
if (!bi) |
|||
while (1) |
|||
{ |
|||
try |
|||
{ |
|||
auto b = _bc.block(_block); |
|||
bi.populate(b); |
|||
break; |
|||
} |
|||
catch (Exception const& _e) |
|||
{ |
|||
// TODO: Slightly nicer handling? :-)
|
|||
cerr << "ERROR: Corrupt block-chain! Delete your block-chain DB and restart." << endl; |
|||
cerr << diagnostic_information(_e) << endl; |
|||
} |
|||
catch (std::exception const& _e) |
|||
{ |
|||
// TODO: Slightly nicer handling? :-)
|
|||
cerr << "ERROR: Corrupt block-chain! Delete your block-chain DB and restart." << endl; |
|||
cerr << _e.what() << endl; |
|||
} |
|||
} |
|||
#endif |
|||
if (bi == m_currentBlock) |
|||
{ |
|||
// We mined the last block.
|
|||
// Our state is good - we just need to move on to next.
|
|||
m_previousBlock = m_currentBlock; |
|||
resetCurrent(); |
|||
ret = true; |
|||
} |
|||
else if (bi == m_previousBlock) |
|||
{ |
|||
// No change since last sync.
|
|||
// Carry on as we were.
|
|||
} |
|||
else |
|||
{ |
|||
// New blocks available, or we've switched to a different branch. All change.
|
|||
// Find most recent state dump and replay what's left.
|
|||
// (Most recent state dump might end up being genesis.)
|
|||
|
|||
if (m_state.db().lookup(bi.stateRoot()).empty()) // TODO: API in State for this?
|
|||
{ |
|||
cwarn << "Unable to sync to" << bi.hash() << "; state root" << bi.stateRoot() << "not found in database."; |
|||
cwarn << "Database corrupt: contains block without stateRoot:" << bi; |
|||
cwarn << "Try rescuing the database by running: eth --rescue"; |
|||
BOOST_THROW_EXCEPTION(InvalidStateRoot() << errinfo_target(bi.stateRoot())); |
|||
} |
|||
m_previousBlock = bi; |
|||
resetCurrent(); |
|||
ret = true; |
|||
} |
|||
#if ALLOW_REBUILD |
|||
else |
|||
{ |
|||
// New blocks available, or we've switched to a different branch. All change.
|
|||
// Find most recent state dump and replay what's left.
|
|||
// (Most recent state dump might end up being genesis.)
|
|||
|
|||
std::vector<h256> chain; |
|||
while (bi.number() != 0 && m_db.lookup(bi.stateRoot()).empty()) // while we don't have the state root of the latest block...
|
|||
{ |
|||
chain.push_back(bi.hash()); // push back for later replay.
|
|||
bi.populate(_bc.block(bi.parentHash())); // move to parent.
|
|||
} |
|||
|
|||
m_previousBlock = bi; |
|||
resetCurrent(); |
|||
|
|||
// Iterate through in reverse, playing back each of the blocks.
|
|||
try |
|||
{ |
|||
for (auto it = chain.rbegin(); it != chain.rend(); ++it) |
|||
{ |
|||
auto b = _bc.block(*it); |
|||
enact(&b, _bc, _ir); |
|||
cleanup(true); |
|||
} |
|||
} |
|||
catch (...) |
|||
{ |
|||
// TODO: Slightly nicer handling? :-)
|
|||
cerr << "ERROR: Corrupt block-chain! Delete your block-chain DB and restart." << endl; |
|||
cerr << boost::current_exception_diagnostic_information() << endl; |
|||
exit(1); |
|||
} |
|||
|
|||
resetCurrent(); |
|||
ret = true; |
|||
} |
|||
#endif |
|||
return ret; |
|||
} |
|||
|
|||
pair<TransactionReceipts, bool> Block::sync(BlockChain const& _bc, TransactionQueue& _tq, GasPricer const& _gp, unsigned msTimeout) |
|||
{ |
|||
// TRANSACTIONS
|
|||
pair<TransactionReceipts, bool> ret; |
|||
ret.second = false; |
|||
|
|||
auto ts = _tq.topTransactions(c_maxSyncTransactions); |
|||
|
|||
LastHashes lh; |
|||
|
|||
auto deadline = chrono::steady_clock::now() + chrono::milliseconds(msTimeout); |
|||
|
|||
for (int goodTxs = 1; goodTxs; ) |
|||
{ |
|||
goodTxs = 0; |
|||
for (auto const& t: ts) |
|||
if (!m_transactionSet.count(t.sha3())) |
|||
{ |
|||
try |
|||
{ |
|||
if (t.gasPrice() >= _gp.ask(*this)) |
|||
{ |
|||
// Timer t;
|
|||
if (lh.empty()) |
|||
lh = _bc.lastHashes(); |
|||
execute(lh, t); |
|||
ret.first.push_back(m_receipts.back()); |
|||
++goodTxs; |
|||
// cnote << "TX took:" << t.elapsed() * 1000;
|
|||
} |
|||
else if (t.gasPrice() < _gp.ask(*this) * 9 / 10) |
|||
{ |
|||
clog(StateTrace) << t.sha3() << "Dropping El Cheapo transaction (<90% of ask price)"; |
|||
_tq.drop(t.sha3()); |
|||
} |
|||
} |
|||
catch (InvalidNonce const& in) |
|||
{ |
|||
bigint const& req = *boost::get_error_info<errinfo_required>(in); |
|||
bigint const& got = *boost::get_error_info<errinfo_got>(in); |
|||
|
|||
if (req > got) |
|||
{ |
|||
// too old
|
|||
clog(StateTrace) << t.sha3() << "Dropping old transaction (nonce too low)"; |
|||
_tq.drop(t.sha3()); |
|||
} |
|||
else if (got > req + _tq.waiting(t.sender())) |
|||
{ |
|||
// too new
|
|||
clog(StateTrace) << t.sha3() << "Dropping new transaction (too many nonces ahead)"; |
|||
_tq.drop(t.sha3()); |
|||
} |
|||
else |
|||
_tq.setFuture(t.sha3()); |
|||
} |
|||
catch (BlockGasLimitReached const& e) |
|||
{ |
|||
bigint const& got = *boost::get_error_info<errinfo_got>(e); |
|||
if (got > m_currentBlock.gasLimit()) |
|||
{ |
|||
clog(StateTrace) << t.sha3() << "Dropping over-gassy transaction (gas > block's gas limit)"; |
|||
_tq.drop(t.sha3()); |
|||
} |
|||
else |
|||
{ |
|||
// Temporarily no gas left in current block.
|
|||
// OPTIMISE: could note this and then we don't evaluate until a block that does have the gas left.
|
|||
// for now, just leave alone.
|
|||
} |
|||
} |
|||
catch (Exception const& _e) |
|||
{ |
|||
// Something else went wrong - drop it.
|
|||
clog(StateTrace) << t.sha3() << "Dropping invalid transaction:" << diagnostic_information(_e); |
|||
_tq.drop(t.sha3()); |
|||
} |
|||
catch (std::exception const&) |
|||
{ |
|||
// Something else went wrong - drop it.
|
|||
_tq.drop(t.sha3()); |
|||
cwarn << t.sha3() << "Transaction caused low-level exception :("; |
|||
} |
|||
} |
|||
if (chrono::steady_clock::now() > deadline) |
|||
{ |
|||
ret.second = true; |
|||
break; |
|||
} |
|||
} |
|||
return ret; |
|||
} |
|||
|
|||
u256 Block::enactOn(VerifiedBlockRef const& _block, BlockChain const& _bc) |
|||
{ |
|||
#if ETH_TIMED_ENACTMENTS |
|||
Timer t; |
|||
double populateVerify; |
|||
double populateGrand; |
|||
double syncReset; |
|||
double enactment; |
|||
#endif |
|||
|
|||
// Check family:
|
|||
BlockInfo biParent = _bc.info(_block.info.parentHash()); |
|||
_block.info.verifyParent(biParent); |
|||
|
|||
#if ETH_TIMED_ENACTMENTS |
|||
populateVerify = t.elapsed(); |
|||
t.restart(); |
|||
#endif |
|||
|
|||
BlockInfo biGrandParent; |
|||
if (biParent.number()) |
|||
biGrandParent = _bc.info(biParent.parentHash()); |
|||
|
|||
#if ETH_TIMED_ENACTMENTS |
|||
populateGrand = t.elapsed(); |
|||
t.restart(); |
|||
#endif |
|||
|
|||
sync(_bc, _block.info.parentHash(), BlockInfo()); |
|||
resetCurrent(); |
|||
|
|||
#if ETH_TIMED_ENACTMENTS |
|||
syncReset = t.elapsed(); |
|||
t.restart(); |
|||
#endif |
|||
|
|||
m_previousBlock = biParent; |
|||
auto ret = enact(_block, _bc); |
|||
|
|||
#if ETH_TIMED_ENACTMENTS |
|||
enactment = t.elapsed(); |
|||
if (populateVerify + populateGrand + syncReset + enactment > 0.5) |
|||
clog(StateChat) << "popVer/popGrand/syncReset/enactment = " << populateVerify << "/" << populateGrand << "/" << syncReset << "/" << enactment; |
|||
#endif |
|||
return ret; |
|||
} |
|||
|
|||
u256 Block::enact(VerifiedBlockRef const& _block, BlockChain const& _bc) |
|||
{ |
|||
DEV_TIMED_FUNCTION_ABOVE(500); |
|||
|
|||
// m_currentBlock is assumed to be prepopulated and reset.
|
|||
#if !ETH_RELEASE |
|||
assert(m_previousBlock.hash() == _block.info.parentHash()); |
|||
assert(m_currentBlock.parentHash() == _block.info.parentHash()); |
|||
assert(rootHash() == m_previousBlock.stateRoot()); |
|||
#endif |
|||
|
|||
if (m_currentBlock.parentHash() != m_previousBlock.hash()) |
|||
// Internal client error.
|
|||
BOOST_THROW_EXCEPTION(InvalidParentHash()); |
|||
|
|||
// Populate m_currentBlock with the correct values.
|
|||
m_currentBlock.noteDirty(); |
|||
m_currentBlock = _block.info; |
|||
|
|||
// cnote << "playback begins:" << m_state.root();
|
|||
// cnote << m_state;
|
|||
|
|||
LastHashes lh; |
|||
DEV_TIMED_ABOVE("lastHashes", 500) |
|||
lh = _bc.lastHashes((unsigned)m_previousBlock.number()); |
|||
|
|||
RLP rlp(_block.block); |
|||
|
|||
vector<bytes> receipts; |
|||
|
|||
// All ok with the block generally. Play back the transactions now...
|
|||
unsigned i = 0; |
|||
DEV_TIMED_ABOVE("txExec", 500) |
|||
for (auto const& tr: _block.transactions) |
|||
{ |
|||
try |
|||
{ |
|||
LogOverride<ExecutiveWarnChannel> o(false); |
|||
execute(lh, tr); |
|||
} |
|||
catch (Exception& ex) |
|||
{ |
|||
ex << errinfo_transactionIndex(i); |
|||
throw; |
|||
} |
|||
|
|||
RLPStream receiptRLP; |
|||
m_receipts.back().streamRLP(receiptRLP); |
|||
receipts.push_back(receiptRLP.out()); |
|||
++i; |
|||
} |
|||
|
|||
h256 receiptsRoot; |
|||
DEV_TIMED_ABOVE(".receiptsRoot()", 500) |
|||
receiptsRoot = orderedTrieRoot(receipts); |
|||
|
|||
if (receiptsRoot != m_currentBlock.receiptsRoot()) |
|||
{ |
|||
InvalidReceiptsStateRoot ex; |
|||
ex << Hash256RequirementError(receiptsRoot, m_currentBlock.receiptsRoot()); |
|||
ex << errinfo_receipts(receipts); |
|||
ex << errinfo_vmtrace(vmTrace(_block.block, _bc, ImportRequirements::None)); |
|||
BOOST_THROW_EXCEPTION(ex); |
|||
} |
|||
|
|||
if (m_currentBlock.logBloom() != logBloom()) |
|||
{ |
|||
InvalidLogBloom ex; |
|||
ex << LogBloomRequirementError(logBloom(), m_currentBlock.logBloom()); |
|||
ex << errinfo_receipts(receipts); |
|||
BOOST_THROW_EXCEPTION(ex); |
|||
} |
|||
|
|||
// Initialise total difficulty calculation.
|
|||
u256 tdIncrease = m_currentBlock.difficulty(); |
|||
|
|||
// Check uncles & apply their rewards to state.
|
|||
if (rlp[2].itemCount() > 2) |
|||
{ |
|||
TooManyUncles ex; |
|||
ex << errinfo_max(2); |
|||
ex << errinfo_got(rlp[2].itemCount()); |
|||
BOOST_THROW_EXCEPTION(ex); |
|||
} |
|||
|
|||
vector<BlockInfo> rewarded; |
|||
h256Hash excluded; |
|||
DEV_TIMED_ABOVE("allKin", 500) |
|||
excluded = _bc.allKinFrom(m_currentBlock.parentHash(), 6); |
|||
excluded.insert(m_currentBlock.hash()); |
|||
|
|||
unsigned ii = 0; |
|||
DEV_TIMED_ABOVE("uncleCheck", 500) |
|||
for (auto const& i: rlp[2]) |
|||
{ |
|||
try |
|||
{ |
|||
auto h = sha3(i.data()); |
|||
if (excluded.count(h)) |
|||
{ |
|||
UncleInChain ex; |
|||
ex << errinfo_comment("Uncle in block already mentioned"); |
|||
ex << errinfo_unclesExcluded(excluded); |
|||
ex << errinfo_hash256(sha3(i.data())); |
|||
BOOST_THROW_EXCEPTION(ex); |
|||
} |
|||
excluded.insert(h); |
|||
|
|||
// IgnoreSeal since it's a VerifiedBlock.
|
|||
BlockInfo uncle(i.data(), IgnoreSeal, h, HeaderData); |
|||
|
|||
BlockInfo uncleParent; |
|||
if (!_bc.isKnown(uncle.parentHash())) |
|||
BOOST_THROW_EXCEPTION(UnknownParent()); |
|||
uncleParent = BlockInfo(_bc.block(uncle.parentHash())); |
|||
|
|||
if ((bigint)uncleParent.number() < (bigint)m_currentBlock.number() - 7) |
|||
{ |
|||
UncleTooOld ex; |
|||
ex << errinfo_uncleNumber(uncle.number()); |
|||
ex << errinfo_currentNumber(m_currentBlock.number()); |
|||
BOOST_THROW_EXCEPTION(ex); |
|||
} |
|||
else if (uncle.number() == m_currentBlock.number()) |
|||
{ |
|||
UncleIsBrother ex; |
|||
ex << errinfo_uncleNumber(uncle.number()); |
|||
ex << errinfo_currentNumber(m_currentBlock.number()); |
|||
BOOST_THROW_EXCEPTION(ex); |
|||
} |
|||
uncle.verifyParent(uncleParent); |
|||
|
|||
rewarded.push_back(uncle); |
|||
++ii; |
|||
} |
|||
catch (Exception& ex) |
|||
{ |
|||
ex << errinfo_uncleIndex(ii); |
|||
throw; |
|||
} |
|||
} |
|||
|
|||
DEV_TIMED_ABOVE("applyRewards", 500) |
|||
applyRewards(rewarded); |
|||
|
|||
// Commit all cached state changes to the state trie.
|
|||
DEV_TIMED_ABOVE("commit", 500) |
|||
m_state.commit(); |
|||
|
|||
// Hash the state trie and check against the state_root hash in m_currentBlock.
|
|||
if (m_currentBlock.stateRoot() != m_previousBlock.stateRoot() && m_currentBlock.stateRoot() != rootHash()) |
|||
{ |
|||
m_state.db().rollback(); // TODO: API in State for this?
|
|||
BOOST_THROW_EXCEPTION(InvalidStateRoot() << Hash256RequirementError(rootHash(), m_currentBlock.stateRoot())); |
|||
} |
|||
|
|||
if (m_currentBlock.gasUsed() != gasUsed()) |
|||
{ |
|||
// Rollback the trie.
|
|||
m_state.db().rollback(); // TODO: API in State for this?
|
|||
BOOST_THROW_EXCEPTION(InvalidGasUsed() << RequirementError(bigint(gasUsed()), bigint(m_currentBlock.gasUsed()))); |
|||
} |
|||
|
|||
return tdIncrease; |
|||
} |
|||
|
|||
ExecutionResult Block::execute(LastHashes const& _lh, Transaction const& _t, Permanence _p, OnOpFunc const& _onOp) |
|||
{ |
|||
// Uncommitting is a non-trivial operation - only do it once we've verified as much of the
|
|||
// transaction as possible.
|
|||
uncommitToMine(); |
|||
|
|||
std::pair<ExecutionResult, TransactionReceipt> resultReceipt = m_state.execute(EnvInfo(info(), _lh, gasUsed()), _t, _p, _onOp); |
|||
|
|||
if (_p == Permanence::Committed) |
|||
{ |
|||
// Add to the user-originated transactions that we've executed.
|
|||
m_transactions.push_back(_t); |
|||
m_receipts.push_back(resultReceipt.second); |
|||
m_transactionSet.insert(_t.sha3()); |
|||
} |
|||
|
|||
return resultReceipt.first; |
|||
} |
|||
|
|||
void Block::applyRewards(vector<BlockInfo> const& _uncleBlockHeaders) |
|||
{ |
|||
u256 r = m_blockReward; |
|||
for (auto const& i: _uncleBlockHeaders) |
|||
{ |
|||
m_state.addBalance(i.beneficiary(), m_blockReward * (8 + i.number() - m_currentBlock.number()) / 8); |
|||
r += m_blockReward / 32; |
|||
} |
|||
m_state.addBalance(m_currentBlock.beneficiary(), r); |
|||
} |
|||
|
|||
void Block::commitToSeal(BlockChain const& _bc, bytes const& _extraData) |
|||
{ |
|||
if (m_committedToMine) |
|||
uncommitToMine(); |
|||
else |
|||
m_precommit = m_state; |
|||
|
|||
vector<BlockInfo> uncleBlockHeaders; |
|||
|
|||
RLPStream unclesData; |
|||
unsigned unclesCount = 0; |
|||
if (m_previousBlock.number() != 0) |
|||
{ |
|||
// Find great-uncles (or second-cousins or whatever they are) - children of great-grandparents, great-great-grandparents... that were not already uncles in previous generations.
|
|||
clog(StateDetail) << "Checking " << m_previousBlock.hash() << ", parent=" << m_previousBlock.parentHash(); |
|||
h256Hash excluded = _bc.allKinFrom(m_currentBlock.parentHash(), 6); |
|||
auto p = m_previousBlock.parentHash(); |
|||
for (unsigned gen = 0; gen < 6 && p != _bc.genesisHash() && unclesCount < 2; ++gen, p = _bc.details(p).parent) |
|||
{ |
|||
auto us = _bc.details(p).children; |
|||
assert(us.size() >= 1); // must be at least 1 child of our grandparent - it's our own parent!
|
|||
for (auto const& u: us) |
|||
if (!excluded.count(u)) // ignore any uncles/mainline blocks that we know about.
|
|||
{ |
|||
uncleBlockHeaders.push_back(_bc.info(u)); |
|||
unclesData.appendRaw(_bc.headerData(u)); |
|||
++unclesCount; |
|||
if (unclesCount == 2) |
|||
break; |
|||
} |
|||
} |
|||
} |
|||
|
|||
BytesMap transactionsMap; |
|||
BytesMap receiptsMap; |
|||
|
|||
RLPStream txs; |
|||
txs.appendList(m_transactions.size()); |
|||
|
|||
for (unsigned i = 0; i < m_transactions.size(); ++i) |
|||
{ |
|||
RLPStream k; |
|||
k << i; |
|||
|
|||
RLPStream receiptrlp; |
|||
m_receipts[i].streamRLP(receiptrlp); |
|||
receiptsMap.insert(std::make_pair(k.out(), receiptrlp.out())); |
|||
|
|||
RLPStream txrlp; |
|||
m_transactions[i].streamRLP(txrlp); |
|||
transactionsMap.insert(std::make_pair(k.out(), txrlp.out())); |
|||
|
|||
txs.appendRaw(txrlp.out()); |
|||
} |
|||
|
|||
txs.swapOut(m_currentTxs); |
|||
|
|||
RLPStream(unclesCount).appendRaw(unclesData.out(), unclesCount).swapOut(m_currentUncles); |
|||
|
|||
// Apply rewards last of all.
|
|||
applyRewards(uncleBlockHeaders); |
|||
|
|||
// Commit any and all changes to the trie that are in the cache, then update the state root accordingly.
|
|||
m_state.commit(); |
|||
|
|||
clog(StateDetail) << "Post-reward stateRoot:" << m_state.rootHash(); |
|||
clog(StateDetail) << m_state; |
|||
clog(StateDetail) << *this; |
|||
|
|||
m_currentBlock.setLogBloom(logBloom()); |
|||
m_currentBlock.setGasUsed(gasUsed()); |
|||
m_currentBlock.setRoots(hash256(transactionsMap), hash256(receiptsMap), sha3(m_currentUncles), m_state.rootHash()); |
|||
|
|||
m_currentBlock.setParentHash(m_previousBlock.hash()); |
|||
m_currentBlock.setExtraData(_extraData); |
|||
if (m_currentBlock.extraData().size() > 32) |
|||
{ |
|||
auto ed = m_currentBlock.extraData(); |
|||
ed.resize(32); |
|||
m_currentBlock.setExtraData(ed); |
|||
} |
|||
|
|||
m_committedToMine = true; |
|||
} |
|||
|
|||
void Block::uncommitToMine() |
|||
{ |
|||
if (m_committedToMine) |
|||
{ |
|||
m_state = m_precommit; |
|||
m_committedToMine = false; |
|||
} |
|||
} |
|||
|
|||
bool Block::sealBlock(bytesConstRef _header) |
|||
{ |
|||
if (!m_committedToMine) |
|||
return false; |
|||
|
|||
clog(StateDetail) << "Sealing block!"; |
|||
// Got it!
|
|||
|
|||
// Compile block:
|
|||
RLPStream ret; |
|||
ret.appendList(3); |
|||
ret.appendRaw(_header); |
|||
ret.appendRaw(m_currentTxs); |
|||
ret.appendRaw(m_currentUncles); |
|||
ret.swapOut(m_currentBytes); |
|||
m_currentBlock = BlockInfo(_header, CheckNothing, h256(), HeaderData); |
|||
cnote << "Mined " << m_currentBlock.hash() << "(parent: " << m_currentBlock.parentHash() << ")"; |
|||
// TODO: move into Sealer
|
|||
StructuredLogger::minedNewBlock( |
|||
m_currentBlock.hash().abridged(), |
|||
"", // Can't give the nonce here.
|
|||
"", //TODO: chain head hash here ??
|
|||
m_currentBlock.parentHash().abridged() |
|||
); |
|||
|
|||
// Quickly reset the transactions.
|
|||
// TODO: Leave this in a better state than this limbo, or at least record that it's in limbo.
|
|||
m_transactions.clear(); |
|||
m_receipts.clear(); |
|||
m_transactionSet.clear(); |
|||
m_precommit = m_state; |
|||
|
|||
return true; |
|||
} |
|||
|
|||
State Block::fromPending(unsigned _i) const |
|||
{ |
|||
State ret = m_state; |
|||
_i = min<unsigned>(_i, m_transactions.size()); |
|||
if (!_i) |
|||
ret.setRoot(m_previousBlock.stateRoot()); |
|||
else |
|||
ret.setRoot(m_receipts[_i - 1].stateRoot()); |
|||
return ret; |
|||
} |
|||
|
|||
LogBloom Block::logBloom() const |
|||
{ |
|||
LogBloom ret; |
|||
for (TransactionReceipt const& i: m_receipts) |
|||
ret |= i.bloom(); |
|||
return ret; |
|||
} |
|||
|
|||
void Block::cleanup(bool _fullCommit) |
|||
{ |
|||
if (_fullCommit) |
|||
{ |
|||
// Commit the new trie to disk.
|
|||
if (isChannelVisible<StateTrace>()) // Avoid calling toHex if not needed
|
|||
clog(StateTrace) << "Committing to disk: stateRoot" << m_currentBlock.stateRoot() << "=" << rootHash() << "=" << toHex(asBytes(db().lookup(rootHash()))); |
|||
|
|||
try |
|||
{ |
|||
EnforceRefs er(db(), true); |
|||
rootHash(); |
|||
} |
|||
catch (BadRoot const&) |
|||
{ |
|||
clog(StateChat) << "Trie corrupt! :-("; |
|||
throw; |
|||
} |
|||
|
|||
m_state.db().commit(); // TODO: State API for this?
|
|||
|
|||
if (isChannelVisible<StateTrace>()) // Avoid calling toHex if not needed
|
|||
clog(StateTrace) << "Committed: stateRoot" << m_currentBlock.stateRoot() << "=" << rootHash() << "=" << toHex(asBytes(db().lookup(rootHash()))); |
|||
|
|||
m_previousBlock = m_currentBlock; |
|||
m_currentBlock.populateFromParent(m_previousBlock); |
|||
|
|||
clog(StateTrace) << "finalising enactment. current -> previous, hash is" << m_previousBlock.hash(); |
|||
} |
|||
else |
|||
m_state.db().rollback(); // TODO: State API for this?
|
|||
|
|||
resetCurrent(); |
|||
} |
|||
|
|||
string Block::vmTrace(bytesConstRef _block, BlockChain const& _bc, ImportRequirements::value _ir) |
|||
{ |
|||
RLP rlp(_block); |
|||
|
|||
cleanup(false); |
|||
BlockInfo bi(_block, (_ir & ImportRequirements::ValidSeal) ? CheckEverything : IgnoreSeal); |
|||
m_currentBlock = bi; |
|||
m_currentBlock.verifyInternals(_block); |
|||
m_currentBlock.noteDirty(); |
|||
|
|||
LastHashes lh = _bc.lastHashes((unsigned)m_previousBlock.number()); |
|||
|
|||
string ret; |
|||
unsigned i = 0; |
|||
for (auto const& tr: rlp[1]) |
|||
{ |
|||
StandardTrace st; |
|||
st.setShowMnemonics(); |
|||
execute(lh, Transaction(tr.data(), CheckTransaction::Everything), Permanence::Committed, st.onOp()); |
|||
ret += (ret.empty() ? "[" : ",") + st.json(); |
|||
++i; |
|||
} |
|||
return ret.empty() ? "[]" : (ret + "]"); |
|||
} |
|||
|
|||
std::ostream& dev::eth::operator<<(std::ostream& _out, Block const& _s) |
|||
{ |
|||
(void)_s; |
|||
return _out; |
|||
} |
|||
@ -0,0 +1,310 @@ |
|||
/*
|
|||
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.h
|
|||
* @author Gav Wood <i@gavwood.com> |
|||
* @date 2014 |
|||
*/ |
|||
|
|||
#pragma once |
|||
|
|||
#include <array> |
|||
#include <unordered_map> |
|||
#include <libdevcore/Common.h> |
|||
#include <libdevcore/RLP.h> |
|||
#include <libdevcore/TrieDB.h> |
|||
#include <libdevcrypto/OverlayDB.h> |
|||
#include <libethcore/Exceptions.h> |
|||
#include <libethcore/BlockInfo.h> |
|||
#include <libethcore/Miner.h> |
|||
#include <libevm/ExtVMFace.h> |
|||
#include "Account.h" |
|||
#include "Transaction.h" |
|||
#include "TransactionReceipt.h" |
|||
#include "AccountDiff.h" |
|||
#include "GasPricer.h" |
|||
#include "State.h" |
|||
|
|||
namespace dev |
|||
{ |
|||
|
|||
namespace test { class ImportTest; class StateLoader; } |
|||
|
|||
namespace eth |
|||
{ |
|||
|
|||
class BlockChain; |
|||
class State; |
|||
class TransactionQueue; |
|||
struct VerifiedBlockRef; |
|||
|
|||
struct BlockChat: public LogChannel { static const char* name(); static const int verbosity = 4; }; |
|||
struct BlockTrace: public LogChannel { static const char* name(); static const int verbosity = 5; }; |
|||
struct BlockDetail: public LogChannel { static const char* name(); static const int verbosity = 14; }; |
|||
struct BlockSafeExceptions: public LogChannel { static const char* name(); static const int verbosity = 21; }; |
|||
|
|||
struct PopulationStatistics |
|||
{ |
|||
double verify; |
|||
double enact; |
|||
}; |
|||
|
|||
/**
|
|||
* @brief Active model of a block within the block chain. |
|||
* Keeps track of all transactions, receipts and state for a particular block. Can apply all |
|||
* needed transforms of the state for rewards and contains logic for sealing the block. |
|||
*/ |
|||
class Block |
|||
{ |
|||
friend class ExtVM; |
|||
friend class dev::test::ImportTest; |
|||
friend class dev::test::StateLoader; |
|||
friend class Executive; |
|||
friend class BlockChain; |
|||
|
|||
public: |
|||
/// Default constructor; creates with a blank database prepopulated with the genesis block.
|
|||
Block(): m_state(OverlayDB(), BaseState::Empty) {} |
|||
|
|||
/// Basic state object from database.
|
|||
/// Use the default when you already have a database and you just want to make a Block object
|
|||
/// which uses it. If you have no preexisting database then set BaseState to something other
|
|||
/// than BaseState::PreExisting in order to prepopulate the Trie.
|
|||
/// You can also set the beneficiary address.
|
|||
explicit Block(OverlayDB const& _db, BaseState _bs = BaseState::PreExisting, Address _coinbaseAddress = Address()); |
|||
|
|||
/// Copy state object.
|
|||
Block(Block const& _s); |
|||
|
|||
/// Copy state object.
|
|||
Block& operator=(Block const& _s); |
|||
|
|||
/// Get the beneficiary address for any transactions we do and rewards we get.
|
|||
Address beneficiary() const { return m_beneficiary; } |
|||
|
|||
/// Set the beneficiary address for any transactions we do and rewards we get.
|
|||
/// This causes a complete reset of current block.
|
|||
void setBeneficiary(Address const& _id) { m_beneficiary = _id; resetCurrent(); } |
|||
|
|||
// Account-getters. All operate on the final state.
|
|||
|
|||
/// Get an account's balance.
|
|||
/// @returns 0 if the address has never been used.
|
|||
u256 balance(Address const& _address) const { return m_state.balance(_address); } |
|||
|
|||
/// Get the number of transactions a particular address has sent (used for the transaction nonce).
|
|||
/// @returns 0 if the address has never been used.
|
|||
u256 transactionsFrom(Address const& _address) const { return m_state.transactionsFrom(_address); } |
|||
|
|||
/// Check if the address is in use.
|
|||
bool addressInUse(Address const& _address) const { return m_state.addressInUse(_address); } |
|||
|
|||
/// Check if the address contains executable code.
|
|||
bool addressHasCode(Address const& _address) const { return m_state.addressHasCode(_address); } |
|||
|
|||
/// Get the root of the storage of an account.
|
|||
h256 storageRoot(Address const& _contract) const { return m_state.storageRoot(_contract); } |
|||
|
|||
/// Get the value of a storage position of an account.
|
|||
/// @returns 0 if no account exists at that address.
|
|||
u256 storage(Address const& _contract, u256 const& _memory) const { return m_state.storage(_contract, _memory); } |
|||
|
|||
/// Get the storage of an account.
|
|||
/// @note This is expensive. Don't use it unless you need to.
|
|||
/// @returns std::unordered_map<u256, u256> if no account exists at that address.
|
|||
std::unordered_map<u256, u256> storage(Address const& _contract) const { return m_state.storage(_contract); } |
|||
|
|||
/// Get the code of an account.
|
|||
/// @returns bytes() if no account exists at that address.
|
|||
bytes const& code(Address const& _contract) const { return m_state.code(_contract); } |
|||
|
|||
/// Get the code hash of an account.
|
|||
/// @returns EmptySHA3 if no account exists at that address or if there is no code associated with the address.
|
|||
h256 codeHash(Address const& _contract) const { return m_state.codeHash(_contract); } |
|||
|
|||
// General information from state
|
|||
|
|||
/// Get the backing state object.
|
|||
State const& state() const { return m_state; } |
|||
|
|||
/// Open a DB - useful for passing into the constructor & keeping for other states that are necessary.
|
|||
OverlayDB const& db() const { return m_state.db(); } |
|||
|
|||
/// The hash of the root of our state tree.
|
|||
h256 rootHash() const { return m_state.rootHash(); } |
|||
|
|||
/// @returns the set containing all addresses currently in use in Ethereum.
|
|||
/// @throws InterfaceNotSupported if compiled without ETH_FATDB.
|
|||
std::unordered_map<Address, u256> addresses() const { return m_state.addresses(); } |
|||
|
|||
// For altering accounts behind-the-scenes
|
|||
|
|||
/// Get a mutable State object which is backing this block.
|
|||
/// @warning Only use this is you know what you're doing. If you use it while constructing a
|
|||
/// normal sealable block, don't expect things to work right.
|
|||
State& mutableState() { return m_state; } |
|||
|
|||
// Information concerning ongoing transactions
|
|||
|
|||
/// Get the remaining gas limit in this block.
|
|||
u256 gasLimitRemaining() const { return m_currentBlock.gasLimit() - gasUsed(); } |
|||
|
|||
/// Get the list of pending transactions.
|
|||
Transactions const& pending() const { return m_transactions; } |
|||
|
|||
/// Get the list of hashes of pending transactions.
|
|||
h256Hash const& pendingHashes() const { return m_transactionSet; } |
|||
|
|||
/// Get the transaction receipt for the transaction of the given index.
|
|||
TransactionReceipt const& receipt(unsigned _i) const { return m_receipts[_i]; } |
|||
|
|||
/// Get the list of pending transactions.
|
|||
LogEntries const& log(unsigned _i) const { return m_receipts[_i].log(); } |
|||
|
|||
/// Get the bloom filter of all logs that happened in the block.
|
|||
LogBloom logBloom() const; |
|||
|
|||
/// Get the bloom filter of a particular transaction that happened in the block.
|
|||
LogBloom const& logBloom(unsigned _i) const { return m_receipts[_i].bloom(); } |
|||
|
|||
/// Get the State immediately after the given number of pending transactions have been applied.
|
|||
/// If (_i == 0) returns the initial state of the block.
|
|||
/// If (_i == pending().size()) returns the final state of the block, prior to rewards.
|
|||
State fromPending(unsigned _i) const; |
|||
|
|||
/// @returns the StateDiff caused by the pending transaction of index @a _i.
|
|||
StateDiff pendingDiff(unsigned _i) const { return fromPending(_i).diff(fromPending(_i + 1), true); } |
|||
|
|||
// State-change operations
|
|||
|
|||
/// Construct state object from arbitrary point in blockchain.
|
|||
PopulationStatistics populateFromChain(BlockChain const& _bc, h256 const& _hash, ImportRequirements::value _ir = ImportRequirements::None); |
|||
|
|||
/// Execute a given transaction.
|
|||
/// This will append @a _t to the transaction list and change the state accordingly.
|
|||
ExecutionResult execute(LastHashes const& _lh, Transaction const& _t, Permanence _p = Permanence::Committed, OnOpFunc const& _onOp = OnOpFunc()); |
|||
|
|||
/// Sync our transactions, killing those from the queue that we have and assimilating those that we don't.
|
|||
/// @returns a list of receipts one for each transaction placed from the queue into the state and bool, true iff there are more transactions to be processed.
|
|||
std::pair<TransactionReceipts, bool> sync(BlockChain const& _bc, TransactionQueue& _tq, GasPricer const& _gp, unsigned _msTimeout = 100); |
|||
|
|||
/// Sync our state with the block chain.
|
|||
/// This basically involves wiping ourselves if we've been superceded and rebuilding from the transaction queue.
|
|||
bool sync(BlockChain const& _bc); |
|||
|
|||
/// Sync with the block chain, but rather than synching to the latest block, instead sync to the given block.
|
|||
bool sync(BlockChain const& _bc, h256 const& _blockHash, BlockInfo const& _bi = BlockInfo()); |
|||
|
|||
/// Execute all transactions within a given block.
|
|||
/// @returns the additional total difficulty.
|
|||
u256 enactOn(VerifiedBlockRef const& _block, BlockChain const& _bc); |
|||
|
|||
/// Returns back to a pristine state after having done a playback.
|
|||
/// @arg _fullCommit if true flush everything out to disk. If false, this effectively only validates
|
|||
/// the block since all state changes are ultimately reversed.
|
|||
void cleanup(bool _fullCommit); |
|||
|
|||
/// Sets m_currentBlock to a clean state, (i.e. no change from m_previousBlock).
|
|||
void resetCurrent(); |
|||
|
|||
// Sealing
|
|||
|
|||
/// Prepares the current state for mining.
|
|||
/// Commits all transactions into the trie, compiles uncles and transactions list, applies all
|
|||
/// rewards and populates the current block header with the appropriate hashes.
|
|||
/// The only thing left to do after this is to actually mine().
|
|||
///
|
|||
/// This may be called multiple times and without issue.
|
|||
void commitToSeal(BlockChain const& _bc, bytes const& _extraData = {}); |
|||
|
|||
/// Pass in a solution to the proof-of-work.
|
|||
/// @returns true iff we were previously committed to mining.
|
|||
/// TODO: verify it prior to calling this.
|
|||
/** Commit to DB and build the final block if the previous call to mine()'s result is completion.
|
|||
* Typically looks like: |
|||
* @code |
|||
* while (notYetMined) |
|||
* { |
|||
* // lock
|
|||
* commitToSeal(_blockChain); // will call uncommitToMine if a repeat.
|
|||
* completeMine(); |
|||
* // unlock
|
|||
* @endcode |
|||
*/ |
|||
bool sealBlock(bytes const& _header) { return sealBlock(&_header); } |
|||
bool sealBlock(bytesConstRef _header); |
|||
|
|||
/// Get the complete current block, including valid nonce.
|
|||
/// Only valid after mine() returns true.
|
|||
bytes const& blockData() const { return m_currentBytes; } |
|||
|
|||
/// Get the header information on the present block.
|
|||
BlockInfo const& info() const { return m_currentBlock; } |
|||
|
|||
|
|||
private: |
|||
/// Undo the changes to the state for committing to mine.
|
|||
void uncommitToMine(); |
|||
|
|||
/// Retrieve all information about a given address into the cache.
|
|||
/// If _requireMemory is true, grab the full memory should it be a contract item.
|
|||
/// If _forceCreate is true, then insert a default item into the cache, in the case it doesn't
|
|||
/// exist in the DB.
|
|||
void ensureCached(Address const& _a, bool _requireCode, bool _forceCreate) const; |
|||
|
|||
/// Retrieve all information about a given address into a cache.
|
|||
void ensureCached(std::unordered_map<Address, Account>& _cache, Address const& _a, bool _requireCode, bool _forceCreate) const; |
|||
|
|||
/// Execute the given block, assuming it corresponds to m_currentBlock.
|
|||
/// Throws on failure.
|
|||
u256 enact(VerifiedBlockRef const& _block, BlockChain const& _bc); |
|||
|
|||
/// Finalise the block, applying the earned rewards.
|
|||
void applyRewards(std::vector<BlockInfo> const& _uncleBlockHeaders); |
|||
|
|||
/// @returns gas used by transactions thus far executed.
|
|||
u256 gasUsed() const { return m_receipts.size() ? m_receipts.back().gasUsed() : 0; } |
|||
|
|||
/// Provide a standard VM trace for debugging purposes.
|
|||
std::string vmTrace(bytesConstRef _block, BlockChain const& _bc, ImportRequirements::value _ir); |
|||
|
|||
State m_state; ///< Our state tree, as an OverlayDB DB.
|
|||
Transactions m_transactions; ///< The current list of transactions that we've included in the state.
|
|||
TransactionReceipts m_receipts; ///< The corresponding list of transaction receipts.
|
|||
h256Hash m_transactionSet; ///< The set of transaction hashes that we've included in the state.
|
|||
State m_precommit; ///< State at the point immediately prior to rewards.
|
|||
|
|||
BlockInfo m_previousBlock; ///< The previous block's information.
|
|||
BlockInfo m_currentBlock; ///< The current block's information.
|
|||
bytes m_currentBytes; ///< The current block.
|
|||
bool m_committedToMine = false; ///< Have we committed to mine on the present m_currentBlock?
|
|||
|
|||
bytes m_currentTxs; ///< The RLP-encoded block of transactions.
|
|||
bytes m_currentUncles; ///< The RLP-encoded block of uncles.
|
|||
|
|||
Address m_beneficiary; ///< Our address (i.e. the address to which fees go).
|
|||
|
|||
u256 m_blockReward; |
|||
|
|||
friend std::ostream& operator<<(std::ostream& _out, Block const& _s); |
|||
}; |
|||
|
|||
std::ostream& operator<<(std::ostream& _out, Block const& _s); |
|||
|
|||
|
|||
} |
|||
|
|||
} |
|||
@ -1,57 +0,0 @@ |
|||
/*
|
|||
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 StateLoader.cpp
|
|||
* @author Marek Kotewicz <marek@ethdev.com> |
|||
* @date 2015 |
|||
*/ |
|||
|
|||
#include "StateLoader.h" |
|||
|
|||
using namespace std; |
|||
using namespace dev; |
|||
using namespace dev::eth; |
|||
using namespace dev::test; |
|||
|
|||
StateLoader::StateLoader(Json::Value const& _json, std::string const& _dbPath): |
|||
m_state(State::openDB(_dbPath, h256{}, WithExisting::Kill), BaseState::Empty) |
|||
{ |
|||
for (string const& name: _json.getMemberNames()) |
|||
{ |
|||
Json::Value o = _json[name]; |
|||
|
|||
Address address = Address(name); |
|||
bytes code = fromHex(o["code"].asString().substr(2)); |
|||
|
|||
if (!code.empty()) |
|||
{ |
|||
m_state.m_cache[address] = Account(u256(o["balance"].asString()), Account::ContractConception); |
|||
m_state.m_cache[address].setCode(std::move(code)); |
|||
} |
|||
else |
|||
m_state.m_cache[address] = Account(u256(o["balance"].asString()), Account::NormalCreation); |
|||
|
|||
for (string const& j: o["storage"].getMemberNames()) |
|||
m_state.setStorage(address, u256(j), u256(o["storage"][j].asString())); |
|||
|
|||
for (auto i = 0; i < u256(o["nonce"].asString()); ++i) |
|||
m_state.noteSending(address); |
|||
|
|||
m_state.ensureCached(address, false, false); |
|||
} |
|||
|
|||
m_state.commit(); |
|||
} |
|||
@ -1,49 +0,0 @@ |
|||
/*
|
|||
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 StateLoader.h
|
|||
* @author Marek Kotewicz <marek@ethdev.com> |
|||
* @date 2015 |
|||
*/ |
|||
|
|||
#pragma once |
|||
|
|||
#include <json/json.h> |
|||
#include <libdevcore/TransientDirectory.h> |
|||
#include <libethereum/State.h> |
|||
#include <libethereum/BlockChain.h> |
|||
|
|||
namespace dev |
|||
{ |
|||
namespace test |
|||
{ |
|||
|
|||
/**
|
|||
* @brief Friend of State, loads State from given JSON object |
|||
*/ |
|||
class StateLoader |
|||
{ |
|||
public: |
|||
StateLoader(Json::Value const& _json, std::string const& _dbPath); |
|||
eth::State const& state() const { return m_state; } |
|||
eth::StateDefinition const& stateDefinition() const { return m_state.m_cache; } |
|||
|
|||
private: |
|||
eth::State m_state; |
|||
}; |
|||
|
|||
} |
|||
} |
|||
Loading…
Reference in new issue