Restructure state tests. Remove FakeStateClass

TestHelper.cpp

@@ -24,6 +24,9 @@
 #include <thread>
 #include <chrono>
 #include <libethereum/Client.h>
+#include <liblll/Compiler.h>
+
+using namespace std;
 
 namespace dev
 {
@@ -54,5 +57,193 @@ void connectClients(Client& c1, Client& c2)
 #endif
 }
 
+namespace test
+{
+
+ImportTest::ImportTest(json_spirit::mObject& _o, bool isFiller)
+{
+	importEnv(_o["env"].get_obj());
+	importState(_o["pre"].get_obj(), m_statePre);
+	importExec(_o["exec"].get_obj());
+
+	if (!isFiller)
+	{
+		importState(_o["post"].get_obj(), m_statePost);
+		importCallCreates(_o["callcreates"].get_array());
+		importGas(_o);
+		importOutput(_o);
+	}
 }
+
+void ImportTest::importEnv(json_spirit::mObject& _o)
+{
+	assert(_o.count("previousHash") > 0);
+	assert(_o.count("currentGasLimit") > 0);
+	assert(_o.count("currentDifficulty") > 0);
+	assert(_o.count("currentTimestamp") > 0);
+	assert(_o.count("currentCoinbase") > 0);
+	assert(_o.count("currentNumber") > 0);
+
+	m_environment.previousBlock.hash = h256(_o["previousHash"].get_str());
+	m_environment.currentBlock.number = toInt(_o["currentNumber"]);
+	m_environment.currentBlock.gasLimit = toInt(_o["currentGasLimit"]);
+	m_environment.currentBlock.difficulty = toInt(_o["currentDifficulty"]);
+	m_environment.currentBlock.timestamp = toInt(_o["currentTimestamp"]);
+	m_environment.currentBlock.coinbaseAddress = Address(_o["currentCoinbase"].get_str());
 }
+
+void ImportTest::importState(json_spirit::mObject& _o, State& _state)
+{
+	for (auto const& i: _o)
+	{
+		json_spirit::mObject o = i.second.get_obj();
+
+		assert(o.count("balance") > 0);
+		assert(o.count("nonce") > 0);
+		assert(o.count("storage") > 0);
+		assert(o.count("code") > 0);
+
+		Address address = Address(i.first);
+		cout << "address: " << address.abridged() << endl;
+
+		_state.m_cache[address] = AddressState(toInt(o["nonce"]), toInt(o["balance"]), h256(), h256());
+
+		cout << "addressInUse: " << _state.addressInUse(address) << endl;
+		cout << "balance: " << _state.balance(address) << endl;
+
+		for (auto const& j: o["storage"].get_obj())
+			_state.setStorage(address, toInt(j.first), toInt(j.second));
+
+		bytes code;
+		if (o["code"].type() == json_spirit::str_type)
+			if (o["code"].get_str().find_first_of("0x") != 0)
+				code = compileLLL(o["code"].get_str(), false);
+			else
+				code = fromHex(o["code"].get_str().substr(2));
+		else
+		{
+			code.clear();
+			for (auto const& j: o["code"].get_array())
+				code.push_back(toByte(j));
+		}
+
+		_state.m_cache[address].setCode(bytesConstRef(&code));
+		_state.ensureCached(address, true, true);
+	}
+}
+
+void ImportTest::importExec(json_spirit::mObject& _o)
+{
+	assert(_o.count("address")> 0);
+	assert(_o.count("caller") > 0);
+	assert(_o.count("origin") > 0);
+	assert(_o.count("value") > 0);
+	assert(_o.count("data") > 0);
+	assert(_o.count("gasPrice") > 0);
+	assert(_o.count("gas") > 0);
+	assert(_o.count("code") > 0);
+
+	m_environment.myAddress = Address(_o["address"].get_str());
+	m_environment.caller = Address(_o["caller"].get_str());
+	m_environment.origin = Address(_o["origin"].get_str());
+	m_environment.value = toInt(_o["value"]);
+	m_environment.gasPrice = toInt(_o["gasPrice"]);
+	gasExec = toInt(_o["gas"]);
+
+	if (_o["code"].type() == json_spirit::str_type)
+		if (_o["code"].get_str().find_first_of("0x") == 0)
+			code = fromHex(_o["code"].get_str().substr(2));
+		else
+			code = compileLLL(_o["code"].get_str());
+	else if (_o["code"].type() == json_spirit::array_type)
+		for (auto const& j: _o["code"].get_array())
+			code.push_back(toByte(j));
+	else
+		m_environment.code.reset();
+	m_environment.code = &code;
+
+	if (_o["data"].type() == json_spirit::str_type)
+		if (_o["data"].get_str().find_first_of("0x") == 0)
+			data = fromHex(_o["data"].get_str().substr(2));
+		else
+			data = fromHex(_o["data"].get_str());
+	else
+		for (auto const& j: _o["data"].get_array())
+			data.push_back(toByte(j));
+	m_environment.data = &data;
+}
+
+void ImportTest::importCallCreates(json_spirit::mArray& _callcreates)
+{
+	for (json_spirit::mValue& v: _callcreates)
+	{
+		auto tx = v.get_obj();
+		assert(tx.count("data") > 0);
+		assert(tx.count("value") > 0);
+		assert(tx.count("destination") > 0);
+		assert(tx.count("gasLimit") > 0);
+		Transaction t;
+		t.type = tx["destination"].get_str().empty() ? Transaction::ContractCreation : Transaction::MessageCall;
+		t.receiveAddress = Address(tx["destination"].get_str());
+		t.value = toInt(tx["value"]);
+		t.gas = toInt(tx["gasLimit"]);
+		if (tx["data"].type() == json_spirit::str_type)
+			if (tx["data"].get_str().find_first_of("0x") == 0)
+				t.data = fromHex(tx["data"].get_str().substr(2));
+			else
+				t.data = fromHex(tx["data"].get_str());
+		else
+			for (auto const& j: tx["data"].get_array())
+				t.data.push_back(toByte(j));
+		callcreates.push_back(t);
+	}
+}
+
+void ImportTest::importGas(json_spirit::mObject& _o)
+{
+	gas = toInt(_o["gas"]);
+}
+
+void ImportTest::importOutput(json_spirit::mObject& _o)
+{
+	int i = 0;
+	if (_o["out"].type() == json_spirit::array_type)
+		for (auto const& d: _o["out"].get_array())
+		{
+			output[i] = uint8_t(toInt(d));
+			++i;
+		}
+	else if (_o["out"].get_str().find("0x") == 0)
+		output = fromHex(_o["out"].get_str().substr(2));
+	else
+		output = fromHex(_o["out"].get_str());
+}
+
+u256 toInt(json_spirit::mValue const& _v)
+{
+	switch (_v.type())
+	{
+	case json_spirit::str_type: return u256(_v.get_str());
+	case json_spirit::int_type: return (u256)_v.get_uint64();
+	case json_spirit::bool_type: return (u256)(uint64_t)_v.get_bool();
+	case json_spirit::real_type: return (u256)(uint64_t)_v.get_real();
+	default: cwarn << "Bad type for scalar: " << _v.type();
+	}
+	return 0;
+}
+
+byte toByte(json_spirit::mValue const& _v)
+{
+	switch (_v.type())
+	{
+	case json_spirit::str_type: return (byte)stoi(_v.get_str());
+	case json_spirit::int_type: return (byte)_v.get_uint64();
+	case json_spirit::bool_type: return (byte)_v.get_bool();
+	case json_spirit::real_type: return (byte)_v.get_real();
+	default: cwarn << "Bad type for scalar: " << _v.type();
+	}
+	return 0;
+}
+
+
+} } } // namespaces

