diff --git a/TestHelper.cpp b/TestHelper.cpp index 03e679343..17bd1ebfd 100644 --- a/TestHelper.cpp +++ b/TestHelper.cpp @@ -24,6 +24,9 @@ #include #include #include +#include + +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 diff --git a/TestHelper.h b/TestHelper.h index d6924a17c..63c84fc4f 100644 --- a/TestHelper.h +++ b/TestHelper.h @@ -21,6 +21,9 @@ #pragma once +#include "JsonSpiritHeaders.h" +#include + 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); + +} } } diff --git a/state.cpp b/state.cpp index b0f279bac..1474813d6 100644 --- a/state.cpp +++ b/state.cpp @@ -15,81 +15,219 @@ along with cpp-ethereum. If not, see . */ /** @file state.cpp - * @author Gav Wood + * @author Christoph Jentzsch * @date 2014 * State test functions. */ #include -#include +#include +#include "JsonSpiritHeaders.h" +#include #include #include +#include #include +#include +#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(); - BlockChain bc; - State s(myMiner.address(), stateDB); +namespace dev { namespace eth{ namespace test { - 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; +void doStateTests(json_spirit::mValue& v, bool _fillin) +{ + for (auto& i: v.get_obj()) { - 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(); + cnote << i.first; + mObject& o = i.second.get_obj(); + + BOOST_REQUIRE(o.count("env") > 0); + BOOST_REQUIRE(o.count("pre") > 0); + BOOST_REQUIRE(o.count("exec") > 0); + + 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; +//} + diff --git a/stateOriginal.cpp b/stateOriginal.cpp new file mode 100644 index 000000000..e6b3ab959 --- /dev/null +++ b/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 . +*/ +/** @file stateOriginal.cpp + * @author Gav Wood + * @date 2014 + * State test functions. + */ + +#include +#include +#include +#include +#include +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; +} + diff --git a/vm.cpp b/vm.cpp index e6c82349c..97d645068 100644 --- a/vm.cpp +++ b/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_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); - if (!m_ms.internal.back().from) - m_ms.internal.pop_back(); +// m_s.noteSending(myAddress); +// 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); +// if (!m_ms.internal.back().from) +// m_ms.internal.pop_back(); - if (get<0>(addresses[myAddress]) >= _endowment) - { - get<1>(addresses[myAddress])++; - get<0>(addresses[ret]) = _endowment; - get<3>(addresses[ret]) = m_s.code(ret); - } +// if (get<0>(addresses[myAddress]) >= _endowment) +// { +// get<1>(addresses[myAddress])++; +// get<0>(addresses[ret]) = _endowment; +// //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); - - 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 - + (void)_out; 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)) - o << std::showbase << std::hex << i.first << ": " << i.second << std::endl; +// for (auto const& i: ext.state().storage(ext.myAddress)) +// 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. -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; +//// 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) +//{ +// (void)o_sub; - if (!_origin) - _origin = _sender; +// if (!_origin) +// _origin = _sender; - if (o_ms) - { - o_ms->from = _sender; - o_ms->to = Address(); - o_ms->value = _endowment; - o_ms->input = _code.toBytes(); - } +// if (o_ms) +// { +// o_ms->from = _sender; +// o_ms->to = Address(); +// o_ms->value = _endowment; +// o_ms->input = _code.toBytes(); +// } - // Set up new account... - m_cache[_newAddress] = AddressState(0, balance(_newAddress) + _endowment, h256(), h256()); +// // Set up new account... +// m_cache[_newAddress] = AddressState(0, balance(_newAddress) + _endowment, h256(), h256()); - // Execute init code. - VM vm(*_gas); - ExtVM evm(*this, _newAddress, _sender, _origin, _endowment, _gasPrice, bytesConstRef(), _code, o_ms, _level); - bool revert = false; - bytesConstRef out; +// // Execute init code. +// VM vm(*_gas); +// ExtVM evm(*this, _newAddress, _sender, _origin, _endowment, _gasPrice, bytesConstRef(), _code, o_ms, _level); +// bool revert = false; +// bytesConstRef out; - try - { - out = vm.go(evm, _onOp); - if (o_ms) - o_ms->output = out.toBytes(); - // TODO: deal with evm.sub - } - catch (OutOfGas const& /*_e*/) - { - clog(StateChat) << "Out of Gas! Reverting."; - revert = true; - } - catch (VMException const& _e) - { - clog(StateChat) << "VM Exception: " << diagnostic_information(_e); - } - catch (Exception const& _e) - { - clog(StateChat) << "Exception in VM: " << diagnostic_information(_e); - } - catch (std::exception const& _e) - { - clog(StateChat) << "std::exception in VM: " << _e.what(); - } +// try +// { +// out = vm.go(evm, _onOp); +// if (o_ms) +// o_ms->output = out.toBytes(); +// // TODO: deal with evm.sub +// } +// catch (OutOfGas const& /*_e*/) +// { +// clog(StateChat) << "Out of Gas! Reverting."; +// revert = true; +// } +// catch (VMException const& _e) +// { +// clog(StateChat) << "VM Exception: " << diagnostic_information(_e); +// } +// catch (Exception const& _e) +// { +// clog(StateChat) << "Exception in VM: " << diagnostic_information(_e); +// } +// catch (std::exception const& _e) +// { +// 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. - if (revert) - evm.revert(); +// // Write state out only in the case of a non-out-of-gas transaction. +// if (revert) +// evm.revert(); - // Set code. - if (addressInUse(_newAddress)) - m_cache[_newAddress].setCode(out); +// // Set code. +// if (addressInUse(_newAddress)) +// 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()); - 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"); diff --git a/vm.h b/vm.h index ddc6ddb3e..632aa996b 100644 --- a/vm.h +++ b/vm.h @@ -41,12 +41,12 @@ namespace dev { namespace test { struct FakeExtVMFailure : virtual Exception {}; -class FakeState: public eth::State -{ -public: - /// 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); -}; +//class FakeState: public eth::State +//{ +//public: +// /// 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); +//}; 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, bytes>> addresses; eth::Transactions callcreates; @@ -91,7 +91,7 @@ public: u256 gas; private: - FakeState m_s; + //FakeState m_s; eth::Manifest m_ms; }; diff --git a/vmSha3TestFiller.json b/vmSha3TestFiller.json index 5f9a29b6e..47c32a0e5 100644 --- a/vmSha3TestFiller.json +++ b/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" + } } - - - }