EIP96 - blockhash refactoring

libdevcrypto/Common.cpp

@@ -67,6 +67,8 @@ const Address dev::ZeroAddress = Address();
 
 const Address dev::MaxAddress = Address("0xffffffffffffffffffffffffffffffffffffffff");
 
+const Address dev::SystemAddress = Address("0xfffffffffffffffffffffffffffffffffffffffe");
+
 Public dev::toPublic(Secret const& _secret)
 {
 	auto* ctx = getCtx();

libdevcrypto/Common.h

@@ -67,6 +67,9 @@ extern const Address ZeroAddress;
 /// The last address.
 extern const Address MaxAddress;
 
+/// The SYSTEM address.
+extern const Address SystemAddress;
+
 /// A vector of Ethereum addresses.
 using Addresses = h160s;
 

libethashseal/GenesisInfo.cpp

@@ -30,6 +30,7 @@ using namespace dev;
 #include "genesis/eip150Test.cpp"
 #include "genesis/eip158Test.cpp"
 #include "genesis/metropolisTest.cpp"
+#include "genesis/metropolisTransitionTest.cpp"
 #include "genesis/transitionnetTest.cpp"
 
 std::string const& dev::eth::genesisInfo(Network _n)
@@ -45,6 +46,7 @@ std::string const& dev::eth::genesisInfo(Network _n)
 	case Network::EIP150Test: return c_genesisInfoEIP150Test;
 	case Network::EIP158Test: return c_genesisInfoEIP158Test;
 	case Network::MetropolisTest: return c_genesisInfoMetropolisTest;
+	case Network::MetropolisTransitionTest: return c_genesisInfoMetropolisTransitionTest;
 	default:
 		throw std::invalid_argument("Invalid network value");
 	}

libethashseal/GenesisInfo.h

@@ -44,6 +44,7 @@ enum class Network
 	EIP150Test = 73,		///< Homestead + EIP150 Rules active from block 0 For BlockchainTests
 	EIP158Test = 74,		///< Homestead + EIP150 + EIP158 Rules active from block 0
 	MetropolisTest = 75,   ///< All fork rules + Metropolis active from block 0
+	MetropolisTransitionTest = 76, ///< All fork rules + Metropolis active from block 2
 	Special = 0xff			///< Something else.
 };
 

libethashseal/genesis/metropolisTransitionTest.cpp

@@ -0,0 +1,63 @@
+/*
+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/>.
+*/
+#include "../GenesisInfo.h"
+
+static dev::h256 const c_genesisStateRootMetropolisTransitionTest;
+static std::string const c_genesisInfoMetropolisTransitionTest = std::string() +
+R"E(
+{
+	"sealEngine": "NoProof",
+	"params": {
+		"accountStartNonce": "0x00",
+		"maximumExtraDataSize": "0x20",
+		"homsteadForkBlock": "0x00",
+		"daoHardforkBlock": "0xfffffffffffffff",
+		"EIP150ForkBlock": "0x00",
+		"EIP158ForkBlock": "0x00",
+		"metropolisForkBlock": "0x02",
+		"minGasLimit": "0x1388",
+		"maxGasLimit": "7fffffffffffffff",
+		"tieBreakingGas": false,
+		"gasLimitBoundDivisor": "0x0400",
+		"minimumDifficulty": "0x020000",
+		"difficultyBoundDivisor": "0x0800",
+		"durationLimit": "0x0d",
+		"blockReward": "0x4563918244F40000",
+		"registrar" : "0xc6d9d2cd449a754c494264e1809c50e34d64562b",
+		"networkID" : "0x1",
+		"chainID": "0x01",
+		"allowFutureBlocks" : true
+	},
+	"genesis": {
+		"nonce": "0x0000000000000042",
+		"difficulty": "0x400000000",
+		"mixHash": "0x0000000000000000000000000000000000000000000000000000000000000000",
+		"author": "0x0000000000000000000000000000000000000000",
+		"timestamp": "0x00",
+		"parentHash": "0x0000000000000000000000000000000000000000000000000000000000000000",
+		"extraData": "0x11bbe8db4e347b4e8c937c1c8370e4b5ed33adb3db69cbdb7a38e1e50b1b82fa",
+		"gasLimit": "0x1388"
+	},
+	"accounts": {
+		"0000000000000000000000000000000000000001": { "wei": "1", "precompiled": { "name": "ecrecover", "linear": { "base": 3000, "word": 0 } } },
+		"0000000000000000000000000000000000000002": { "wei": "1", "precompiled": { "name": "sha256", "linear": { "base": 60, "word": 12 } } },
+		"0000000000000000000000000000000000000003": { "wei": "1", "precompiled": { "name": "ripemd160", "linear": { "base": 600, "word": 120 } } },
+		"0000000000000000000000000000000000000004": { "wei": "1", "precompiled": { "name": "identity", "linear": { "base": 15, "word": 3 } } },
+		"0000000000000000000000000000000000000005": { "wei": "1", "precompiled": { "name": "modexp" } }
+	}
+}
+)E";