TestHelper.h

@@ -21,6 +21,9 @@
 
 #pragma once
 
+#include "JsonSpiritHeaders.h"
+#include <libethereum/State.h>
+
 namespace dev
 {
 namespace eth
@@ -31,5 +34,46 @@ class Client;
 void mine(Client& c, int numBlocks);
 void connectClients(Client& c1, Client& c2);
 
+namespace test
+{
+
+class ImportTest
+{
+public:
+	ImportTest() = default;
+	ImportTest(json_spirit::mObject& _o, bool isFiller);
+
+	// imports
+	void importEnv(json_spirit::mObject& _o);
+	void importState(json_spirit::mObject& _o, State& _state);
+	void importExec(json_spirit::mObject& _o);
+	void importCallCreates(json_spirit::mArray& _callcreates);
+	void importGas(json_spirit::mObject& _o);
+	void importOutput(json_spirit::mObject& _o);
+
+	void exportTest();
+	Manifest* getManifest(){ return &m_manifest;}
+
+	State m_statePre;
+	State m_statePost;
+	ExtVMFace m_environment;
+	u256 gas;
+	u256 gasExec;
+	Transactions callcreates;
+	bytes output;
+	Manifest m_manifest;
+
+private:
+	// needed for const refs
+	bytes code;
+	bytes data;
+};
+
+// helping functions
+
+u256 toInt(json_spirit::mValue const& _v);
+byte toByte(json_spirit::mValue const& _v);
+
+}
 }
 }

state.cpp

@@ -15,81 +15,219 @@
 	along with cpp-ethereum.  If not, see <http://www.gnu.org/licenses/>.
 */
 /** @file state.cpp
- * @author Gav Wood <i@gavwood.com>
+ * @author Christoph Jentzsch <cj@ethdev.com>
  * @date 2014
  * State test functions.
  */
 
 #include <boost/filesystem/operations.hpp>
-#include <secp256k1/secp256k1.h>
+#include <boost/test/unit_test.hpp>
+#include "JsonSpiritHeaders.h"
+#include <libdevcore/CommonIO.h>
 #include <libethereum/BlockChain.h>
 #include <libethereum/State.h>
+#include <libethereum/ExtVM.h>
 #include <libethereum/Defaults.h>
+#include <libevm/VM.h>
+#include "TestHelper.h"
+
 using namespace std;
+using namespace json_spirit;
 using namespace dev;
 using namespace dev::eth;
+using namespace dev::eth::test;
 
-int stateTest()
+class FakeState: public State
 {
-	cnote << "Testing State...";
 
-	KeyPair me = sha3("Gav Wood");
+};
-	KeyPair myMiner = sha3("Gav's Miner");
-//	KeyPair you = sha3("123");
 
-	Defaults::setDBPath(boost::filesystem::temp_directory_path().string());
 
