ethminer/test/createRandomStateTest.cpp

/*
	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 createRandomStateTest.cpp
 * @author Christoph Jentzsch <jentzsch.simulationsoftware@gmail.com>
 * @date 2015
 * Creating a random state test.
 */

#include <string>
#include <iostream>
#include <chrono>

#include <boost/random.hpp>
#include <boost/filesystem/path.hpp>

#pragma GCC diagnostic ignored "-Wunused-parameter"
#include <json_spirit/json_spirit.h>
#include <json_spirit/json_spirit_reader_template.h>
#include <json_spirit/json_spirit_writer_template.h>
#include <libdevcore/CommonIO.h>
#include <libdevcore/CommonData.h>
#include <libevmcore/Instruction.h>
#include <libevm/VMFactory.h>
#include "TestHelper.h"
#include "vm.h"

using namespace std;
using namespace json_spirit;
using namespace dev;

void doStateTests(json_spirit::mValue& _v);

int main(int argc, char *argv[])
{
	g_logVerbosity = 0;

	// create random code

	boost::random::mt19937 gen;

	auto now = chrono::steady_clock::now().time_since_epoch();
	auto timeSinceEpoch = chrono::duration_cast<chrono::nanoseconds>(now).count();
	gen.seed(static_cast<unsigned int>(timeSinceEpoch));
	// set min and max length of the random evm code
	boost::random::uniform_int_distribution<> lengthOfCodeDist(8, 24);
	boost::random::uniform_int_distribution<> reasonableInputValuesSize(0, 7);
	boost::random::uniform_int_distribution<> opcodeDist(0, 255);
	boost::random::uniform_int_distribution<> BlockInfoOpcodeDist(0x40, 0x45);
	boost::random::uniform_int_distribution<> uniformInt(0, 0x7fffffff);
	boost::random::variate_generator<boost::mt19937&, boost::random::uniform_int_distribution<> > randGenInputValue(gen, reasonableInputValuesSize);
	boost::random::variate_generator<boost::mt19937&, boost::random::uniform_int_distribution<> > randGenUniformInt(gen, uniformInt);
	boost::random::variate_generator<boost::mt19937&, boost::random::uniform_int_distribution<> > randGen(gen, opcodeDist);
	boost::random::variate_generator<boost::mt19937&, boost::random::uniform_int_distribution<> > randGenBlockInfoOpcode(gen, BlockInfoOpcodeDist);

	std::vector<u256> reasonableInputValues;
	reasonableInputValues.push_back(0);
	reasonableInputValues.push_back(1);
	reasonableInputValues.push_back(50000);
	reasonableInputValues.push_back(u256("0x10000000000000000000000000000000000000000"));
	reasonableInputValues.push_back(u256("0xffffffffffffffffffffffffffffffffffffffff"));
	reasonableInputValues.push_back(u256("0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe"));
	reasonableInputValues.push_back(u256("0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff"));
	reasonableInputValues.push_back(u256("0x945304eb96065b2a98b57a48a06ae28d285a71b5"));
	reasonableInputValues.push_back(randGenUniformInt());

	int lengthOfCode  = lengthOfCodeDist(gen);
	string randomCode;

	for (int i = 0; i < lengthOfCode; ++i)
	{
		// pre-fill stack to avoid that most of the test fail with a stackunderflow
		if (i < 8 && (randGen() < 192))
		{
			randomCode += randGen() < 32 ? toHex(toCompactBigEndian((uint8_t)randGenBlockInfoOpcode())) : "7f" +  toHex(reasonableInputValues[randGenInputValue()]);
			continue;
		}

		uint8_t opcode = randGen();
		// disregard all invalid commands, except of one (0x0c)
		if ((dev::eth::isValidInstruction(dev::eth::Instruction(opcode)) || (randGen() > 250)))
			randomCode += toHex(toCompactBigEndian(opcode));
		else
			i--;
	}

	string const s = R"(
	{
		"randomStatetest" : {
			"env" : {
				"currentCoinbase" : "945304eb96065b2a98b57a48a06ae28d285a71b5",
				"currentDifficulty" : "5623894562375",
				"currentGasLimit" : "115792089237316195423570985008687907853269984665640564039457584007913129639935",
				"currentNumber" : "0",
				"currentTimestamp" : "1",
				"previousHash" : "5e20a0453cecd065ea59c37ac63e079ee08998b6045136a8ce6635c7912ec0b6"
			},
			"pre" : {
				"095e7baea6a6c7c4c2dfeb977efac326af552d87" : {
					"balance" : "0",
					"code" : "0x6001600101600055",
					"nonce" : "0",
					"storage" : {
					}
				},
				"945304eb96065b2a98b57a48a06ae28d285a71b5" : {
					"balance" : "46",
					"code" : "0x6000355415600957005b60203560003555",
					"nonce" : "0",
					"storage" : {
					}
				},
				"a94f5374fce5edbc8e2a8697c15331677e6ebf0b" : {
					"balance" : "1000000000000000000",
					"code" : "0x",
					"nonce" : "0",
					"storage" : {
					}
				}
			},
			"transaction" : {
				"data" : "0x42",
				"gasLimit" : "400000",
				"gasPrice" : "1",
				"nonce" : "0",
				"secretKey" : "45a915e4d060149eb4365960e6a7a45f334393093061116b197e3240065ff2d8",
				"to" : "095e7baea6a6c7c4c2dfeb977efac326af552d87",
				"value" : "100000"
			}
		}
	}
)";
	mValue v;
	read_string(s, v);

	// insert new random code
	v.get_obj().find("randomStatetest")->second.get_obj().find("pre")->second.get_obj().begin()->second.get_obj()["code"] = "0x" + randomCode + (randGen() > 128 ? "55" : "") + (randGen() > 128 ? "60005155" : "");

	// insert new data in tx
	v.get_obj().find("randomStatetest")->second.get_obj().find("transaction")->second.get_obj()["data"] = "0x" + randomCode;

	// insert new value in tx
	v.get_obj().find("randomStatetest")->second.get_obj().find("transaction")->second.get_obj()["value"] = toString(randGenUniformInt());

	// insert new gasLimit in tx
	v.get_obj().find("randomStatetest")->second.get_obj().find("transaction")->second.get_obj()["gasLimit"] = "0x" + toHex(toCompactBigEndian((int)randGenUniformInt()));

	// fill test
	doStateTests(v);

	// stream to output for further handling by the bash script
	cout << json_spirit::write_string(v, true);

	return 0;
}

void doStateTests(json_spirit::mValue& _v)
{
	eth::VMFactory::setKind(eth::VMKind::Interpreter);

	for (auto& i: _v.get_obj())
	{
		//cerr << i.first << endl;
		mObject& o = i.second.get_obj();

		assert(o.count("env") > 0);
		assert(o.count("pre") > 0);
		assert(o.count("transaction") > 0);

		test::ImportTest importer(o, true);

		eth::State theState = importer.m_statePre;
		bytes tx = importer.m_transaction.rlp();
		bytes output;

		try
		{
			output = theState.execute(test::lastHashes(importer.m_environment.currentBlock.number), tx).output;
		}
		catch (Exception const& _e)
		{
			cnote << "state execution did throw an exception: " << diagnostic_information(_e);
			theState.commit();
		}
		catch (std::exception const& _e)
		{
			cnote << "state execution did throw an exception: " << _e.what();
		}
#if ETH_FATDB
		importer.exportTest(output, theState);
#else
		cout << "You can not fill tests when FATDB is switched off";
#endif
	}
}