libethcore/Common.cpp

@@ -53,6 +53,9 @@ const unsigned c_databaseVersionModifier = 0;
 
 const unsigned c_databaseVersion = c_databaseBaseVersion + (c_databaseVersionModifier << 8) + (23 << 9);
 
+const Address c_blockhashContractAddress(0xf0);
+const bytes c_blockhashContractCode(fromHex("0x73fffffffffffffffffffffffffffffffffffffffe33141561006a5760014303600035610100820755610100810715156100455760003561010061010083050761010001555b6201000081071515610064576000356101006201000083050761020001555b5061013e565b4360003512151561008457600060405260206040f361013d565b61010060003543031315156100a857610100600035075460605260206060f361013c565b6101006000350715156100c55762010000600035430313156100c8565b60005b156100ea576101006101006000350507610100015460805260206080f361013b565b620100006000350715156101095763010000006000354303131561010c565b60005b1561012f57610100620100006000350507610200015460a052602060a0f361013a565b600060c052602060c0f35b5b5b5b5b"));
+
 Address toAddress(std::string const& _s)
 {
 	try

libethcore/Common.h

@@ -43,6 +43,11 @@ extern const unsigned c_minorProtocolVersion;
 /// Current database version.
 extern const unsigned c_databaseVersion;
 
+/// Address of the special contract for block hash storage defined in EIP96
+extern const Address c_blockhashContractAddress;
+/// Code of the special contract for block hash storage defined in EIP96
+extern const bytes c_blockhashContractCode;
+
 /// User-friendly string representation of the amount _b in wei.
 std::string formatBalance(bigint const& _b);
 

libethereum/Block.cpp

@@ -128,6 +128,7 @@ void Block::resetCurrent(u256 const& _timestamp)
 	m_committedToSeal = false;
 
 	performIrregularModifications();
+	updateBlockhashContract();
 }
 
 SealEngineFace* Block::sealEngine() const
@@ -692,6 +693,30 @@ void Block::performIrregularModifications()
 	}
 }
 
+void Block::updateBlockhashContract()
+{
+	u256 const blockNumber = info().number();
+
+	u256 const metropolisForkBlock = m_sealEngine->chainParams().u256Param("metropolisForkBlock");
+	if (blockNumber == metropolisForkBlock)
+	{
+		m_state.createContract(c_blockhashContractAddress);
+		m_state.setNewCode(c_blockhashContractAddress, bytes(c_blockhashContractCode));
+		m_state.commit(State::CommitBehaviour::KeepEmptyAccounts);
+	}
+
+	if (blockNumber >= metropolisForkBlock)
+	{
+		Executive e(*this);
+		h256 const parentHash = m_previousBlock.hash();
+		if (!e.call(c_blockhashContractAddress, SystemAddress, 0, 0, parentHash.ref(), 1000000))
+			e.go();
+		e.finalize();
+
+		m_state.commit(State::CommitBehaviour::KeepEmptyAccounts);
+	}
+}
+
 void Block::commitToSeal(BlockChain const& _bc, bytes const& _extraData)
 {
 	if (isSealed())

libethereum/Block.h

@@ -307,6 +307,9 @@ class Block
 	/// Performs irregular modifications right after initialization, e.g. to implement a hard fork.
 	void performIrregularModifications();
 
+	/// Creates and updates the special contract for storing block hashes according to EIP96
+	void updateBlockhashContract();
+
 	/// Provide a standard VM trace for debugging purposes.
 	std::string vmTrace(bytesConstRef _block, BlockChain const& _bc, ImportRequirements::value _ir);
 

libethereum/ExtVM.cpp

@@ -134,3 +134,26 @@ void ExtVM::suicide(Address _a)
 	m_s.subBalance(myAddress, m_s.balance(myAddress));
 	ExtVMFace::suicide(_a);
 }
+
+h256 ExtVM::blockHash(u256 _number)
+{
+	u256 const currentNumber = envInfo().number();
+
+	if (_number >= currentNumber || _number < (std::max<u256>(256, currentNumber) - 256))
+		return h256();
+
+	if (currentNumber < m_sealEngine.chainParams().u256Param("metropolisForkBlock") + 256)
+	{
+		assert(envInfo().lastHashes().size() > (unsigned)(currentNumber - 1 - _number));
+		return envInfo().lastHashes()[(unsigned)(currentNumber - 1 - _number)];
+	}
+
+	u256 const nonce = m_s.getNonce(caller);
+	u256 const gas = 1000000;
+	Transaction tx(0, 0, gas, c_blockhashContractAddress, toBigEndian(_number), nonce);
+	tx.forceSender(caller);
+
+	ExecutionResult res;
+	std::tie(res, std::ignore) = m_s.execute(envInfo(), m_sealEngine, tx, Permanence::Reverted);
+	return h256(res.output);
+}