-	OverlayDB stateDB = State::openDB();
+namespace dev { namespace eth{ namespace test {
-	BlockChain bc;
-	State s(myMiner.address(), stateDB);
 
-	cout << bc;
 
-	// Sync up - this won't do much until we use the last state.
-	s.sync(bc);
 
-	cout << s;
+void doStateTests(json_spirit::mValue& v, bool _fillin)
-
+{
-	// Mine to get some ether!
+	for (auto& i: v.get_obj())
-	s.commitToMine(bc);
-	while (!s.mine(100).completed) {}
-	s.completeMine();
-	bc.attemptImport(s.blockData(), stateDB);
-
-	cout << bc;
-
-	s.sync(bc);
-
-	cout << s;
-
-	// Inject a transaction to transfer funds from miner to me.
-	bytes tx;
 	{
-		Transaction t;
+		cnote << i.first;
-		t.nonce = s.transactionsFrom(myMiner.address());
+		mObject& o = i.second.get_obj();
-		t.value = 1000;			// 1e3 wei.
+
-		t.type = eth::Transaction::MessageCall;
+		BOOST_REQUIRE(o.count("env") > 0);
-		t.receiveAddress = me.address();
+		BOOST_REQUIRE(o.count("pre") > 0);
-		t.sign(myMiner.secret());
+		BOOST_REQUIRE(o.count("exec") > 0);
-		assert(t.sender() == myMiner.address());
+
-		tx = t.rlp();
+		ImportTest importer(o,false);
+
+		ExtVM evm(importer.m_statePre, importer.m_environment.myAddress,
+				  importer.m_environment.caller, importer.m_environment.origin,
+				  importer.m_environment.value, importer.m_environment.gasPrice,
+				  importer.m_environment.data, importer.m_environment.code,
+				  importer.getManifest());
+
+		bytes output;
+		VM vm(importer.gasExec);
+		try
+		{
+			output = vm.go(evm, Executive::simpleTrace()).toVector();
+		}
+		catch (Exception const& _e)
+		{
+			cnote << "VM did throw an exception: " << diagnostic_information(_e);
+			//BOOST_ERROR("Failed VM Test with Exception: " << e.what());
+		}
+		catch (std::exception const& _e)
+		{
+			cnote << "VM did throw an exception: " << _e.what();
+			//BOOST_ERROR("Failed VM Test with Exception: " << e.what());
+		}
+
+		BOOST_REQUIRE(o.count("post") > 0);
+		BOOST_REQUIRE(o.count("callcreates") > 0);
+		BOOST_REQUIRE(o.count("out") > 0);
+		BOOST_REQUIRE(o.count("gas") > 0);
+
+
+		// check output
+
+
+		//dev::test::FakeExtVM test;
+		//test.importState(o["post"].get_obj());
+		//test.importCallCreates(o["callcreates"].get_array());
+
+		int j = 0;
+		if (o["out"].type() == array_type)
+			for (auto const& d: o["out"].get_array())
+			{
+				BOOST_CHECK_MESSAGE(output[j] == toInt(d), "Output byte [" << j << "] different!");
+				++j;
+			}
+		else if (o["out"].get_str().find("0x") == 0)
+			BOOST_CHECK(output == fromHex(o["out"].get_str().substr(2)));
+		else
+			BOOST_CHECK(output == fromHex(o["out"].get_str()));
+
+		cout << "gas check: " << importer.gas << " " << toInt(o["gas"]) << " " << vm.gas() << endl;
+		BOOST_CHECK_EQUAL(toInt(o["gas"]), vm.gas());
+
+//		auto& expectedAddrs = test.addresses;
+//		auto& resultAddrs = fev.addresses;
+//		for (auto&& expectedPair : expectedAddrs)
+//		{
+//			auto& expectedAddr = expectedPair.first;
+//			auto resultAddrIt = resultAddrs.find(expectedAddr);
+//			if (resultAddrIt == resultAddrs.end())
+//				BOOST_ERROR("Missing expected address " << expectedAddr);
+//			else
+//			{
+//				auto& expectedState = expectedPair.second;
+//				auto& resultState = resultAddrIt->second;
+//				BOOST_CHECK_MESSAGE(std::get<0>(expectedState) == std::get<0>(resultState), expectedAddr << ": incorrect balance " << std::get<0>(resultState) << ", expected " << std::get<0>(expectedState));
+//				BOOST_CHECK_MESSAGE(std::get<1>(expectedState) == std::get<1>(resultState), expectedAddr << ": incorrect txCount " << std::get<1>(resultState) << ", expected " << std::get<1>(expectedState));
+//				BOOST_CHECK_MESSAGE(std::get<3>(expectedState) == std::get<3>(resultState), expectedAddr << ": incorrect code");
+
+//				auto&& expectedStore = std::get<2>(expectedState);
+//				auto&& resultStore = std::get<2>(resultState);
+
+//				for (auto&& expectedStorePair : expectedStore)
+//				{
+//					auto& expectedStoreKey = expectedStorePair.first;
+//					auto resultStoreIt = resultStore.find(expectedStoreKey);
+//					if (resultStoreIt == resultStore.end())
+//						BOOST_ERROR(expectedAddr << ": missing store key " << expectedStoreKey);
+//					else
+//					{
+//						auto& expectedStoreValue = expectedStorePair.second;
+//						auto& resultStoreValue = resultStoreIt->second;
+//						BOOST_CHECK_MESSAGE(expectedStoreValue == resultStoreValue, expectedAddr << ": store[" << expectedStoreKey << "] = " << resultStoreValue << ", expected " << expectedStoreValue);
+//					}
+//				}
+//			}
+//		}
+
+		BOOST_CHECK(evm.state().addresses() == importer.m_statePost.addresses());	// Just to make sure nothing missed
+		//BOOST_CHECK(evm.callcreates == importer.callcreates);
+
 	}
-	s.execute(tx);
-
-	cout << s;
-
-	// Mine to get some ether and set in stone.
-	s.commitToMine(bc);
-	while (!s.mine(100).completed) {}
-	s.completeMine();
-	bc.attemptImport(s.blockData(), stateDB);
-
-	cout << bc;
-
-	s.sync(bc);
-
-	cout << s;
-
-	return 0;
 }
 
+
+void executeStateTests(const string& _name)
+{
+	const char* ptestPath = getenv("ETHEREUM_TEST_PATH");
+	string testPath;
+
+	if (ptestPath == NULL)
+	{
+		cnote << " could not find environment variable ETHEREUM_TEST_PATH \n";
+		testPath = "../../../tests";
+	}
+	else
+		testPath = ptestPath;
+
+	testPath += "/vmtests";
+
+#ifdef FILL_TESTS
+	try
+	{
+		cnote << "Populating VM tests...";
+		json_spirit::mValue v;
+		boost::filesystem::path p(__FILE__);
+		boost::filesystem::path dir = p.parent_path();
+		string s = asString(dev::contents(dir.string() + "/" + _name + "Filler.json"));
+		BOOST_REQUIRE_MESSAGE(s.length() > 0, "Contents of " + _name + "Filler.json is empty.");
+		json_spirit::read_string(s, v);
+		dev::test::doStateTests(v, true);
+		writeFile(testPath + "/" + _name + ".json", asBytes(json_spirit::write_string(v, true)));
+	}
+	catch (Exception const& _e)
+	{
+		BOOST_ERROR("Failed VM Test with Exception: " << diagnostic_information(_e));
+	}
+	catch (std::exception const& _e)
+	{
+		BOOST_ERROR("Failed VM Test with Exception: " << _e.what());
+	}
+#endif
+
+	try
+	{
+		cnote << "Testing VM..." << _name;
+		json_spirit::mValue v;
+		string s = asString(dev::contents(testPath + "/" + _name + ".json"));
+		BOOST_REQUIRE_MESSAGE(s.length() > 0, "Contents of " + testPath + "/" + _name + ".json is empty. Have you cloned the 'tests' repo branch develop and set ETHEREUM_TEST_PATH to its path?");
+		json_spirit::read_string(s, v);
+		doStateTests(v, false);
+	}
+	catch (Exception const& _e)
+	{
+		BOOST_ERROR("Failed VM Test with Exception: " << diagnostic_information(_e));
+	}
+	catch (std::exception const& _e)
+	{
+		BOOST_ERROR("Failed VM Test with Exception: " << _e.what());
+	}
+
+}
+} } }// Namespace Close
+
+
+BOOST_AUTO_TEST_CASE(vmSystemOperationsTest)
+{
+	std::cout << "Doing systemoperationsTest in state\n";
+	int currentVerbosity = g_logVerbosity;
+	g_logVerbosity = 12;
+	dev::eth::test::executeStateTests("vmSystemOperationsTest");
+	g_logVerbosity = currentVerbosity;
+}
+
+//BOOST_AUTO_TEST_CASE(tmp)
+//{
+//	std::cout << "Doing systemoperationsTest in state\n";
+//	int currentVerbosity = g_logVerbosity;
+//	g_logVerbosity = 12;
+//	dev::eth::test::executeStateTests("tmp");
+//	g_logVerbosity = currentVerbosity;
+//}
+

