subtly
10 years ago
93 changed files with 3179 additions and 2580 deletions
@ -0,0 +1,812 @@ |
|||||
|
/*
|
||||
|
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 <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 <libethcore/Params.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 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 | ImportRequirements::TransactionBasic); |
||||
|
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()) |
||||
|
{ |
||||
|
auto r = rootHash(); |
||||
|
m_state.db().rollback(); // TODO: API in State for this?
|
||||
|
BOOST_THROW_EXCEPTION(InvalidStateRoot() << Hash256RequirementError(r, 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; |
||||
|
|
||||
|
if (BlockInfo(_header, CheckNothing, h256{}, HeaderData).hashWithout() != m_currentBlock.hashWithout()) |
||||
|
return false; |
||||
|
|
||||
|
clog(StateDetail) << "Sealing block!"; |
||||
|
|
||||
|
// 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; |
|
||||
}; |
|
||||
|
|
||||
} |
|
||||
} |
|
||||
@ -0,0 +1,497 @@ |
|||||
|
/*
|
||||
|
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/>.
|
||||
|
*/ |
||||
|
/**
|
||||
|
* @author Christian <c@ethdev.com> |
||||
|
* @date 2015 |
||||
|
* Tests for a fixed fee registrar contract. |
||||
|
*/ |
||||
|
|
||||
|
#include <string> |
||||
|
#include <tuple> |
||||
|
#include <boost/test/unit_test.hpp> |
||||
|
#include <libdevcore/Hash.h> |
||||
|
#include <libethcore/ABI.h> |
||||
|
#include <test/libsolidity/solidityExecutionFramework.h> |
||||
|
|
||||
|
using namespace std; |
||||
|
|
||||
|
namespace dev |
||||
|
{ |
||||
|
namespace solidity |
||||
|
{ |
||||
|
namespace test |
||||
|
{ |
||||
|
|
||||
|
namespace |
||||
|
{ |
||||
|
|
||||
|
static char const* registrarCode = R"DELIMITER( |
||||
|
//sol
|
||||
|
|
||||
|
contract NameRegister { |
||||
|
function addr(string _name) constant returns (address o_owner); |
||||
|
function name(address _owner) constant returns (string o_name); |
||||
|
} |
||||
|
|
||||
|
contract Registrar is NameRegister { |
||||
|
event Changed(string indexed name); |
||||
|
event PrimaryChanged(string indexed name, address indexed addr); |
||||
|
|
||||
|
function owner(string _name) constant returns (address o_owner); |
||||
|
function addr(string _name) constant returns (address o_address); |
||||
|
function subRegistrar(string _name) constant returns (address o_subRegistrar); |
||||
|
function content(string _name) constant returns (bytes32 o_content); |
||||
|
|
||||
|
function name(address _owner) constant returns (string o_name); |
||||
|
} |
||||
|
|
||||
|
contract AuctionSystem { |
||||
|
event AuctionEnded(string indexed _name, address _winner); |
||||
|
event NewBid(string indexed _name, address _bidder, uint _value); |
||||
|
|
||||
|
/// Function that is called once an auction ends.
|
||||
|
function onAuctionEnd(string _name) internal; |
||||
|
|
||||
|
function bid(string _name, address _bidder, uint _value) internal { |
||||
|
var auction = m_auctions[_name]; |
||||
|
if (auction.endDate > 0 && now > auction.endDate) |
||||
|
{ |
||||
|
AuctionEnded(_name, auction.highestBidder); |
||||
|
onAuctionEnd(_name); |
||||
|
delete m_auctions[_name]; |
||||
|
return; |
||||
|
} |
||||
|
if (msg.value > auction.highestBid) |
||||
|
{ |
||||
|
// new bid on auction
|
||||
|
auction.secondHighestBid = auction.highestBid; |
||||
|
auction.sumOfBids += _value; |
||||
|
auction.highestBid = _value; |
||||
|
auction.highestBidder = _bidder; |
||||
|
auction.endDate = now + c_biddingTime; |
||||
|
|
||||
|
NewBid(_name, _bidder, _value); |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
uint constant c_biddingTime = 7 days; |
||||
|
|
||||
|
struct Auction { |
||||
|
address highestBidder; |
||||
|
uint highestBid; |
||||
|
uint secondHighestBid; |
||||
|
uint sumOfBids; |
||||
|
uint endDate; |
||||
|
} |
||||
|
mapping(string => Auction) m_auctions; |
||||
|
} |
||||
|
|
||||
|
contract GlobalRegistrar is Registrar, AuctionSystem { |
||||
|
struct Record { |
||||
|
address owner; |
||||
|
address primary; |
||||
|
address subRegistrar; |
||||
|
bytes32 content; |
||||
|
uint renewalDate; |
||||
|
} |
||||
|
|
||||
|
uint constant c_renewalInterval = 1 years; |
||||
|
uint constant c_freeBytes = 12; |
||||
|
|
||||
|
function Registrar() { |
||||
|
// TODO: Populate with hall-of-fame.
|
||||
|
} |
||||
|
|
||||
|
function() { |
||||
|
// prevent people from just sending funds to the registrar
|
||||
|
__throw(); |
||||
|
} |
||||
|
|
||||
|
function onAuctionEnd(string _name) internal { |
||||
|
var auction = m_auctions[_name]; |
||||
|
var record = m_toRecord[_name]; |
||||
|
if (record.owner != 0) |
||||
|
record.owner.send(auction.sumOfBids - auction.highestBid / 100); |
||||
|
else |
||||
|
auction.highestBidder.send(auction.highestBid - auction.secondHighestBid); |
||||
|
record.renewalDate = now + c_renewalInterval; |
||||
|
record.owner = auction.highestBidder; |
||||
|
Changed(_name); |
||||
|
} |
||||
|
|
||||
|
function reserve(string _name) external { |
||||
|
if (bytes(_name).length == 0) |
||||
|
__throw(); |
||||
|
bool needAuction = requiresAuction(_name); |
||||
|
if (needAuction) |
||||
|
{ |
||||
|
if (now < m_toRecord[_name].renewalDate) |
||||
|
__throw(); |
||||
|
bid(_name, msg.sender, msg.value); |
||||
|
} |
||||
|
else |
||||
|
{ |
||||
|
Record record = m_toRecord[_name]; |
||||
|
if (record.owner != 0) |
||||
|
__throw(); |
||||
|
m_toRecord[_name].owner = msg.sender; |
||||
|
Changed(_name); |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
function requiresAuction(string _name) internal returns (bool) { |
||||
|
return bytes(_name).length < c_freeBytes; |
||||
|
} |
||||
|
|
||||
|
modifier onlyrecordowner(string _name) { if (m_toRecord[_name].owner == msg.sender) _ } |
||||
|
|
||||
|
function transfer(string _name, address _newOwner) onlyrecordowner(_name) { |
||||
|
m_toRecord[_name].owner = _newOwner; |
||||
|
Changed(_name); |
||||
|
} |
||||
|
|
||||
|
function disown(string _name) onlyrecordowner(_name) { |
||||
|
if (stringsEqual(m_toName[m_toRecord[_name].primary], _name)) |
||||
|
{ |
||||
|
PrimaryChanged(_name, m_toRecord[_name].primary); |
||||
|
m_toName[m_toRecord[_name].primary] = ""; |
||||
|
} |
||||
|
delete m_toRecord[_name]; |
||||
|
Changed(_name); |
||||
|
} |
||||
|
|
||||
|
function setAddress(string _name, address _a, bool _primary) onlyrecordowner(_name) { |
||||
|
m_toRecord[_name].primary = _a; |
||||
|
if (_primary) |
||||
|
{ |
||||
|
PrimaryChanged(_name, _a); |
||||
|
m_toName[_a] = _name; |
||||
|
} |
||||
|
Changed(_name); |
||||
|
} |
||||
|
function setSubRegistrar(string _name, address _registrar) onlyrecordowner(_name) { |
||||
|
m_toRecord[_name].subRegistrar = _registrar; |
||||
|
Changed(_name); |
||||
|
} |
||||
|
function setContent(string _name, bytes32 _content) onlyrecordowner(_name) { |
||||
|
m_toRecord[_name].content = _content; |
||||
|
Changed(_name); |
||||
|
} |
||||
|
|
||||
|
function stringsEqual(string storage _a, string memory _b) internal returns (bool) { |
||||
|
bytes storage a = bytes(_a); |
||||
|
bytes memory b = bytes(_b); |
||||
|
if (a.length != b.length) |
||||
|
return false; |
||||
|
// @todo unroll this loop
|
||||
|
for (uint i = 0; i < a.length; i ++) |
||||
|
if (a[i] != b[i]) |
||||
|
return false; |
||||
|
return true; |
||||
|
} |
||||
|
|
||||
|
function owner(string _name) constant returns (address) { return m_toRecord[_name].owner; } |
||||
|
function addr(string _name) constant returns (address) { return m_toRecord[_name].primary; } |
||||
|
function subRegistrar(string _name) constant returns (address) { return m_toRecord[_name].subRegistrar; } |
||||
|
function content(string _name) constant returns (bytes32) { return m_toRecord[_name].content; } |
||||
|
function name(address _addr) constant returns (string o_name) { return m_toName[_addr]; } |
||||
|
|
||||
|
function __throw() internal { |
||||
|
// workaround until we have "throw"
|
||||
|
uint[] x; x[1]; |
||||
|
} |
||||
|
|
||||
|
mapping (address => string) m_toName; |
||||
|
mapping (string => Record) m_toRecord; |
||||
|
} |
||||
|
)DELIMITER"; |
||||
|
|
||||
|
static unique_ptr<bytes> s_compiledRegistrar; |
||||
|
|
||||
|
class AuctionRegistrarTestFramework: public ExecutionFramework |
||||
|
{ |
||||
|
protected: |
||||
|
void deployRegistrar() |
||||
|
{ |
||||
|
if (!s_compiledRegistrar) |
||||
|
{ |
||||
|
m_optimize = true; |
||||
|
m_compiler.reset(false, m_addStandardSources); |
||||
|
m_compiler.addSource("", registrarCode); |
||||
|
ETH_TEST_REQUIRE_NO_THROW(m_compiler.compile(m_optimize, m_optimizeRuns), "Compiling contract failed"); |
||||
|
s_compiledRegistrar.reset(new bytes(m_compiler.getBytecode("GlobalRegistrar"))); |
||||
|
} |
||||
|
sendMessage(*s_compiledRegistrar, true); |
||||
|
BOOST_REQUIRE(!m_output.empty()); |
||||
|
} |
||||
|
|
||||
|
using ContractInterface = ExecutionFramework::ContractInterface; |
||||
|
class RegistrarInterface: public ContractInterface |
||||
|
{ |
||||
|
public: |
||||
|
RegistrarInterface(ExecutionFramework& _framework): ContractInterface(_framework) {} |
||||
|
void reserve(string const& _name) |
||||
|
{ |
||||
|
callString("reserve", _name); |
||||
|
} |
||||
|
u160 owner(string const& _name) |
||||
|
{ |
||||
|
return callStringReturnsAddress("owner", _name); |
||||
|
} |
||||
|
void setAddress(string const& _name, u160 const& _address, bool _primary) |
||||
|
{ |
||||
|
callStringAddressBool("setAddress", _name, _address, _primary); |
||||
|
} |
||||
|
u160 addr(string const& _name) |
||||
|
{ |
||||
|
return callStringReturnsAddress("addr", _name); |
||||
|
} |
||||
|
string name(u160 const& _addr) |
||||
|
{ |
||||
|
return callAddressReturnsString("name", _addr); |
||||
|
} |
||||
|
void setSubRegistrar(string const& _name, u160 const& _address) |
||||
|
{ |
||||
|
callStringAddress("setSubRegistrar", _name, _address); |
||||
|
} |
||||
|
u160 subRegistrar(string const& _name) |
||||
|
{ |
||||
|
return callStringReturnsAddress("subRegistrar", _name); |
||||
|
} |
||||
|
void setContent(string const& _name, h256 const& _content) |
||||
|
{ |
||||
|
callStringBytes32("setContent", _name, _content); |
||||
|
} |
||||
|
h256 content(string const& _name) |
||||
|
{ |
||||
|
return callStringReturnsBytes32("content", _name); |
||||
|
} |
||||
|
void transfer(string const& _name, u160 const& _target) |
||||
|
{ |
||||
|
return callStringAddress("transfer", _name, _target); |
||||
|
} |
||||
|
void disown(string const& _name) |
||||
|
{ |
||||
|
return callString("disown", _name); |
||||
|
} |
||||
|
}; |
||||
|
|
||||
|
u256 const m_biddingTime = u256(7 * 24 * 3600); |
||||
|
u256 const m_renewalInterval = u256(365 * 24 * 3600); |
||||
|
}; |
||||
|
|
||||
|
} |
||||
|
|
||||
|
/// This is a test suite that tests optimised code!
|
||||
|
BOOST_FIXTURE_TEST_SUITE(SolidityAuctionRegistrar, AuctionRegistrarTestFramework) |
||||
|
|
||||
|
BOOST_AUTO_TEST_CASE(creation) |
||||
|
{ |
||||
|
deployRegistrar(); |
||||
|
} |
||||
|
|
||||
|
BOOST_AUTO_TEST_CASE(reserve) |
||||
|
{ |
||||
|
// Test that reserving works for long strings
|
||||
|
deployRegistrar(); |
||||
|
vector<string> names{"abcabcabcabcabc", "defdefdefdefdef", "ghighighighighighighighighighighighighighighi"}; |
||||
|
m_sender = Address(0x123); |
||||
|
|
||||
|
RegistrarInterface registrar(*this); |
||||
|
|
||||
|
// should not work
|
||||
|
registrar.reserve(""); |
||||
|
BOOST_CHECK_EQUAL(registrar.owner(""), u160(0)); |
||||
|
|
||||
|
for (auto const& name: names) |
||||
|
{ |
||||
|
registrar.reserve(name); |
||||
|
BOOST_CHECK_EQUAL(registrar.owner(name), u160(0x123)); |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
BOOST_AUTO_TEST_CASE(double_reserve_long) |
||||
|
{ |
||||
|
// Test that it is not possible to re-reserve from a different address.
|
||||
|
deployRegistrar(); |
||||
|
string name = "abcabcabcabcabcabcabcabcabcabca"; |
||||
|
m_sender = Address(0x123); |
||||
|
RegistrarInterface registrar(*this); |
||||
|
registrar.reserve(name); |
||||
|
BOOST_CHECK_EQUAL(registrar.owner(name), u160(0x123)); |
||||
|
|
||||
|
m_sender = Address(0x124); |
||||
|
registrar.reserve(name); |
||||
|
BOOST_CHECK_EQUAL(registrar.owner(name), u160(0x123)); |
||||
|
} |
||||
|
|
||||
|
BOOST_AUTO_TEST_CASE(properties) |
||||
|
{ |
||||
|
// Test setting and retrieving the various properties works.
|
||||
|
deployRegistrar(); |
||||
|
RegistrarInterface registrar(*this); |
||||
|
string names[] = {"abcaeouoeuaoeuaoeu", "defncboagufra,fui", "ghagpyajfbcuajouhaeoi"}; |
||||
|
size_t addr = 0x9872543; |
||||
|
for (string const& name: names) |
||||
|
{ |
||||
|
addr++; |
||||
|
size_t sender = addr + 10007; |
||||
|
m_sender = Address(sender); |
||||
|
// setting by sender works
|
||||
|
registrar.reserve(name); |
||||
|
BOOST_CHECK_EQUAL(registrar.owner(name), u160(sender)); |
||||
|
registrar.setAddress(name, addr, true); |
||||
|
BOOST_CHECK_EQUAL(registrar.addr(name), u160(addr)); |
||||
|
registrar.setSubRegistrar(name, addr + 20); |
||||
|
BOOST_CHECK_EQUAL(registrar.subRegistrar(name), u160(addr + 20)); |
||||
|
registrar.setContent(name, h256(u256(addr + 90))); |
||||
|
BOOST_CHECK_EQUAL(registrar.content(name), h256(u256(addr + 90))); |
||||
|
|
||||
|
// but not by someone else
|
||||
|
m_sender = Address(h256(addr + 10007 - 1)); |
||||
|
BOOST_CHECK_EQUAL(registrar.owner(name), u160(sender)); |
||||
|
registrar.setAddress(name, addr + 1, true); |
||||
|
BOOST_CHECK_EQUAL(registrar.addr(name), u160(addr)); |
||||
|
registrar.setSubRegistrar(name, addr + 20 + 1); |
||||
|
BOOST_CHECK_EQUAL(registrar.subRegistrar(name), u160(addr + 20)); |
||||
|
registrar.setContent(name, h256(u256(addr + 90 + 1))); |
||||
|
BOOST_CHECK_EQUAL(registrar.content(name), h256(u256(addr + 90))); |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
BOOST_AUTO_TEST_CASE(transfer) |
||||
|
{ |
||||
|
deployRegistrar(); |
||||
|
string name = "abcaoeguaoucaeoduceo"; |
||||
|
m_sender = Address(0x123); |
||||
|
RegistrarInterface registrar(*this); |
||||
|
registrar.reserve(name); |
||||
|
registrar.setContent(name, h256(u256(123))); |
||||
|
registrar.transfer(name, u160(555)); |
||||
|
BOOST_CHECK_EQUAL(registrar.owner(name), u160(555)); |
||||
|
BOOST_CHECK_EQUAL(registrar.content(name), h256(u256(123))); |
||||
|
} |
||||
|
|
||||
|
BOOST_AUTO_TEST_CASE(disown) |
||||
|
{ |
||||
|
deployRegistrar(); |
||||
|
string name = "abcaoeguaoucaeoduceo"; |
||||
|
m_sender = Address(0x123); |
||||
|
RegistrarInterface registrar(*this); |
||||
|
registrar.reserve(name); |
||||
|
registrar.setContent(name, h256(u256(123))); |
||||
|
registrar.setAddress(name, u160(124), true); |
||||
|
registrar.setSubRegistrar(name, u160(125)); |
||||
|
BOOST_CHECK_EQUAL(registrar.name(u160(124)), name); |
||||
|
|
||||
|
// someone else tries disowning
|
||||
|
m_sender = Address(0x128); |
||||
|
registrar.disown(name); |
||||
|
BOOST_CHECK_EQUAL(registrar.owner(name), 0x123); |
||||
|
|
||||
|
m_sender = Address(0x123); |
||||
|
registrar.disown(name); |
||||
|
BOOST_CHECK_EQUAL(registrar.owner(name), 0); |
||||
|
BOOST_CHECK_EQUAL(registrar.addr(name), 0); |
||||
|
BOOST_CHECK_EQUAL(registrar.subRegistrar(name), 0); |
||||
|
BOOST_CHECK_EQUAL(registrar.content(name), h256()); |
||||
|
BOOST_CHECK_EQUAL(registrar.name(u160(124)), ""); |
||||
|
} |
||||
|
|
||||
|
BOOST_AUTO_TEST_CASE(auction_simple) |
||||
|
{ |
||||
|
deployRegistrar(); |
||||
|
string name = "x"; |
||||
|
m_sender = Address(0x123); |
||||
|
RegistrarInterface registrar(*this); |
||||
|
// initiate auction
|
||||
|
registrar.setNextValue(8); |
||||
|
registrar.reserve(name); |
||||
|
BOOST_CHECK_EQUAL(registrar.owner(name), 0); |
||||
|
// "wait" until auction end
|
||||
|
m_envInfo.setTimestamp(m_envInfo.timestamp() + m_biddingTime + 10); |
||||
|
// trigger auction again
|
||||
|
registrar.reserve(name); |
||||
|
BOOST_CHECK_EQUAL(registrar.owner(name), 0x123); |
||||
|
} |
||||
|
|
||||
|
BOOST_AUTO_TEST_CASE(auction_bidding) |
||||
|
{ |
||||
|
deployRegistrar(); |
||||
|
string name = "x"; |
||||
|
m_sender = Address(0x123); |
||||
|
RegistrarInterface registrar(*this); |
||||
|
// initiate auction
|
||||
|
registrar.setNextValue(8); |
||||
|
registrar.reserve(name); |
||||
|
BOOST_CHECK_EQUAL(registrar.owner(name), 0); |
||||
|
// overbid self
|
||||
|
m_envInfo.setTimestamp(m_biddingTime - 10); |
||||
|
registrar.setNextValue(12); |
||||
|
registrar.reserve(name); |
||||
|
// another bid by someone else
|
||||
|
m_sender = Address(0x124); |
||||
|
m_envInfo.setTimestamp(2 * m_biddingTime - 50); |
||||
|
registrar.setNextValue(13); |
||||
|
registrar.reserve(name); |
||||
|
BOOST_CHECK_EQUAL(registrar.owner(name), 0); |
||||
|
// end auction by first bidder (which is not highest) trying to overbid again (too late)
|
||||
|
m_sender = Address(0x123); |
||||
|
m_envInfo.setTimestamp(4 * m_biddingTime); |
||||
|
registrar.setNextValue(20); |
||||
|
registrar.reserve(name); |
||||
|
BOOST_CHECK_EQUAL(registrar.owner(name), 0x124); |
||||
|
} |
||||
|
|
||||
|
BOOST_AUTO_TEST_CASE(auction_renewal) |
||||
|
{ |
||||
|
deployRegistrar(); |
||||
|
string name = "x"; |
||||
|
RegistrarInterface registrar(*this); |
||||
|
// register name by auction
|
||||
|
m_sender = Address(0x123); |
||||
|
registrar.setNextValue(8); |
||||
|
registrar.reserve(name); |
||||
|
m_envInfo.setTimestamp(4 * m_biddingTime); |
||||
|
registrar.reserve(name); |
||||
|
BOOST_CHECK_EQUAL(registrar.owner(name), 0x123); |
||||
|
|
||||
|
// try to re-register before interval end
|
||||
|
m_sender = Address(0x222); |
||||
|
registrar.setNextValue(80); |
||||
|
m_envInfo.setTimestamp(m_envInfo.timestamp() + m_renewalInterval - 1); |
||||
|
registrar.reserve(name); |
||||
|
m_envInfo.setTimestamp(m_envInfo.timestamp() + m_biddingTime); |
||||
|
// if there is a bug in the renewal logic, this would transfer the ownership to 0x222,
|
||||
|
// but if there is no bug, this will initiate the auction, albeit with a zero bid
|
||||
|
registrar.reserve(name); |
||||
|
BOOST_CHECK_EQUAL(registrar.owner(name), 0x123); |
||||
|
|
||||
|
m_envInfo.setTimestamp(m_envInfo.timestamp() + 2); |
||||
|
registrar.setNextValue(80); |
||||
|
registrar.reserve(name); |
||||
|
BOOST_CHECK_EQUAL(registrar.owner(name), 0x123); |
||||
|
m_envInfo.setTimestamp(m_envInfo.timestamp() + m_biddingTime + 2); |
||||
|
registrar.reserve(name); |
||||
|
BOOST_CHECK_EQUAL(registrar.owner(name), 0x222); |
||||
|
} |
||||
|
|
||||
|
BOOST_AUTO_TEST_SUITE_END() |
||||
|
|
||||
|
} |
||||
|
} |
||||
|
} // end namespaces
|
||||
@ -0,0 +1,169 @@ |
|||||
|
/*
|
||||
|
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 Transaction.cpp
|
||||
|
* @author Dmitrii Khokhlov <winsvega@mail.ru> |
||||
|
* @date 2015 |
||||
|
* Transaaction test functions. |
||||
|
*/ |
||||
|
|
||||
|
#include "test/TestHelper.h" |
||||
|
#include <libethcore/Exceptions.h> |
||||
|
#include <libevm/VMFace.h> |
||||
|
#include <libethcore/Common.h> |
||||
|
|
||||
|
using namespace dev; |
||||
|
using namespace eth; |
||||
|
|
||||
|
BOOST_AUTO_TEST_SUITE(libethereum) |
||||
|
|
||||
|
BOOST_AUTO_TEST_CASE(TransactionGasRequired) |
||||
|
{ |
||||
|
Transaction tr(fromHex("0xf86d800182521c94095e7baea6a6c7c4c2dfeb977efac326af552d870a8e0358ac39584bc98a7c979f984b031ba048b55bfa915ac795c431978d8a6a992b628d557da5ff759b307d495a36649353a0efffd310ac743f371de3b9f7f9cb56c0b28ad43601b4ab949f53faa07bd2c804"), CheckTransaction::None); |
||||
|
BOOST_CHECK_MESSAGE(tr.gasRequired() == 21952, "Transaction::GasRequired() has changed!"); |
||||
|
} |
||||
|
|
||||
|
BOOST_AUTO_TEST_CASE(TransactionConstructor) |
||||
|
{ |
||||
|
bool wasException = false; |
||||
|
try |
||||
|
{ |
||||
|
Transaction(fromHex("0xf86d800182521c94095e7baea6a6c7c4c2dfeb977efac326af552d870a8e0358ac39584bc98a7c979f984b031ba048b55bfa915ac795c431978d8a6a992b628d557da5ff759b307d495a36649353a0efffd310ac743f371de3b9f7f9cb56c0b28ad43601b4ab949f53faa07bd2c804"), CheckTransaction::Everything); |
||||
|
} |
||||
|
catch (OutOfGasIntrinsic) |
||||
|
{ |
||||
|
wasException = true; |
||||
|
} |
||||
|
catch (Exception) |
||||
|
{ |
||||
|
BOOST_ERROR("Exception thrown but expected OutOfGasIntrinsic instead"); |
||||
|
} |
||||
|
|
||||
|
BOOST_CHECK_MESSAGE(wasException, "Expected OutOfGasIntrinsic exception to be thrown at TransactionConstructor test"); |
||||
|
} |
||||
|
|
||||
|
BOOST_AUTO_TEST_CASE(ExecutionResultOutput) |
||||
|
{ |
||||
|
std::stringstream buffer; |
||||
|
ExecutionResult exRes; |
||||
|
|
||||
|
exRes.gasUsed = u256("12345"); |
||||
|
exRes.newAddress = Address("a94f5374fce5edbc8e2a8697c15331677e6ebf0b"); |
||||
|
exRes.output = fromHex("001122334455"); |
||||
|
|
||||
|
buffer << exRes; |
||||
|
BOOST_CHECK_MESSAGE(buffer.str() == "{12345, a94f5374fce5edbc8e2a8697c15331677e6ebf0b, 001122334455}", "Error ExecutionResultOutput"); |
||||
|
} |
||||
|
|
||||
|
BOOST_AUTO_TEST_CASE(transactionExceptionOutput) |
||||
|
{ |
||||
|
std::stringstream buffer; |
||||
|
buffer << TransactionException::BadInstruction; |
||||
|
BOOST_CHECK_MESSAGE(buffer.str() == "BadInstruction", "Error output TransactionException::BadInstruction"); |
||||
|
buffer.str(std::string()); |
||||
|
|
||||
|
buffer << TransactionException::None; |
||||
|
BOOST_CHECK_MESSAGE(buffer.str() == "None", "Error output TransactionException::None"); |
||||
|
buffer.str(std::string()); |
||||
|
|
||||
|
buffer << TransactionException::BadRLP; |
||||
|
BOOST_CHECK_MESSAGE(buffer.str() == "BadRLP", "Error output TransactionException::BadRLP"); |
||||
|
buffer.str(std::string()); |
||||
|
|
||||
|
buffer << TransactionException::InvalidFormat; |
||||
|
BOOST_CHECK_MESSAGE(buffer.str() == "InvalidFormat", "Error output TransactionException::InvalidFormat"); |
||||
|
buffer.str(std::string()); |
||||
|
|
||||
|
buffer << TransactionException::OutOfGasIntrinsic; |
||||
|
BOOST_CHECK_MESSAGE(buffer.str() == "OutOfGasIntrinsic", "Error output TransactionException::OutOfGasIntrinsic"); |
||||
|
buffer.str(std::string()); |
||||
|
|
||||
|
buffer << TransactionException::InvalidSignature; |
||||
|
BOOST_CHECK_MESSAGE(buffer.str() == "InvalidSignature", "Error output TransactionException::InvalidSignature"); |
||||
|
buffer.str(std::string()); |
||||
|
|
||||
|
buffer << TransactionException::InvalidNonce; |
||||
|
BOOST_CHECK_MESSAGE(buffer.str() == "InvalidNonce", "Error output TransactionException::InvalidNonce"); |
||||
|
buffer.str(std::string()); |
||||
|
|
||||
|
buffer << TransactionException::NotEnoughCash; |
||||
|
BOOST_CHECK_MESSAGE(buffer.str() == "NotEnoughCash", "Error output TransactionException::NotEnoughCash"); |
||||
|
buffer.str(std::string()); |
||||
|
|
||||
|
buffer << TransactionException::OutOfGasBase; |
||||
|
BOOST_CHECK_MESSAGE(buffer.str() == "OutOfGasBase", "Error output TransactionException::OutOfGasBase"); |
||||
|
buffer.str(std::string()); |
||||
|
|
||||
|
buffer << TransactionException::BlockGasLimitReached; |
||||
|
BOOST_CHECK_MESSAGE(buffer.str() == "BlockGasLimitReached", "Error output TransactionException::BlockGasLimitReached"); |
||||
|
buffer.str(std::string()); |
||||
|
|
||||
|
buffer << TransactionException::BadInstruction; |
||||
|
BOOST_CHECK_MESSAGE(buffer.str() == "BadInstruction", "Error output TransactionException::BadInstruction"); |
||||
|
buffer.str(std::string()); |
||||
|
|
||||
|
buffer << TransactionException::BadJumpDestination; |
||||
|
BOOST_CHECK_MESSAGE(buffer.str() == "BadJumpDestination", "Error output TransactionException::BadJumpDestination"); |
||||
|
buffer.str(std::string()); |
||||
|
|
||||
|
buffer << TransactionException::OutOfGas; |
||||
|
BOOST_CHECK_MESSAGE(buffer.str() == "OutOfGas", "Error output TransactionException::OutOfGas"); |
||||
|
buffer.str(std::string()); |
||||
|
|
||||
|
buffer << TransactionException::OutOfStack; |
||||
|
BOOST_CHECK_MESSAGE(buffer.str() == "OutOfStack", "Error output TransactionException::OutOfStack"); |
||||
|
buffer.str(std::string()); |
||||
|
|
||||
|
buffer << TransactionException::StackUnderflow; |
||||
|
BOOST_CHECK_MESSAGE(buffer.str() == "StackUnderflow", "Error output TransactionException::StackUnderflow"); |
||||
|
buffer.str(std::string()); |
||||
|
|
||||
|
buffer << TransactionException(-1); |
||||
|
BOOST_CHECK_MESSAGE(buffer.str() == "Unknown", "Error output TransactionException::StackUnderflow"); |
||||
|
buffer.str(std::string()); |
||||
|
} |
||||
|
|
||||
|
BOOST_AUTO_TEST_CASE(toTransactionExceptionConvert) |
||||
|
{ |
||||
|
RLPException rlpEx("exception");//toTransactionException(*(dynamic_cast<Exception*>
|
||||
|
BOOST_CHECK_MESSAGE(toTransactionException(rlpEx) == TransactionException::BadRLP, "RLPException !=> TransactionException"); |
||||
|
OutOfGasIntrinsic oogEx; |
||||
|
BOOST_CHECK_MESSAGE(toTransactionException(oogEx) == TransactionException::OutOfGasIntrinsic, "OutOfGasIntrinsic !=> TransactionException"); |
||||
|
InvalidSignature sigEx; |
||||
|
BOOST_CHECK_MESSAGE(toTransactionException(sigEx) == TransactionException::InvalidSignature, "InvalidSignature !=> TransactionException"); |
||||
|
OutOfGasBase oogbEx; |
||||
|
BOOST_CHECK_MESSAGE(toTransactionException(oogbEx) == TransactionException::OutOfGasBase, "OutOfGasBase !=> TransactionException"); |
||||
|
InvalidNonce nonceEx; |
||||
|
BOOST_CHECK_MESSAGE(toTransactionException(nonceEx) == TransactionException::InvalidNonce, "InvalidNonce !=> TransactionException"); |
||||
|
NotEnoughCash cashEx; |
||||
|
BOOST_CHECK_MESSAGE(toTransactionException(cashEx) == TransactionException::NotEnoughCash, "NotEnoughCash !=> TransactionException"); |
||||
|
BlockGasLimitReached blGasEx; |
||||
|
BOOST_CHECK_MESSAGE(toTransactionException(blGasEx) == TransactionException::BlockGasLimitReached, "BlockGasLimitReached !=> TransactionException"); |
||||
|
BadInstruction badInsEx; |
||||
|
BOOST_CHECK_MESSAGE(toTransactionException(badInsEx) == TransactionException::BadInstruction, "BadInstruction !=> TransactionException"); |
||||
|
BadJumpDestination badJumpEx; |
||||
|
BOOST_CHECK_MESSAGE(toTransactionException(badJumpEx) == TransactionException::BadJumpDestination, "BadJumpDestination !=> TransactionException"); |
||||
|
OutOfGas oogEx2; |
||||
|
BOOST_CHECK_MESSAGE(toTransactionException(oogEx2) == TransactionException::OutOfGas, "OutOfGas !=> TransactionException"); |
||||
|
OutOfStack oosEx; |
||||
|
BOOST_CHECK_MESSAGE(toTransactionException(oosEx) == TransactionException::OutOfStack, "OutOfStack !=> TransactionException"); |
||||
|
StackUnderflow stackEx; |
||||
|
BOOST_CHECK_MESSAGE(toTransactionException(stackEx) == TransactionException::StackUnderflow, "StackUnderflow !=> TransactionException"); |
||||
|
Exception notEx; |
||||
|
BOOST_CHECK_MESSAGE(toTransactionException(notEx) == TransactionException::Unknown, "Unexpected should be TransactionException::Unknown"); |
||||
|
} |
||||
|
|
||||
|
BOOST_AUTO_TEST_SUITE_END() |
||||
@ -0,0 +1,264 @@ |
|||||
|
/*
|
||||
|
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 shhrpc.cpp
|
||||
|
* @author Vladislav Gluhovsky <vlad@ethdev.com> |
||||
|
* @date July 2015 |
||||
|
*/ |
||||
|
|
||||
|
#include <boost/test/unit_test.hpp> |
||||
|
#include <boost/lexical_cast.hpp> |
||||
|
#include <libdevcore/Log.h> |
||||
|
#include <libdevcore/CommonIO.h> |
||||
|
#include <libethcore/CommonJS.h> |
||||
|
#include <libwebthree/WebThree.h> |
||||
|
#include <libweb3jsonrpc/WebThreeStubServer.h> |
||||
|
#include <jsonrpccpp/server/connectors/httpserver.h> |
||||
|
#include <jsonrpccpp/client/connectors/httpclient.h> |
||||
|
#include <test/TestHelper.h> |
||||
|
#include <test/libweb3jsonrpc/webthreestubclient.h> |
||||
|
#include <libethcore/KeyManager.h> |
||||
|
#include <libp2p/Common.h> |
||||
|
#include <libwhisper/WhisperHost.h> |
||||
|
|
||||
|
using namespace std; |
||||
|
using namespace dev; |
||||
|
using namespace dev::eth; |
||||
|
using namespace dev::p2p; |
||||
|
using namespace dev::shh; |
||||
|
namespace js = json_spirit; |
||||
|
|
||||
|
WebThreeDirect* web3; |
||||
|
unique_ptr<WebThreeStubServer> jsonrpcServer; |
||||
|
unique_ptr<WebThreeStubClient> jsonrpcClient; |
||||
|
static uint16_t const web3port = 30333; |
||||
|
|
||||
|
struct Setup |
||||
|
{ |
||||
|
Setup() |
||||
|
{ |
||||
|
dev::p2p::NodeIPEndpoint::test_allowLocal = true; |
||||
|
|
||||
|
static bool setup = false; |
||||
|
if (!setup) |
||||
|
{ |
||||
|
setup = true; |
||||
|
NetworkPreferences nprefs(std::string(), web3port, false); |
||||
|
web3 = new WebThreeDirect("shhrpc-web3", "", WithExisting::Trust, {"eth", "shh"}, nprefs); |
||||
|
web3->setIdealPeerCount(1); |
||||
|
web3->ethereum()->setForceMining(false); |
||||
|
auto server = new jsonrpc::HttpServer(8080); |
||||
|
vector<KeyPair> v; |
||||
|
KeyManager keyMan; |
||||
|
TrivialGasPricer gp; |
||||
|
jsonrpcServer = unique_ptr<WebThreeStubServer>(new WebThreeStubServer(*server, *web3, nullptr, v, keyMan, gp)); |
||||
|
jsonrpcServer->setIdentities({}); |
||||
|
jsonrpcServer->StartListening(); |
||||
|
auto client = new jsonrpc::HttpClient("http://localhost:8080"); |
||||
|
jsonrpcClient = unique_ptr<WebThreeStubClient>(new WebThreeStubClient(*client)); |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
~Setup() |
||||
|
{ |
||||
|
dev::p2p::NodeIPEndpoint::test_allowLocal = false; |
||||
|
} |
||||
|
}; |
||||
|
|
||||
|
|
||||
|
BOOST_FIXTURE_TEST_SUITE(shhrpc, Setup) |
||||
|
|
||||
|
BOOST_AUTO_TEST_CASE(basic) |
||||
|
{ |
||||
|
cnote << "Testing web3 basic functionality..."; |
||||
|
|
||||
|
web3->startNetwork(); |
||||
|
unsigned const step = 10; |
||||
|
for (unsigned i = 0; i < 3000 && !web3->haveNetwork(); i += step) |
||||
|
this_thread::sleep_for(chrono::milliseconds(step)); |
||||
|
|
||||
|
BOOST_REQUIRE(web3->haveNetwork()); |
||||
|
|
||||
|
uint16_t const port2 = 30334; |
||||
|
NetworkPreferences prefs2("127.0.0.1", port2, false); |
||||
|
string const version2 = "shhrpc-host2"; |
||||
|
Host host2(version2, prefs2); |
||||
|
auto whost2 = host2.registerCapability(new WhisperHost()); |
||||
|
host2.start(); |
||||
|
|
||||
|
for (unsigned i = 0; i < 3000 && !host2.haveNetwork(); i += step) |
||||
|
this_thread::sleep_for(chrono::milliseconds(step)); |
||||
|
|
||||
|
BOOST_REQUIRE(host2.haveNetwork()); |
||||
|
|
||||
|
web3->addNode(host2.id(), NodeIPEndpoint(bi::address::from_string("127.0.0.1"), port2, port2)); |
||||
|
|
||||
|
for (unsigned i = 0; i < 3000 && (!web3->peerCount() || !host2.peerCount()); i += step) |
||||
|
this_thread::sleep_for(chrono::milliseconds(step)); |
||||
|
|
||||
|
BOOST_REQUIRE_EQUAL(host2.peerCount(), 1); |
||||
|
BOOST_REQUIRE_EQUAL(web3->peerCount(), 1); |
||||
|
|
||||
|
vector<PeerSessionInfo> vpeers = web3->peers(); |
||||
|
BOOST_REQUIRE(!vpeers.empty()); |
||||
|
PeerSessionInfo const& peer = vpeers.back(); |
||||
|
BOOST_REQUIRE_EQUAL(peer.id, host2.id()); |
||||
|
BOOST_REQUIRE_EQUAL(peer.port, port2); |
||||
|
BOOST_REQUIRE_EQUAL(peer.clientVersion, version2); |
||||
|
|
||||
|
web3->stopNetwork(); |
||||
|
|
||||
|
for (unsigned i = 0; i < 3000 && (web3->haveNetwork() || host2.haveNetwork()); i += step) |
||||
|
this_thread::sleep_for(chrono::milliseconds(step)); |
||||
|
|
||||
|
BOOST_REQUIRE(!web3->peerCount()); |
||||
|
BOOST_REQUIRE(!host2.peerCount()); |
||||
|
} |
||||
|
|
||||
|
BOOST_AUTO_TEST_CASE(send) |
||||
|
{ |
||||
|
cnote << "Testing web3 send..."; |
||||
|
|
||||
|
bool sent = false; |
||||
|
bool ready = false; |
||||
|
unsigned result = 0; |
||||
|
unsigned const messageCount = 10; |
||||
|
unsigned const step = 10; |
||||
|
uint16_t port2 = 30337; |
||||
|
|
||||
|
Host host2("shhrpc-host2", NetworkPreferences("127.0.0.1", port2, false)); |
||||
|
host2.setIdealPeerCount(1); |
||||
|
auto whost2 = host2.registerCapability(new WhisperHost()); |
||||
|
host2.start(); |
||||
|
web3->startNetwork(); |
||||
|
|
||||
|
std::thread listener([&]() |
||||
|
{ |
||||
|
setThreadName("listener"); |
||||
|
ready = true; |
||||
|
auto w = whost2->installWatch(BuildTopicMask("odd")); |
||||
|
set<unsigned> received; |
||||
|
for (unsigned x = 0; x < 9000 && !sent; x += step) |
||||
|
this_thread::sleep_for(chrono::milliseconds(step)); |
||||
|
|
||||
|
for (unsigned x = 0, last = 0; x < 100 && received.size() < messageCount; ++x) |
||||
|
{ |
||||
|
this_thread::sleep_for(chrono::milliseconds(50)); |
||||
|
for (auto i: whost2->checkWatch(w)) |
||||
|
{ |
||||
|
Message msg = whost2->envelope(i).open(whost2->fullTopics(w)); |
||||
|
last = RLP(msg.payload()).toInt<unsigned>(); |
||||
|
if (received.insert(last).second) |
||||
|
result += last; |
||||
|
} |
||||
|
} |
||||
|
}); |
||||
|
|
||||
|
for (unsigned i = 0; i < 2000 && (!host2.haveNetwork() || !web3->haveNetwork()); i += step) |
||||
|
this_thread::sleep_for(chrono::milliseconds(step)); |
||||
|
|
||||
|
BOOST_REQUIRE(host2.haveNetwork()); |
||||
|
BOOST_REQUIRE(web3->haveNetwork()); |
||||
|
|
||||
|
web3->requirePeer(host2.id(), NodeIPEndpoint(bi::address::from_string("127.0.0.1"), port2, port2)); |
||||
|
|
||||
|
for (unsigned i = 0; i < 3000 && (!web3->peerCount() || !host2.peerCount()); i += step) |
||||
|
this_thread::sleep_for(chrono::milliseconds(step)); |
||||
|
|
||||
|
BOOST_REQUIRE_EQUAL(host2.peerCount(), 1); |
||||
|
BOOST_REQUIRE_EQUAL(web3->peerCount(), 1); |
||||
|
|
||||
|
KeyPair us = KeyPair::create(); |
||||
|
for (unsigned i = 0; i < messageCount; ++i) |
||||
|
{ |
||||
|
web3->whisper()->post(us.sec(), RLPStream().append(i * i).out(), BuildTopic(i)(i % 2 ? "odd" : "even"), 777000, 1); |
||||
|
this_thread::sleep_for(chrono::milliseconds(50)); |
||||
|
} |
||||
|
|
||||
|
sent = true; |
||||
|
auto messages = web3->whisper()->all(); |
||||
|
BOOST_REQUIRE_EQUAL(messages.size(), messageCount); |
||||
|
|
||||
|
listener.join(); |
||||
|
BOOST_REQUIRE_EQUAL(result, 1 + 9 + 25 + 49 + 81); |
||||
|
} |
||||
|
|
||||
|
BOOST_AUTO_TEST_CASE(receive) |
||||
|
{ |
||||
|
cnote << "Testing web3 receive..."; |
||||
|
|
||||
|
bool sent = false; |
||||
|
bool ready = false; |
||||
|
unsigned result = 0; |
||||
|
unsigned const messageCount = 6; |
||||
|
unsigned const step = 10; |
||||
|
uint16_t port2 = 30338; |
||||
|
Host host2("shhrpc-host2", NetworkPreferences("127.0.0.1", port2, false)); |
||||
|
host2.setIdealPeerCount(1); |
||||
|
auto whost2 = host2.registerCapability(new WhisperHost()); |
||||
|
host2.start(); |
||||
|
web3->startNetwork(); |
||||
|
|
||||
|
std::thread listener([&]() |
||||
|
{ |
||||
|
setThreadName("listener"); |
||||
|
ready = true; |
||||
|
auto w = web3->whisper()->installWatch(BuildTopicMask("odd")); |
||||
|
|
||||
|
set<unsigned> received; |
||||
|
for (unsigned x = 0; x < 9000 && !sent; x += step) |
||||
|
this_thread::sleep_for(chrono::milliseconds(step)); |
||||
|
|
||||
|
for (unsigned x = 0, last = 0; x < 100 && received.size() < messageCount; ++x) |
||||
|
{ |
||||
|
this_thread::sleep_for(chrono::milliseconds(50)); |
||||
|
for (auto i: web3->whisper()->checkWatch(w)) |
||||
|
{ |
||||
|
Message msg = web3->whisper()->envelope(i).open(web3->whisper()->fullTopics(w)); |
||||
|
last = RLP(msg.payload()).toInt<unsigned>(); |
||||
|
if (received.insert(last).second) |
||||
|
result += last; |
||||
|
} |
||||
|
} |
||||
|
}); |
||||
|
|
||||
|
for (unsigned i = 0; i < 2000 && (!host2.haveNetwork() || !web3->haveNetwork()); i += step) |
||||
|
this_thread::sleep_for(chrono::milliseconds(step)); |
||||
|
|
||||
|
BOOST_REQUIRE(host2.haveNetwork()); |
||||
|
BOOST_REQUIRE(web3->haveNetwork()); |
||||
|
|
||||
|
host2.addNode(web3->id(), NodeIPEndpoint(bi::address::from_string("127.0.0.1"), web3port, web3port)); |
||||
|
|
||||
|
for (unsigned i = 0; i < 3000 && (!web3->peerCount() || !host2.peerCount()); i += step) |
||||
|
this_thread::sleep_for(chrono::milliseconds(step)); |
||||
|
|
||||
|
BOOST_REQUIRE_EQUAL(host2.peerCount(), 1); |
||||
|
BOOST_REQUIRE_EQUAL(web3->peerCount(), 1); |
||||
|
|
||||
|
KeyPair us = KeyPair::create(); |
||||
|
for (unsigned i = 0; i < messageCount; ++i) |
||||
|
{ |
||||
|
web3->whisper()->post(us.sec(), RLPStream().append(i * i * i).out(), BuildTopic(i)(i % 2 ? "odd" : "even"), 777000, 1); |
||||
|
this_thread::sleep_for(chrono::milliseconds(50)); |
||||
|
} |
||||
|
|
||||
|
sent = true; |
||||
|
listener.join(); |
||||
|
BOOST_REQUIRE_EQUAL(result, 1 + 27 + 125); |
||||
|
} |
||||
|
|
||||
|
BOOST_AUTO_TEST_SUITE_END() |
||||
Loading…
Reference in new issue