libethereum/ExtVM.h

@@ -91,6 +91,9 @@ class ExtVM: public ExtVMFace
 
 	State const& state() const { return m_s; }
 
+	/// Hash of a block if within the last 256 blocks, or h256() otherwise.
+	h256 blockHash(u256 _number) override;
+
 private:
 	State& m_s;  ///< A reference to the base state.
 	SealEngineFace const& m_sealEngine;

libevm/ExtVMFace.h

@@ -297,7 +297,7 @@ class ExtVMFace
 	virtual void log(h256s&& _topics, bytesConstRef _data) { sub.logs.push_back(LogEntry(myAddress, std::move(_topics), _data.toBytes())); }
 
 	/// Hash of a block if within the last 256 blocks, or h256() otherwise.
-	h256 blockHash(u256 _number) { return _number < envInfo().number() && _number >= (std::max<u256>(256, envInfo().number()) - 256) ? envInfo().lastHashes()[(unsigned)(envInfo().number() - 1 - _number)] : h256(); }
+	virtual h256 blockHash(u256 _number) = 0;
 
 	/// Get the execution environment information.
 	EnvInfo const& envInfo() const { return m_envInfo; }

libevm/VM.cpp

@@ -800,6 +800,7 @@ void VM::interpretCases()
 
 		CASE(BLOCKHASH)
 		{
+			m_runGas = toInt63(m_schedule->blockhashGas);
 			ON_OP();
 			updateIOGas();
 

libevmcore/EVMSchedule.h

@@ -73,6 +73,7 @@ struct EVMSchedule
 	unsigned extcodecopyGas = 20;
 	unsigned balanceGas = 20;
 	unsigned suicideGas = 0;
+	unsigned blockhashGas = 20;
 	unsigned maxCodeSize = unsigned(-1);
 
 	bool staticCallDepthLimit() const { return !eip150Mode; }
@@ -110,6 +111,7 @@ static const EVMSchedule EIP158Schedule = []
 static const EVMSchedule MetropolisSchedule = []
 {
 	EVMSchedule schedule = EIP158Schedule;
+	schedule.blockhashGas = 800;
 	schedule.haveRevert = true;
 	schedule.haveReturnData = true;
 	schedule.haveStaticCall = true;

libevmcore/Instruction.cpp

@@ -70,7 +70,7 @@ static const std::map<Instruction,  InstructionInfo> c_instructionInfo =
 	{ Instruction::EXTCODECOPY,  { "EXTCODECOPY",    0,     4,    0,  true,        Tier::Special } },
 	{ Instruction::RETURNDATASIZE,{"RETURNDATASIZE", 0,     0,    1,  false,       Tier::Base } },
 	{ Instruction::RETURNDATACOPY,{"RETURNDATACOPY", 0,     3,    0,  true,        Tier::VeryLow } },
-	{ Instruction::BLOCKHASH,    { "BLOCKHASH",      0,     1,    1,  false,       Tier::Ext } },
+	{ Instruction::BLOCKHASH,    { "BLOCKHASH",      0,     1,    1,  false,       Tier::Special } },
 	{ Instruction::COINBASE,     { "COINBASE",       0,     0,    1,  false,       Tier::Base } },
 	{ Instruction::TIMESTAMP,    { "TIMESTAMP",      0,     0,    1,  false,       Tier::Base } },
 	{ Instruction::NUMBER,       { "NUMBER",         0,     0,    1,  false,       Tier::Base } },

test/tools/jsontests/vm.cpp

@@ -53,6 +53,15 @@ std::pair<bool, eth::owning_bytes_ref> FakeExtVM::call(CallParameters& _p)
 	return {true, eth::owning_bytes_ref{}};  // Return empty output.
 }
 
+h256 FakeExtVM::blockHash(u256 _number)
+{
+	cnote << "Warning: using fake blockhash code!\n";
+	if (_number < envInfo().number() && _number >= (std::max<u256>(256, envInfo().number()) - 256))
+		return sha3(toString(_number));
+
+	return h256();
+}
+
 void FakeExtVM::set(Address _a, u256 _myBalance, u256 _myNonce, map<u256, u256> const& _storage, bytes const& _code)
 {
 	get<0>(addresses[_a]) = _myBalance;
@@ -96,7 +105,6 @@ EnvInfo FakeExtVM::importEnv(mObject& _o)
 	info.setTimestamp(toInt(_o["currentTimestamp"]));
 	info.setAuthor(Address(_o["currentCoinbase"].get_str()));
 	info.setNumber(toInt(_o["currentNumber"]));
-	info.setLastHashes( lastHashes( info.number() ) );
 	return info;
 }
 

test/tools/jsontests/vm.h

@@ -56,6 +56,7 @@ class FakeExtVM: public eth::ExtVMFace
 	virtual size_t codeSizeAt(Address _a) override { return std::get<3>(addresses[_a]).size(); }
 	virtual std::pair<h160, eth::owning_bytes_ref> create(u256 _endowment, u256& io_gas, bytesConstRef _init, eth::OnOpFunc const&) override;
 	virtual std::pair<bool, eth::owning_bytes_ref> call(eth::CallParameters&) override;
+	virtual h256 blockHash(u256 _number) override;
 	void setTransaction(Address _caller, u256 _value, u256 _gasPrice, bytes const& _data);
 	void setContract(Address _myAddress, u256 _myBalance, u256 _myNonce, std::map<u256, u256> const& _storage, bytes const& _code);
 	void set(Address _a, u256 _myBalance, u256 _myNonce, std::map<u256, u256> const& _storage, bytes const& _code);

test/tools/libtesteth/BlockChainHelper.h

@@ -136,4 +136,11 @@ class TestBlockChain
 	std::unique_ptr<TransientDirectory> m_tempDirBlockchain;
 };
 