stateOriginal.cpp

@@ -0,0 +1,95 @@
+/*
+	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 stateOriginal.cpp
+ * @author Gav Wood <i@gavwood.com>
+ * @date 2014
+ * State test functions.
+ */
+
+#include <boost/filesystem/operations.hpp>
+#include <secp256k1/secp256k1.h>
+#include <libethereum/BlockChain.h>
+#include <libethereum/State.h>
+#include <libethereum/Defaults.h>
+using namespace std;
+using namespace dev;
+using namespace dev::eth;
+
+int stateTest()
+{
+	cnote << "Testing State...";
+
+	KeyPair me = sha3("Gav Wood");
+	KeyPair myMiner = sha3("Gav's Miner");
+//	KeyPair you = sha3("123");
+
+	Defaults::setDBPath(boost::filesystem::temp_directory_path().string());
+
+	OverlayDB stateDB = State::openDB();
+	BlockChain bc;
+	State s(myMiner.address(), stateDB);
+
+	cout << bc;
+
+	// Sync up - this won't do much until we use the last state.
+	s.sync(bc);
+
+	cout << s;
+
+	// Mine to get some ether!
+	s.commitToMine(bc);
+	while (!s.mine(100).completed) {}
+	s.completeMine();
+	bc.attemptImport(s.blockData(), stateDB);
+
+	cout << bc;
+
+	s.sync(bc);
+
+	cout << s;
+
+	// Inject a transaction to transfer funds from miner to me.
+	bytes tx;
+	{
+		Transaction t;
+		t.nonce = s.transactionsFrom(myMiner.address());
+		t.value = 1000;			// 1e3 wei.
+		t.type = eth::Transaction::MessageCall;
+		t.receiveAddress = me.address();
+		t.sign(myMiner.secret());
+		assert(t.sender() == myMiner.address());
+		tx = t.rlp();
+	}
+	s.execute(tx);
+
+	cout << s;
+
+	// Mine to get some ether and set in stone.
+	s.commitToMine(bc);
+	while (!s.mine(100).completed) {}
+	s.completeMine();
+	bc.attemptImport(s.blockData(), stateDB);
+
+	cout << bc;
+
+	s.sync(bc);
+
+	cout << s;
+
+	return 0;
+}
+

vm.cpp

