Implemented 256-long history for PREVHASH, though still optional.

alethzero/MainWin.cpp

@@ -1350,7 +1350,7 @@ void Main::on_debugCurrent_triggered()
 		{
 			unsigned txi = item->data(Qt::UserRole + 1).toInt();
 			m_executiveState = ethereum()->state(txi + 1, h);
-			m_currentExecution = unique_ptr<Executive>(new Executive(m_executiveState, 0));
+			m_currentExecution = unique_ptr<Executive>(new Executive(m_executiveState, ethereum()->blockChain(), 0));
 			Transaction t = m_executiveState.pending()[txi];
 			m_executiveState = m_executiveState.fromPending(txi);
 			auto r = t.rlp();
@@ -1803,7 +1803,7 @@ void Main::on_debug_clicked()
 			{
 				Secret s = i.secret();
 				m_executiveState = ethereum()->postState();
-				m_currentExecution = unique_ptr<Executive>(new Executive(m_executiveState, 0));
+				m_currentExecution = unique_ptr<Executive>(new Executive(m_executiveState, ethereum()->blockChain(), 0));
 				Transaction t = isCreation() ?
 					Transaction(value(), gasPrice(), ui->gas->value(), m_data, m_executiveState.transactionsFrom(dev::toAddress(s)), s) :
 					Transaction(value(), gasPrice(), ui->gas->value(), fromString(ui->destination->currentText()), m_data, m_executiveState.transactionsFrom(dev::toAddress(s)), s);

eth/main.cpp

@@ -619,7 +619,7 @@ int main(int argc, char** argv)
 				dev::eth::State state =c->state(index + 1,c->blockChain().numberHash(block));
 				if (index < state.pending().size())
 				{
-					Executive e(state, 0);
+					Executive e(state, c->blockChain(), 0);
 					Transaction t = state.pending()[index];
 					state = state.fromPending(index);
 					bytes r = t.rlp();

exp/main.cpp

@@ -21,13 +21,13 @@
  */
 #include <functional>
 #include <libethereum/AccountDiff.h>
+#include <libdevcore/RangeMask.h>
 #include <libdevcore/Log.h>
 #include <libdevcore/Common.h>
 #include <libdevcore/CommonData.h>
 #include <libdevcore/RLP.h>
 #include <libdevcore/CommonIO.h>
 #include <libp2p/All.h>
-#include <libdevcore/RangeMask.h>
 #include <libethereum/DownloadMan.h>
 #include <libethereum/All.h>
 #include <liblll/All.h>
@@ -91,7 +91,7 @@ int main()
 	Transaction t(0, 10000, 10000, c, bytes(), 0, u.secret());
 	cnote << "Transaction: " << t;
 	cnote << s.balance(c);
-	s.execute(t.rlp());
+	s.execute(LastHashes(), t.rlp());
 	cnote << "State after transaction: " << s;
 	cnote << before.diff(s);
 }

libethereum/Client.cpp

@@ -343,7 +343,7 @@ bytes Client::call(Secret _secret, u256 _value, Address _dest, bytes const& _dat
 			n = temp.transactionsFrom(toAddress(_secret));
 		}
 		Transaction t(_value, _gasPrice, _gas, _dest, _data, n, _secret);
-		u256 gasUsed = temp.execute(t.rlp(), &out, false);
+		u256 gasUsed = temp.execute(m_bc, t.rlp(), &out, false);
 		(void)gasUsed; // TODO: do something with gasused which it returns.
 	}
 	catch (...)
@@ -442,7 +442,7 @@ void Client::doWork()
 
 		// returns h256s as blooms, once for each transaction.
 		cwork << "postSTATE <== TQ";
-		h512s newPendingBlooms = m_postMine.sync(m_tq);
+		h512s newPendingBlooms = m_postMine.sync(m_bc, m_tq);
 		if (newPendingBlooms.size())
 		{
 			for (auto i: newPendingBlooms)

libethereum/Executive.cpp

@@ -29,12 +29,19 @@
 #include "State.h"
 #include "ExtVM.h"
 #include "Precompiled.h"
+#include "BlockChain.h"
 using namespace std;
 using namespace dev;
 using namespace dev::eth;
 
 #define ETH_VMTRACE 1
 
+Executive::Executive(State& _s, BlockChain const& _bc, unsigned _level):
+	m_s(_s),
+	m_lastHashes(_s.getLastHashes(_bc)),
+	m_depth(_level)
+{}
+
 u256 Executive::gasUsed() const
 {
 	return m_t.gas() - m_endGas;
@@ -123,7 +130,7 @@ bool Executive::call(Address _receiveAddress, Address _codeAddress, Address _sen
 	{
 		m_vm = VMFactory::create(_gas);
 		bytes const& c = m_s.code(_codeAddress);
-		m_ext = make_shared<ExtVM>(m_s, _receiveAddress, _senderAddress, _originAddress, _value, _gasPrice, _data, &c, m_depth);
+		m_ext = make_shared<ExtVM>(m_s, m_lastHashes, _receiveAddress, _senderAddress, _originAddress, _value, _gasPrice, _data, &c, m_depth);
 	}
 	else
 		m_endGas = _gas;
@@ -143,7 +150,7 @@ bool Executive::create(Address _sender, u256 _endowment, u256 _gasPrice, u256 _g
 
 	// Execute _init.
 	m_vm = VMFactory::create(_gas);
-	m_ext = make_shared<ExtVM>(m_s, m_newAddress, _sender, _origin, _endowment, _gasPrice, bytesConstRef(), _init, m_depth);
+	m_ext = make_shared<ExtVM>(m_s, m_lastHashes, m_newAddress, _sender, _origin, _endowment, _gasPrice, bytesConstRef(), _init, m_depth);
 	return _init.empty();
 }
 

libethereum/Executive.h

@@ -34,6 +34,7 @@ namespace eth
 {
 
 class State;
+class BlockChain;
 class ExtVM;
 struct Manifest;
 
@@ -52,7 +53,9 @@ class Executive
 {
 public:
 	/// Basic constructor.
-	Executive(State& _s, unsigned _level): m_s(_s), m_depth(_level) {}
+	Executive(State& _s, LastHashes const& _lh, unsigned _level): m_s(_s), m_lastHashes(_lh), m_depth(_level) {}
+	/// Basic constructor.
+	Executive(State& _s, BlockChain const& _bc, unsigned _level);
 	/// Basic destructor.
 	~Executive() = default;
 
@@ -102,6 +105,7 @@ public:
 
 private:
 	State& m_s;							///< The state to which this operation/transaction is applied.
+	LastHashes m_lastHashes;
 	std::shared_ptr<ExtVM> m_ext;		///< The VM externality object for the VM execution or null if no VM is required.
 	std::unique_ptr<VMFace> m_vm;		///< The VM object or null if no VM is required.
 	bytes m_precompiledOut;				///< Used for the output when there is no VM for a contract (i.e. precompiled).

libethereum/ExtVM.cpp

@@ -28,7 +28,7 @@ using namespace dev::eth;
 
 bool ExtVM::call(Address _receiveAddress, u256 _txValue, bytesConstRef _txData, u256& io_gas, bytesRef _out, OnOpFunc const& _onOp, Address _myAddressOverride, Address _codeAddressOverride)
 {
-	Executive e(m_s, depth + 1);
+	Executive e(m_s, lastHashes, depth + 1);
 	if (!e.call(_receiveAddress, _codeAddressOverride ? _codeAddressOverride : _receiveAddress, _myAddressOverride ? _myAddressOverride : myAddress, _txValue, gasPrice, _txData, io_gas, origin))
 	{
 		e.go(_onOp);
@@ -45,7 +45,7 @@ h160 ExtVM::create(u256 _endowment, u256& io_gas, bytesConstRef _code, OnOpFunc
 	// Increment associated nonce for sender.
 	m_s.noteSending(myAddress);
 
-	Executive e(m_s, depth + 1);
+	Executive e(m_s, lastHashes, depth + 1);
 	if (!e.create(myAddress, _endowment, gasPrice, io_gas, _code, origin))
 	{
 		e.go(_onOp);

libethereum/ExtVM.h

@@ -39,8 +39,8 @@ class ExtVM: public ExtVMFace
 {
 public:
 	/// Full constructor.
-	ExtVM(State& _s, Address _myAddress, Address _caller, Address _origin, u256 _value, u256 _gasPrice, bytesConstRef _data, bytesConstRef _code, unsigned _depth = 0):
-		ExtVMFace(_myAddress, _caller, _origin, _value, _gasPrice, _data, _code.toBytes(), _s.m_previousBlock, _s.m_currentBlock, _depth), m_s(_s), m_origCache(_s.m_cache)
+	ExtVM(State& _s, LastHashes const& _lh, Address _myAddress, Address _caller, Address _origin, u256 _value, u256 _gasPrice, bytesConstRef _data, bytesConstRef _code, unsigned _depth = 0):
+		ExtVMFace(_myAddress, _caller, _origin, _value, _gasPrice, _data, _code.toBytes(), _s.m_previousBlock, _s.m_currentBlock, _lh, _depth), m_s(_s), m_origCache(_s.m_cache)
 	{
 		m_s.ensureCached(_myAddress, true, true);
 	}

libethereum/State.cpp

@@ -114,7 +114,7 @@ State::State(OverlayDB const& _db, BlockChain const& _bc, h256 _h):
 	m_ourAddress = bi.coinbaseAddress;
 
 	sync(_bc, bi.parentHash, bip);
-	enact(&b);
+	enact(&b, _bc);
 }
 
 State::State(State const& _s):
@@ -319,7 +319,7 @@ bool State::sync(BlockChain const& _bc, h256 _block, BlockInfo const& _bi)
 			for (auto it = chain.rbegin(); it != chain.rend(); ++it)
 			{
 				auto b = _bc.block(*it);
-				enact(&b);
+				enact(&b, _bc);
 				cleanup(true);
 			}
 		}
@@ -348,7 +348,7 @@ u256 State::enactOn(bytesConstRef _block, BlockInfo const& _bi, BlockChain const
 	sync(_bc, _bi.parentHash);
 	resetCurrent();
 	m_previousBlock = biParent;
-	return enact(_block, &_bc);
+	return enact(_block, _bc);
 }
 
 map<Address, u256> State::addresses() const
@@ -412,12 +412,14 @@ bool State::cull(TransactionQueue& _tq) const
 	return ret;
 }
 
-h512s State::sync(TransactionQueue& _tq, bool* o_transactionQueueChanged)
+h512s State::sync(BlockChain const& _bc, TransactionQueue& _tq, bool* o_transactionQueueChanged)
 {
 	// TRANSACTIONS
 	h512s ret;
 	auto ts = _tq.transactions();
 
+	auto lh = getLastHashes(_bc);
+
 	for (int goodTxs = 1; goodTxs;)
 	{
 		goodTxs = 0;
@@ -429,7 +431,7 @@ h512s State::sync(TransactionQueue& _tq, bool* o_transactionQueueChanged)
 				{
 					uncommitToMine();
 //					boost::timer t;
-					execute(i.second);
+					execute(lh, i.second);
 					ret.push_back(m_receipts.back().bloom());
 					_tq.noteGood(i);
 					++goodTxs;
@@ -467,7 +469,7 @@ h512s State::sync(TransactionQueue& _tq, bool* o_transactionQueueChanged)
 	return ret;
 }
 
-u256 State::enact(bytesConstRef _block, BlockChain const* _bc, bool _checkNonce)
+u256 State::enact(bytesConstRef _block, BlockChain const& _bc, bool _checkNonce)
 {
 	// m_currentBlock is assumed to be prepopulated and reset.
 
@@ -496,6 +498,8 @@ u256 State::enact(bytesConstRef _block, BlockChain const* _bc, bool _checkNonce)
 	GenericTrieDB<MemoryDB> receiptsTrie(&rm);
 	receiptsTrie.init();
 
+	LastHashes lh = getLastHashes(_bc);
+
 	// All ok with the block generally. Play back the transactions now...
 	unsigned i = 0;
 	for (auto const& tr: RLP(_block)[1])
@@ -507,7 +511,7 @@ u256 State::enact(bytesConstRef _block, BlockChain const* _bc, bool _checkNonce)
 
 //		cnote << m_state.root() << m_state;
 //		cnote << *this;
-		execute(tr.data());
+		execute(lh, tr.data());
 
 		RLPStream receiptrlp;
 		m_receipts.back().streamRLP(receiptrlp);
@@ -551,7 +555,7 @@ u256 State::enact(bytesConstRef _block, BlockChain const* _bc, bool _checkNonce)
 	// Check uncles & apply their rewards to state.
 	set<h256> nonces = { m_currentBlock.nonce };
 	Addresses rewarded;
-	set<h256> knownUncles = _bc ? _bc->allUnclesFrom(m_currentBlock.parentHash) : set<h256>();
+	set<h256> knownUncles = _bc.allUnclesFrom(m_currentBlock.parentHash);
 	for (auto const& i: RLP(_block)[2])
 	{
 		if (knownUncles.count(sha3(i.data())))
@@ -560,13 +564,11 @@ u256 State::enact(bytesConstRef _block, BlockChain const* _bc, bool _checkNonce)
 		BlockInfo uncle = BlockInfo::fromHeader(i.data());
 		if (nonces.count(uncle.nonce))
 			BOOST_THROW_EXCEPTION(DuplicateUncleNonce());
-		if (_bc)
-		{
-			BlockInfo uncleParent(_bc->block(uncle.parentHash));
-			if ((bigint)uncleParent.number < (bigint)m_currentBlock.number - 6)
-				BOOST_THROW_EXCEPTION(UncleTooOld());
-			uncle.verifyParent(uncleParent);
-		}
+
+		BlockInfo uncleParent(_bc.block(uncle.parentHash));
+		if ((bigint)uncleParent.number < (bigint)m_currentBlock.number - 6)
+			BOOST_THROW_EXCEPTION(UncleTooOld());
+		uncle.verifyParent(uncleParent);
 
 		nonces.insert(uncle.nonce);
 		tdIncrease += uncle.difficulty;
@@ -648,7 +650,7 @@ bool State::amIJustParanoid(BlockChain const& _bc)
 		cnote << "PARANOIA root:" << s.rootHash();
 //		s.m_currentBlock.populate(&block.out(), false);
 //		s.m_currentBlock.verifyInternals(&block.out());
-		s.enact(&block.out(), &_bc, false);	// don't check nonce for this since we haven't mined it yet.
+		s.enact(&block.out(), _bc, false);	// don't check nonce for this since we haven't mined it yet.
 		s.cleanup(false);
 		return true;
 	}
@@ -993,9 +995,17 @@ bool State::isTrieGood(bool _enforceRefs, bool _requireNoLeftOvers) const
 	return true;
 }
 
-// TODO: maintain node overlay revisions for stateroots -> each commit gives a stateroot + OverlayDB; allow overlay copying for rewind operations.
+LastHashes State::getLastHashes(BlockChain const& _bc) const
+{
+	LastHashes ret;
+	unsigned n = (unsigned)m_previousBlock.number;
+	for (unsigned i = 0; i < 256; ++i)
+		ret[i] = _bc.numberHash(n - i);
+	return ret;
+}
 
-u256 State::execute(bytesConstRef _rlp, bytes* o_output, bool _commit)
+// TODO: maintain node overlay revisions for stateroots -> each commit gives a stateroot + OverlayDB; allow overlay copying for rewind operations.
+u256 State::execute(LastHashes const& _lh, bytesConstRef _rlp, bytes* o_output, bool _commit)
 {
 #ifndef ETH_RELEASE
 	commit();	// get an updated hash
@@ -1008,7 +1018,7 @@ u256 State::execute(bytesConstRef _rlp, bytes* o_output, bool _commit)
 	auto h = rootHash();
 #endif
 
-	Executive e(*this, 0);
+	Executive e(*this, _lh, 0);
 	e.setup(_rlp);
 
 	u256 startGasUsed = gasUsed();

libethereum/State.h

@@ -143,14 +143,18 @@ public:
 	/// @returns a list of bloom filters one for each transaction placed from the queue into the state.
 	/// @a o_transactionQueueChanged boolean pointer, the value of which will be set to true if the transaction queue
 	/// changed and the pointer is non-null
-	h512s sync(TransactionQueue& _tq, bool* o_transactionQueueChanged = nullptr);
+	h512s sync(BlockChain const& _bc, TransactionQueue& _tq, bool* o_transactionQueueChanged = nullptr);
 	/// Like sync but only operate on _tq, killing the invalid/old ones.
 	bool cull(TransactionQueue& _tq) const;
 
+	LastHashes getLastHashes(BlockChain const& _bc) const;
+
 	/// Execute a given transaction.
 	/// This will append @a _t to the transaction list and change the state accordingly.
-	u256 execute(bytes const& _rlp, bytes* o_output = nullptr, bool _commit = true) { return execute(&_rlp, o_output, _commit); }
-	u256 execute(bytesConstRef _rlp, bytes* o_output = nullptr, bool _commit = true);
+	u256 execute(BlockChain const& _bc, bytes const& _rlp, bytes* o_output = nullptr, bool _commit = true) { return execute(getLastHashes(_bc), &_rlp, o_output, _commit); }
+	u256 execute(BlockChain const& _bc, bytesConstRef _rlp, bytes* o_output = nullptr, bool _commit = true) { return execute(getLastHashes(_bc), _rlp, o_output, _commit); }
+	u256 execute(LastHashes const& _lh, bytes const& _rlp, bytes* o_output = nullptr, bool _commit = true) { return execute(_lh, &_rlp, o_output, _commit); }
+	u256 execute(LastHashes const& _lh, bytesConstRef _rlp, bytes* o_output = nullptr, bool _commit = true);
 
 	/// Get the remaining gas limit in this block.
 	u256 gasLimitRemaining() const { return m_currentBlock.gasLimit - gasUsed(); }
@@ -268,9 +272,9 @@ private:
 	/// Retrieve all information about a given address into a cache.
 	void ensureCached(std::map<Address, Account>& _cache, Address _a, bool _requireCode, bool _forceCreate) const;
 
-	/// Execute the given block, assuming it corresponds to m_currentBlock. If _bc is passed, it will be used to check the uncles.
+	/// Execute the given block, assuming it corresponds to m_currentBlock.
 	/// Throws on failure.
-	u256 enact(bytesConstRef _block, BlockChain const* _bc = nullptr, bool _checkNonce = true);
+	u256 enact(bytesConstRef _block, BlockChain const& _bc, bool _checkNonce = true);
 
 	/// Finalise the block, applying the earned rewards.
 	void applyRewards(Addresses const& _uncleAddresses);

libevm/ExtVMFace.cpp

@@ -25,7 +25,7 @@ using namespace std;
 using namespace dev;
 using namespace dev::eth;
 
-ExtVMFace::ExtVMFace(Address _myAddress, Address _caller, Address _origin, u256 _value, u256 _gasPrice, bytesConstRef _data, bytes const& _code, BlockInfo const& _previousBlock, BlockInfo const& _currentBlock, unsigned _depth):
+ExtVMFace::ExtVMFace(Address _myAddress, Address _caller, Address _origin, u256 _value, u256 _gasPrice, bytesConstRef _data, bytes const& _code, BlockInfo const& _previousBlock, BlockInfo const& _currentBlock, LastHashes const& _lh, unsigned _depth):
 	myAddress(_myAddress),
 	caller(_caller),
 	origin(_origin),
@@ -33,6 +33,7 @@ ExtVMFace::ExtVMFace(Address _myAddress, Address _caller, Address _origin, u256
 	gasPrice(_gasPrice),
 	data(_data),
 	code(_code),
+	lastHashes(_lh),
 	previousBlock(_previousBlock),
 	currentBlock(_currentBlock),
 	depth(_depth)

libevm/ExtVMFace.h

@@ -93,6 +93,8 @@ struct SubState
 class ExtVMFace;
 class VM;
 
+using LastHashes = std::array<h256, 256>;
+
 using OnOpFunc = std::function<void(uint64_t /*steps*/, Instruction /*instr*/, bigint /*newMemSize*/, bigint /*gasCost*/, VM*, ExtVMFace const*)>;
 
 /**
@@ -105,7 +107,7 @@ public:
 	ExtVMFace() = default;
 
 	/// Full constructor.
-	ExtVMFace(Address _myAddress, Address _caller, Address _origin, u256 _value, u256 _gasPrice, bytesConstRef _data, bytes const& _code, BlockInfo const& _previousBlock, BlockInfo const& _currentBlock, unsigned _depth);
+	ExtVMFace(Address _myAddress, Address _caller, Address _origin, u256 _value, u256 _gasPrice, bytesConstRef _data, bytes const& _code, BlockInfo const& _previousBlock, BlockInfo const& _currentBlock, LastHashes const& _lh, unsigned _depth);
 
 	virtual ~ExtVMFace() = default;
 
@@ -145,6 +147,9 @@ public:
 	/// Revert any changes made (by any of the other calls).
 	virtual void revert() {}
 
+	/// Hash of a block if within the last 256 blocks, or h256() otherwise.
+	h256 prevhash(u256 _number) { return _number < currentBlock.number && _number > (std::max<u256>(257, currentBlock.number) - 257) ? lastHashes[(unsigned)(currentBlock.number - 1 - _number)] : h256(); }	// TODO: CHECK!!!
+
 	/// Get the code at the given location in code ROM.
 	byte getCode(u256 _n) const { return _n < code.size() ? code[(size_t)_n] : 0; }
 
@@ -155,7 +160,8 @@ public:
 	u256 gasPrice;				///< Price of gas (that we already paid).
 	bytesConstRef data;			///< Current input data.
 	bytes code;					///< Current code that is executing.
-	BlockInfo previousBlock;	///< The previous block's information.
+	LastHashes lastHashes;		///< Most recent 256 blocks' hashes.
+	BlockInfo previousBlock;	///< The previous block's information.	TODO: PoC-8: REMOVE
 	BlockInfo currentBlock;		///< The current block's information.
 	SubState sub;				///< Sub-band VM state (suicides, refund counter, logs).
 	unsigned depth = 0;			///< Depth of the present call.

libevm/VM.h

@@ -198,7 +198,6 @@ inline bytesConstRef VM::go(ExtVMFace& _ext, OnOpFunc const& _onOp, uint64_t _st
 			require(1);
 			runGas = c_balanceGas;
 			break;
-
 		case Instruction::LOG0:
 		case Instruction::LOG1:
 		case Instruction::LOG2:
@@ -240,6 +239,11 @@ inline bytesConstRef VM::go(ExtVMFace& _ext, OnOpFunc const& _onOp, uint64_t _st
 			break;
 		}
 
+		case Instruction::PREVHASH:
+			if (c_protocolVersion > 49)
+				require(1);
+		break;
+
 		case Instruction::PC:
 		case Instruction::MSIZE:
 		case Instruction::GAS:
@@ -251,7 +255,6 @@ inline bytesConstRef VM::go(ExtVMFace& _ext, OnOpFunc const& _onOp, uint64_t _st
 		case Instruction::CALLDATASIZE:
 		case Instruction::CODESIZE:
 		case Instruction::GASPRICE:
-		case Instruction::PREVHASH:
 		case Instruction::COINBASE:
 		case Instruction::TIMESTAMP:
 		case Instruction::NUMBER:
@@ -581,7 +584,10 @@ inline bytesConstRef VM::go(ExtVMFace& _ext, OnOpFunc const& _onOp, uint64_t _st
 			m_stack.push_back(_ext.gasPrice);
 			break;
 		case Instruction::PREVHASH:
-			m_stack.push_back(_ext.previousBlock.hash);
+			if (c_protocolVersion > 49)
+				m_stack.back() = (u256)_ext.prevhash(m_stack.back());
+			else
+				m_stack.push_back(_ext.previousBlock.hash);
 			break;
 		case Instruction::COINBASE:
 			m_stack.push_back((u160)_ext.currentBlock.coinbaseAddress);

libp2p/Session.cpp

@@ -195,7 +195,7 @@ bool Session::interpret(RLP const& _r)
 		// "'operator<<' should be declared prior to the call site or in an associated namespace of one of its arguments"
 		stringstream capslog;
 		for (auto cap: caps)
-			capslog << "(" << hex << cap.first << "," << hex << cap.second << ")";
+			capslog << "(" << cap.first << "," << dec << cap.second << ")";
 
 		clogS(NetMessageSummary) << "Hello: " << clientVersion << "V[" << m_protocolVersion << "]" << id.abridged() << showbase << capslog.str() << dec << listenPort;
 

mix/AssemblyDebuggerModel.cpp

@@ -38,7 +38,7 @@ AssemblyDebuggerModel::AssemblyDebuggerModel():
 	m_baseState(Address(), m_overlayDB, BaseState::Empty)
 {
 	m_baseState.addBalance(m_userAccount.address(), 10000000 * ether);
-	m_currentExecution = std::unique_ptr<Executive>(new Executive(m_executiveState, 0));
+	m_currentExecution = std::unique_ptr<Executive>(new Executive(m_executiveState, LastHashes(), 0));
 }
 
 DebuggingContent AssemblyDebuggerModel::getContractInitiationDebugStates(dev::bytesConstRef _rawTransaction)

test/solidityExecutionFramework.h

@@ -117,7 +117,7 @@ private:
 	void sendMessage(bytes const& _data, bool _isCreation, u256 const& _value = 0)
 	{
 		m_state.addBalance(m_sender, _value); // just in case
-		eth::Executive executive(m_state, 0);
+		eth::Executive executive(m_state, eth::LastHashes(), 0);
 		eth::Transaction t = _isCreation ? eth::Transaction(_value, m_gasPrice, m_gas, _data, 0, KeyPair::create().sec())
 										 : eth::Transaction(_value, m_gasPrice, m_gas, m_contractAddress, _data, 0, KeyPair::create().sec());
 		bytes transactionRLP = t.rlp();

test/state.cpp

@@ -62,7 +62,7 @@ void doStateTests(json_spirit::mValue& v, bool _fillin)
 
 		try
 		{
-			theState.execute(tx, &output);
+			theState.execute(LastHashes(), tx, &output);
 		}
 		catch (Exception const& _e)
 		{

test/stateOriginal.cpp

@@ -69,7 +69,7 @@ int stateTest()
 		assert(t.sender() == myMiner.address());
 		tx = t.rlp();
 	}
-	s.execute(tx);
+	s.execute(bc, tx);
 
 	cout << s;
 

test/vm.cpp

@@ -33,7 +33,7 @@ using namespace dev::eth;
 using namespace dev::test;
 
 FakeExtVM::FakeExtVM(eth::BlockInfo const& _previousBlock, eth::BlockInfo const& _currentBlock, unsigned _depth):			/// TODO: XXX: remove the default argument & fix.
-	ExtVMFace(Address(), Address(), Address(), 0, 1, bytesConstRef(), bytes(), _previousBlock, _currentBlock, _depth) {}
+	ExtVMFace(Address(), Address(), Address(), 0, 1, bytesConstRef(), bytes(), _previousBlock, _currentBlock, LastHashes(), _depth) {}
 
 h160 FakeExtVM::create(u256 _endowment, u256& io_gas, bytesConstRef _init, OnOpFunc const&)
 {