+class NetworkSelector
+{
+public:
+	explicit NetworkSelector(Network _network) { TestBlockChain::s_sealEngineNetwork = _network; }
+	~NetworkSelector() { TestBlockChain::s_sealEngineNetwork = Network::FrontierTest; } // reset to default
+};
+
 }}

test/tools/libtesteth/ImportTest.cpp

@@ -29,6 +29,17 @@ using namespace dev;
 using namespace dev::test;
 using namespace std;
 
+namespace
+{
+LastHashes lastHashes(u256 _currentBlockNumber)
+{
+	LastHashes ret;
+	for (u256 i = 1; i <= 256 && i <= _currentBlockNumber; ++i)
+		ret.push_back(sha3(toString(_currentBlockNumber - i)));
+	return ret;
+}
+}
+
 ImportTest::ImportTest(json_spirit::mObject& _o, bool isFiller, testType testTemplate):
 	m_statePre(0, OverlayDB(), eth::BaseState::Empty),
 	m_statePost(0, OverlayDB(), eth::BaseState::Empty),
@@ -135,7 +146,7 @@ bytes ImportTest::executeTest()
 							json_spirit::mObject obj = fillJsonWithState(search2->second.first, search2->second.second);
 							for (auto& adr: obj)
 							{
-								if (adr.first == toString(m_envInfo.author()))
+								if (adr.first == "0x" + toString(m_envInfo.author()))
 								{
 									if (adr.second.get_obj().count("balance"))
 									{
@@ -279,6 +290,7 @@ void ImportTest::importEnv(json_spirit::mObject& _o)
 	m_envInfo.setNumber(toInt(_o["currentNumber"]));
 	m_envInfo.setTimestamp(toInt(_o["currentTimestamp"]));
 	m_envInfo.setAuthor(Address(_o["currentCoinbase"].get_str()));
+
 	m_envInfo.setLastHashes( lastHashes( m_envInfo.number() ) );
 }
 

test/tools/libtesteth/TestHelper.cpp

@@ -494,14 +494,6 @@ RLPStream createRLPStreamFromTransactionFields(json_spirit::mObject const& _tObj
 }
 
 
-LastHashes lastHashes(u256 _currentBlockNumber)
-{
-	LastHashes ret;
-	for (u256 i = 1; i <= 256 && i <= _currentBlockNumber; ++i)
-		ret.push_back(sha3(toString(_currentBlockNumber - i)));
-	return ret;
-}
-
 dev::eth::BlockHeader constructHeader(
 	h256 const& _parentHash,
 	h256 const& _sha3Uncles,

test/tools/libtesteth/TestHelper.h

@@ -155,7 +155,6 @@ void updateEthashSeal(dev::eth::BlockHeader& _header, h256 const& _mixHash, dev:
 void executeTests(const std::string& _name, const std::string& _testPathAppendix, const std::string& _fillerPathAppendix, std::function<void(json_spirit::mValue&, bool)> doTests, bool _addFillerSuffix = true);
 void userDefinedTest(std::function<void(json_spirit::mValue&, bool)> doTests);
 RLPStream createRLPStreamFromTransactionFields(json_spirit::mObject const& _tObj);
-eth::LastHashes lastHashes(u256 _currentBlockNumber);
 json_spirit::mObject fillJsonWithStateChange(eth::State const& _stateOrig, eth::State const& _statePost, eth::ChangeLog const& _changeLog);
 json_spirit::mObject fillJsonWithState(eth::State const& _state);
 json_spirit::mObject fillJsonWithState(eth::State const& _state, eth::AccountMaskMap const& _map);