@@ -36,33 +36,35 @@ FakeExtVM::FakeExtVM(eth::BlockInfo const& _previousBlock, eth::BlockInfo const&
 
 h160 FakeExtVM::create(u256 _endowment, u256* _gas, bytesConstRef _init, OnOpFunc const&)
 {
+	Address na = right160(sha3(rlpList(myAddress, get<1>(addresses[myAddress]))));
+
 	Transaction t;
 	t.value = _endowment;
 	t.gasPrice = gasPrice;
 	t.gas = *_gas;
 	t.data = _init.toBytes();
 
-	m_s.noteSending(myAddress);
+//	m_s.noteSending(myAddress);
-	m_ms.internal.resize(m_ms.internal.size() + 1);
+//	m_ms.internal.resize(m_ms.internal.size() + 1);
-	auto ret = m_s.create(myAddress, _endowment, gasPrice, _gas, _init, origin, &sub, &m_ms ? &(m_ms.internal.back()) : nullptr, {}, 1);
+//	auto ret = m_s.create(myAddress, _endowment, gasPrice, _gas, _init, origin, &sub, &m_ms ? &(m_ms.internal.back()) : nullptr, {}, 1);
-	if (!m_ms.internal.back().from)
+//	if (!m_ms.internal.back().from)
-		m_ms.internal.pop_back();
+//		m_ms.internal.pop_back();
 
-	if (get<0>(addresses[myAddress]) >= _endowment)
+//	if (get<0>(addresses[myAddress]) >= _endowment)
-	{
+//	{
-		get<1>(addresses[myAddress])++;
+//		get<1>(addresses[myAddress])++;
-		get<0>(addresses[ret]) = _endowment;
+//		get<0>(addresses[ret]) = _endowment;
-		get<3>(addresses[ret]) = m_s.code(ret);
+//		//get<3>(addresses[ret]) = m_s.code(ret);
-	}
+//	}
 
 	t.type = eth::Transaction::ContractCreation;
 	callcreates.push_back(t);
-	return ret;
+	return na;
 }
 
 bool FakeExtVM::call(Address _receiveAddress, u256 _value, bytesConstRef _data, u256* _gas, bytesRef _out, OnOpFunc const&, Address _myAddressOverride, Address _codeAddressOverride)
 {
-	u256 contractgas = 0xffff;
+//	u256 contractgas = 0xffff;
 
 	Transaction t;
 	t.value = _value;
@@ -72,101 +74,103 @@ bool FakeExtVM::call(Address _receiveAddress, u256 _value, bytesConstRef _data,
 	t.type = eth::Transaction::MessageCall;
 	t.receiveAddress = _receiveAddress;
 	callcreates.push_back(t);
-
+	(void)_out;
-	string codeOf_CodeAddress = _codeAddressOverride ? toHex(get<3>(addresses[_codeAddressOverride])) : toHex(get<3>(addresses[_receiveAddress]) );
-	string sizeOfCode = toHex(toCompactBigEndian((codeOf_CodeAddress.size()+1)/2));
-
-	string codeOf_SenderAddress = toHex(get<3>(addresses[myAddress]) );
-	string sizeOfSenderCode = toHex(toCompactBigEndian((codeOf_SenderAddress.size()+1)/2));
-
-	if (codeOf_SenderAddress.size())
-	{
-		// create init code that returns given contract code
-		string initStringHex = "{ (CODECOPY 0 (- (CODESIZE) 0x" + sizeOfSenderCode + "  ) 0x" + sizeOfSenderCode + ") (RETURN 0 0x" + sizeOfSenderCode +")}";
-		bytes initBytes = compileLLL(initStringHex, true, NULL);
-		initBytes += fromHex(codeOf_SenderAddress);
-		bytesConstRef init(&initBytes);
-
-		if (!m_s.addresses().count(myAddress))
-		{
-			m_ms.internal.resize(m_ms.internal.size() + 1);
-			auto na = m_s.createNewAddress(myAddress, myAddress, balance(myAddress), gasPrice, &contractgas, init, origin, &sub, &m_ms ? &(m_ms.internal.back()) : nullptr, {}, 1);
-			if (!m_ms.internal.back().from)
-				m_ms.internal.pop_back();
-			if (na != myAddress)
-			{
-				cnote << "not able to call to : " << myAddress << "\n";
-				cnote << "in FakeExtVM you can only make a call to " << na << "\n";
-				BOOST_THROW_EXCEPTION(FakeExtVMFailure() << errinfo_comment("Address not callable in FakeExtVM\n") << errinfo_wrongAddress(toString(myAddress)));
-				return false;
-			}
-		}
-	}
-
-	if (codeOf_CodeAddress.size())
-	{
-		// create init code that returns given contract code
-		string initStringHex = "{ (CODECOPY 0 (- (CODESIZE) 0x" + sizeOfCode + "  ) 0x" + sizeOfCode + ") (RETURN 0 0x" + sizeOfCode +")}";
-		bytes initBytes = compileLLL(initStringHex, true, NULL);
-		initBytes += fromHex(codeOf_CodeAddress);
-		bytesConstRef init(&initBytes);
-
-		if (!m_s.addresses().count(_codeAddressOverride ? _codeAddressOverride : _receiveAddress))
-		{
-			m_s.noteSending(myAddress);
-			m_ms.internal.resize(m_ms.internal.size() + 1);
-			auto na = m_s.createNewAddress(_codeAddressOverride ? _codeAddressOverride : _receiveAddress, myAddress, balance(_codeAddressOverride ? _codeAddressOverride : _receiveAddress), gasPrice, &contractgas, init, origin, &sub, &m_ms ? &(m_ms.internal.back()) : nullptr, OnOpFunc(), 1);
-			if (!m_ms.internal.back().from)
-				m_ms.internal.pop_back();
-
-			if (na != (_codeAddressOverride ? _codeAddressOverride : _receiveAddress))
-			{
-				cnote << "not able to call to : " << (_codeAddressOverride ? _codeAddressOverride : _receiveAddress) << "\n";
-				cnote << "in FakeExtVM you can only make a call to " << na << "\n";
-				BOOST_THROW_EXCEPTION(FakeExtVMFailure() << errinfo_comment("Address not callable in FakeExtVM\n") << errinfo_wrongAddress(toString(_codeAddressOverride ? _codeAddressOverride : _receiveAddress)));
-				return false;
-			}
-		}
-
-		m_ms.internal.resize(m_ms.internal.size() + 1);
-
-		auto ret = m_s.call(_receiveAddress,_codeAddressOverride ? _codeAddressOverride : _receiveAddress, _myAddressOverride ? _myAddressOverride : myAddress, _value, gasPrice, _data, _gas, _out, origin, &sub, &(m_ms.internal.back()), Executive::simpleTrace(), 1);
-
-		if (!m_ms.internal.back().from)
-			m_ms.internal.pop_back();
-
-		// get correct balances, (also for sucicides in the call function)
-		for (auto const& f: addresses)
-		{
-			if (m_s.addressInUse(f.first))
-				get<0>(addresses[f.first]) = m_s.balance(f.first);
-		}
-
-		if (!ret)
-			return false;
-
-		// TODO: @CJentzsch refund SSTORE stuff.
-		// TODO: @CJentzsch test logs.
-
-		// do suicides
-		for (auto const& f: sub.suicides)
-			addresses.erase(f);
-
-		// get storage
-		if ((get<0>(addresses[myAddress]) >= _value) && (sub.suicides.find(_receiveAddress) == sub.suicides.end()))
-		{
-			for (auto const& j: m_s.storage(_receiveAddress))
-			{
-				u256 adr(j.first);
-				if ((j.second != 0) )
-					get<2>(addresses[_receiveAddress])[adr] = j.second;
-			}
-		}
-	}
-	else
-		addresses.erase(_receiveAddress); // for the sake of comparison
-
 	return true;
+
+//	string codeOf_CodeAddress = _codeAddressOverride ? toHex(get<3>(addresses[_codeAddressOverride])) : toHex(get<3>(addresses[_receiveAddress]) );
+//	string sizeOfCode = toHex(toCompactBigEndian((codeOf_CodeAddress.size()+1)/2));
+
+//	string codeOf_SenderAddress = toHex(get<3>(addresses[myAddress]) );
+//	string sizeOfSenderCode = toHex(toCompactBigEndian((codeOf_SenderAddress.size()+1)/2));
+
+//	if (codeOf_SenderAddress.size())
+//	{
+//		// create init code that returns given contract code
+//		string initStringHex = "{ (CODECOPY 0 (- (CODESIZE) 0x" + sizeOfSenderCode + "  ) 0x" + sizeOfSenderCode + ") (RETURN 0 0x" + sizeOfSenderCode +")}";
+//		bytes initBytes = compileLLL(initStringHex, true, NULL);
+//		initBytes += fromHex(codeOf_SenderAddress);
+//		bytesConstRef init(&initBytes);
+
+//		if (!m_s.addresses().count(myAddress))
+//		{
+//			m_ms.internal.resize(m_ms.internal.size() + 1);
+//			auto na = m_s.createNewAddress(myAddress, myAddress, balance(myAddress), gasPrice, &contractgas, init, origin, &sub, &m_ms ? &(m_ms.internal.back()) : nullptr, {}, 1);
+//			if (!m_ms.internal.back().from)
+//				m_ms.internal.pop_back();
+//			if (na != myAddress)
+//			{
+//				cnote << "not able to call to : " << myAddress << "\n";
+//				cnote << "in FakeExtVM you can only make a call to " << na << "\n";
+//				BOOST_THROW_EXCEPTION(FakeExtVMFailure() << errinfo_comment("Address not callable in FakeExtVM\n") << errinfo_wrongAddress(toString(myAddress)));
+//				return false;
+//			}
+//		}
+//	}
+
+//	if (codeOf_CodeAddress.size())
+//	{
+//		// create init code that returns given contract code
+//		string initStringHex = "{ (CODECOPY 0 (- (CODESIZE) 0x" + sizeOfCode + "  ) 0x" + sizeOfCode + ") (RETURN 0 0x" + sizeOfCode +")}";
+//		bytes initBytes = compileLLL(initStringHex, true, NULL);
+//		initBytes += fromHex(codeOf_CodeAddress);
+//		bytesConstRef init(&initBytes);
+
+//		if (!m_s.addresses().count(_codeAddressOverride ? _codeAddressOverride : _receiveAddress))
+//		{
+//			m_s.noteSending(myAddress);
+//			m_ms.internal.resize(m_ms.internal.size() + 1);
+//			auto na = m_s.createNewAddress(_codeAddressOverride ? _codeAddressOverride : _receiveAddress, myAddress, balance(_codeAddressOverride ? _codeAddressOverride : _receiveAddress), gasPrice, &contractgas, init, origin, &sub, &m_ms ? &(m_ms.internal.back()) : nullptr, OnOpFunc(), 1);
+//			if (!m_ms.internal.back().from)
+//				m_ms.internal.pop_back();
+
+//			if (na != (_codeAddressOverride ? _codeAddressOverride : _receiveAddress))
+//			{
+//				cnote << "not able to call to : " << (_codeAddressOverride ? _codeAddressOverride : _receiveAddress) << "\n";
+//				cnote << "in FakeExtVM you can only make a call to " << na << "\n";
+//				BOOST_THROW_EXCEPTION(FakeExtVMFailure() << errinfo_comment("Address not callable in FakeExtVM\n") << errinfo_wrongAddress(toString(_codeAddressOverride ? _codeAddressOverride : _receiveAddress)));
+//				return false;
+//			}
+//		}
+
+//		m_ms.internal.resize(m_ms.internal.size() + 1);
+
+//		auto ret = m_s.call(_receiveAddress,_codeAddressOverride ? _codeAddressOverride : _receiveAddress, _myAddressOverride ? _myAddressOverride : myAddress, _value, gasPrice, _data, _gas, _out, origin, &sub, &(m_ms.internal.back()), Executive::simpleTrace(), 1);
+
+//		if (!m_ms.internal.back().from)
+//			m_ms.internal.pop_back();
+
+//		// get correct balances, (also for sucicides in the call function)
+//		for (auto const& f: addresses)
+//		{
+//			if (m_s.addressInUse(f.first))
+//				get<0>(addresses[f.first]) = m_s.balance(f.first);
+//		}
+
+//		if (!ret)
+//			return false;
+
+//		// TODO: @CJentzsch refund SSTORE stuff.
+//		// TODO: @CJentzsch test logs.
+
+//		// do suicides
+//		for (auto const& f: sub.suicides)
+//			addresses.erase(f);
+
+//		// get storage
+//		if ((get<0>(addresses[myAddress]) >= _value) && (sub.suicides.find(_receiveAddress) == sub.suicides.end()))
+//		{
+//			for (auto const& j: m_s.storage(_receiveAddress))
+//			{
+//				u256 adr(j.first);
+//				if ((j.second != 0) )
+//					get<2>(addresses[_receiveAddress])[adr] = j.second;
+//			}
+//		}
+//	}
+//	else
+//		addresses.erase(_receiveAddress); // for the sake of comparison
+
+//	return true;
 }
 
 void FakeExtVM::setTransaction(Address _caller, u256 _value, u256 _gasPrice, bytes const& _data)
@@ -435,8 +439,8 @@ eth::OnOpFunc FakeExtVM::simpleTrace()
 		o << "    MEMORY" << std::endl << memDump(vm.memory());
 		o << "    STORAGE" << std::endl;
 
-		for (auto const& i: ext.state().storage(ext.myAddress))
+//		for (auto const& i: ext.state().storage(ext.myAddress))
-			o << std::showbase << std::hex << i.first << ": " << i.second << std::endl;
+//			o << std::showbase << std::hex << i.first << ": " << i.second << std::endl;
 
 		for (auto const& i: std::get<2>(ext.addresses.find(ext.myAddress)->second))
 			o << std::showbase << std::hex << i.first << ": " << i.second << std::endl;
@@ -454,70 +458,70 @@ eth::OnOpFunc FakeExtVM::simpleTrace()
 	};
 }
 
-// THIS IS BROKEN AND NEEDS TO BE REMOVED.
+//// THIS IS BROKEN AND NEEDS TO BE REMOVED.
-h160 FakeState::createNewAddress(Address _newAddress, Address _sender, u256 _endowment, u256 _gasPrice, u256* _gas, bytesConstRef _code, Address _origin, SubState* o_sub, Manifest* o_ms, OnOpFunc const& _onOp, unsigned _level)
+//h160 FakeState::createNewAddress(Address _newAddress, Address _sender, u256 _endowment, u256 _gasPrice, u256* _gas, bytesConstRef _code, Address _origin, SubState* o_sub, Manifest* o_ms, OnOpFunc const& _onOp, unsigned _level)
-{
+//{
-	(void)o_sub;
+//	(void)o_sub;
 
-	if (!_origin)
+//	if (!_origin)
-		_origin = _sender;
+//		_origin = _sender;
 
-	if (o_ms)
+//	if (o_ms)
-	{
+//	{
-		o_ms->from = _sender;
+//		o_ms->from = _sender;
-		o_ms->to = Address();
+//		o_ms->to = Address();
-		o_ms->value = _endowment;
+//		o_ms->value = _endowment;
-		o_ms->input = _code.toBytes();
+//		o_ms->input = _code.toBytes();
-	}
+//	}
 
-	// Set up new account...
+//	// Set up new account...
-	m_cache[_newAddress] = AddressState(0, balance(_newAddress) + _endowment, h256(), h256());
+//	m_cache[_newAddress] = AddressState(0, balance(_newAddress) + _endowment, h256(), h256());
 
-	// Execute init code.
+//	// Execute init code.
-	VM vm(*_gas);
+//	VM vm(*_gas);
-	ExtVM evm(*this, _newAddress, _sender, _origin, _endowment, _gasPrice, bytesConstRef(), _code, o_ms, _level);
+//	ExtVM evm(*this, _newAddress, _sender, _origin, _endowment, _gasPrice, bytesConstRef(), _code, o_ms, _level);
-	bool revert = false;
+//	bool revert = false;
-	bytesConstRef out;
+//	bytesConstRef out;
 
-	try
+//	try
-	{
+//	{
-		out = vm.go(evm, _onOp);
+//		out = vm.go(evm, _onOp);
-		if (o_ms)
+//		if (o_ms)
-			o_ms->output = out.toBytes();
+//			o_ms->output = out.toBytes();
-		// TODO: deal with evm.sub
+//		// TODO: deal with evm.sub
-	}
+//	}
-	catch (OutOfGas const& /*_e*/)
+//	catch (OutOfGas const& /*_e*/)
-	{
+//	{
-		clog(StateChat) << "Out of Gas! Reverting.";
+//		clog(StateChat) << "Out of Gas! Reverting.";
-		revert = true;
+//		revert = true;
-	}
+//	}
-	catch (VMException const& _e)
+//	catch (VMException const& _e)
-	{
+//	{
-		clog(StateChat) << "VM Exception: " << diagnostic_information(_e);
+//		clog(StateChat) << "VM Exception: " << diagnostic_information(_e);
-	}
+//	}
-	catch (Exception const& _e)
+//	catch (Exception const& _e)
-	{
+//	{
-		clog(StateChat) << "Exception in VM: " << diagnostic_information(_e);
+//		clog(StateChat) << "Exception in VM: " << diagnostic_information(_e);
-	}
+//	}
-	catch (std::exception const& _e)
+//	catch (std::exception const& _e)
-	{
+//	{
-		clog(StateChat) << "std::exception in VM: " << _e.what();
+//		clog(StateChat) << "std::exception in VM: " << _e.what();
-	}
+//	}
 
-	// TODO: CHECK: IS THIS CORRECT?! (esp. given account created prior to revertion init.)
+//	// TODO: CHECK: IS THIS CORRECT?! (esp. given account created prior to revertion init.)
 
-	// Write state out only in the case of a non-out-of-gas transaction.
+//	// Write state out only in the case of a non-out-of-gas transaction.
-	if (revert)
+//	if (revert)
-		evm.revert();
+//		evm.revert();
 
-	// Set code.
+//	// Set code.
-	if (addressInUse(_newAddress))
+//	if (addressInUse(_newAddress))
-		m_cache[_newAddress].setCode(out);
+//		m_cache[_newAddress].setCode(out);
 
-	*_gas = vm.gas();
+//	*_gas = vm.gas();
 
-	return _newAddress;
+//	return _newAddress;
-}
+//}
 
 namespace dev { namespace test {
 
@@ -654,34 +658,6 @@ void doTests(json_spirit::mValue& v, bool _fillin)
 	}
 }
 
-/*string makeTestCase()
-{
-	json_spirit::mObject o;
-
-	VM vm;
-	BlockInfo pb;
-	pb.hash = sha3("previousHash");
-	pb.nonce = sha3("previousNonce");
-	BlockInfo cb = pb;
-	cb.difficulty = 256;
-	cb.timestamp = 1;
-	cb.coinbaseAddress = toAddress(sha3("coinbase"));
-	FakeExtVM fev(pb, cb, 0);
-	bytes init;
-	fev.setContract(toAddress(sha3("contract")), ether, 0, compileLisp("(suicide (txsender))", false, init), map<u256, u256>());
-	o["env"] = fev.exportEnv();
-	o["pre"] = fev.exportState();
-	fev.setTransaction(toAddress(sha3("sender")), ether, finney, bytes());
-	mArray execs;
-	execs.push_back(fev.exportExec());
-	o["exec"] = execs;
-	vm.go(fev);
-	o["post"] = fev.exportState();
-	o["txs"] = fev.exportTxs();
-
-	return json_spirit::write_string(json_spirit::mValue(o), true);
-}*/
-
 void executeTests(const string& _name)
 {
 	const char* ptestPath = getenv("ETHEREUM_TEST_PATH");

vm.h

@@ -41,12 +41,12 @@ namespace dev { namespace test {
 
 struct FakeExtVMFailure : virtual Exception {};
 
-class FakeState: public eth::State
+//class FakeState: public eth::State
-{
+//{
-public:
+//public:
-	/// Execute a contract-creation transaction.
+//	/// Execute a contract-creation transaction.
-	h160 createNewAddress(Address _newAddress, Address _txSender, u256 _endowment, u256 _gasPrice, u256* _gas, bytesConstRef _code, Address _originAddress = {}, eth::SubState* o_sub = nullptr, eth::Manifest* o_ms = nullptr, eth::OnOpFunc const& _onOp = {}, unsigned _level = 0);
+//	h160 createNewAddress(Address _newAddress, Address _txSender, u256 _endowment, u256 _gasPrice, u256* _gas, bytesConstRef _code, Address _originAddress = {}, eth::SubState* o_sub = nullptr, eth::Manifest* o_ms = nullptr, eth::OnOpFunc const& _onOp = {}, unsigned _level = 0);
-};
+//};
 
 class FakeExtVM: public eth::ExtVMFace
 {
@@ -82,7 +82,7 @@ public:
 	void importCallCreates(json_spirit::mArray& _callcreates);
 
 	eth::OnOpFunc simpleTrace();
-	FakeState state() const { return m_s; }
+	//FakeState state() const { return m_s; }
 
 	std::map<Address, std::tuple<u256, u256, std::map<u256, u256>, bytes>> addresses;
 	eth::Transactions callcreates;
@@ -91,7 +91,7 @@ public:
 	u256 gas;
 
 private:
-	FakeState m_s;
+	//FakeState m_s;
 	eth::Manifest m_ms;
 };
 

vmSha3TestFiller.json

@@ -137,8 +137,89 @@
             "gasPrice" : "100000000000000",
             "gas" : "10000"
         }
+    },
+
+    "sha3_4": {
+        "env" : {
+            "previousHash" : "5e20a0453cecd065ea59c37ac63e079ee08998b6045136a8ce6635c7912ec0b6",
+            "currentNumber" : "0",
+            "currentGasLimit" : "1000000",
+            "currentDifficulty" : "256",
+            "currentTimestamp" : 1,
+            "currentCoinbase" : "2adc25665018aa1fe0e6bc666dac8fc2697ff9ba"
+        },
+        "pre" : {
+            "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+                "balance" : "1000000000000000000",
+                "nonce" : 0,
+                "code" : "{ [[ 0 ]] (SHA3  0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff 100)}",
+                "storage": {}
+            }
+        },
+        "exec" : {
+            "address" : "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
+            "origin" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+            "caller" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+            "value" : "1000000000000000000",
+            "data" : "",
+            "gasPrice" : "100000000000000",
+            "gas" : "10000"
+        }
+    },
+
+    "sha3_4": {
+        "env" : {
+            "previousHash" : "5e20a0453cecd065ea59c37ac63e079ee08998b6045136a8ce6635c7912ec0b6",
+            "currentNumber" : "0",
+            "currentGasLimit" : "1000000",
+            "currentDifficulty" : "256",
+            "currentTimestamp" : 1,
+            "currentCoinbase" : "2adc25665018aa1fe0e6bc666dac8fc2697ff9ba"
+        },
+        "pre" : {
+            "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+                "balance" : "1000000000000000000",
+                "nonce" : 0,
+                "code" : "{ [[ 0 ]] (SHA3  0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff)}",
+                "storage": {}
+            }
+        },
+        "exec" : {
+            "address" : "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
+            "origin" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+            "caller" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+            "value" : "1000000000000000000",
+            "data" : "",
+            "gasPrice" : "100000000000000",
+            "gas" : "10000"
+        }
+    },
+
+    "sha3_5": {
+        "env" : {
+            "previousHash" : "5e20a0453cecd065ea59c37ac63e079ee08998b6045136a8ce6635c7912ec0b6",
+            "currentNumber" : "0",
+            "currentGasLimit" : "1000000",
+            "currentDifficulty" : "256",
+            "currentTimestamp" : 1,
+            "currentCoinbase" : "2adc25665018aa1fe0e6bc666dac8fc2697ff9ba"
+        },
+        "pre" : {
+            "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+                "balance" : "1000000000000000000",
+                "nonce" : 0,
+                "code" : "{ [[ 0 ]] (SHA3  100 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff)}",
+                "storage": {}
+            }
+        },
+        "exec" : {
+            "address" : "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
+            "origin" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+            "caller" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+            "value" : "1000000000000000000",
+            "data" : "",
+            "gasPrice" : "100000000000000",
+            "gas" : "10000"
+        }
     }
-
-
-
 }