lukechilds
/
ethminer
mirror of https://github.com/lukechilds/ethminer.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity
Browse Source

Restructure state tests. Remove FakeStateClass

cl-refactor
Christoph Jentzsch 10 years ago
parent
a89e2def34
commit
0449b647c0
8 changed files with 783 additions and 259 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Unified View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 7
      libethereum/State.h
  2. 191
      test/TestHelper.cpp
  3. 44
      test/TestHelper.h
  4. 228
      test/state.cpp
  5. 95
      test/stateOriginal.cpp
  6. 378
      test/vm.cpp
  7. 16
      test/vm.h
  8. 83
      test/vmSha3TestFiller.json

7
libethereum/State.h
View File

@ -41,11 +41,11 @@
namespace dev namespace dev
{ {
namespace test { class FakeExtVM; class FakeState; }
namespace eth namespace eth
{ {
namespace test { class ImportTest; }
class BlockChain; class BlockChain;
struct StateChat: public LogChannel { static const char* name() { return "-S-"; } static const int verbosity = 4; }; struct StateChat: public LogChannel { static const char* name() { return "-S-"; } static const int verbosity = 4; };
@ -97,8 +97,7 @@ struct PrecompiledAddress
class State class State
{ {
friend class ExtVM; friend class ExtVM;
friend class test::FakeExtVM; friend class test::ImportTest;
friend class test::FakeState;
friend class Executive; friend class Executive;
public: public:

191
test/TestHelper.cpp
View File

@ -24,6 +24,9 @@
#include <thread> #include <thread>
#include <chrono> #include <chrono>
#include <libethereum/Client.h> #include <libethereum/Client.h>
#include <liblll/Compiler.h>
using namespace std;
namespace dev namespace dev
{ {
@ -54,5 +57,193 @@ void connectClients(Client& c1, Client& c2)
#endif #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

44
test/TestHelper.h
View File

@ -21,6 +21,9 @@
#pragma once #pragma once
#include "JsonSpiritHeaders.h"
#include <libethereum/State.h>
namespace dev namespace dev
{ {
namespace eth namespace eth
@ -31,5 +34,46 @@ class Client;
void mine(Client& c, int numBlocks); void mine(Client& c, int numBlocks);
void connectClients(Client& c1, Client& c2); 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);
}
} }
} }

228
test/state.cpp
View File

@ -15,81 +15,219 @@
along with cpp-ethereum. If not, see <http://www.gnu.org/licenses/>. along with cpp-ethereum. If not, see <http://www.gnu.org/licenses/>.
*/ */
/** @file state.cpp /** @file state.cpp
* @author Gav Wood <i@gavwood.com> * @author Christoph Jentzsch <cj@ethdev.com>
* @date 2014 * @date 2014
* State test functions. * State test functions.
*/ */
#include <boost/filesystem/operations.hpp> #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/BlockChain.h>
#include <libethereum/State.h> #include <libethereum/State.h>
#include <libethereum/ExtVM.h>
#include <libethereum/Defaults.h> #include <libethereum/Defaults.h>
#include <libevm/VM.h>
#include "TestHelper.h"
using namespace std; using namespace std;
using namespace json_spirit;
using namespace dev; using namespace dev;
using namespace dev::eth; 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);
cout << bc; namespace dev { namespace eth{ namespace test {
// Sync up - this won't do much until we use the last state.
s.sync(bc);
cout << s;
// Mine to get some ether! void doStateTests(json_spirit::mValue& v, bool _fillin)
s.commitToMine(bc); {
while (!s.mine(100).completed) {} for (auto& i: v.get_obj())
s.completeMine(); {
bc.attemptImport(s.blockData(), stateDB); 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);
cout << bc; }
}
s.sync(bc);
cout << s; void executeStateTests(const string& _name)
{
const char* ptestPath = getenv("ETHEREUM_TEST_PATH");
string testPath;
// Inject a transaction to transfer funds from miner to me. if (ptestPath == NULL)
bytes tx;
{ {
Transaction t; cnote << " could not find environment variable ETHEREUM_TEST_PATH \n";
t.nonce = s.transactionsFrom(myMiner.address()); testPath = "../../../tests";
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); else
testPath = ptestPath;
cout << s; testPath += "/vmtests";
// Mine to get some ether and set in stone. #ifdef FILL_TESTS
s.commitToMine(bc); try
while (!s.mine(100).completed) {} {
s.completeMine(); cnote << "Populating VM tests...";
bc.attemptImport(s.blockData(), stateDB); 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
cout << bc; 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());
}
s.sync(bc); }
} } }// Namespace Close
cout << s;
return 0; 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;
//}

95
test/stateOriginal.cpp
View File

@ -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;
}

378
test/vm.cpp
View File

@ -36,33 +36,35 @@ FakeExtVM::FakeExtVM(eth::BlockInfo const& _previousBlock, eth::BlockInfo const&
h160 FakeExtVM::create(u256 _endowment, u256* _gas, bytesConstRef _init, OnOpFunc const&) h160 FakeExtVM::create(u256 _endowment, u256* _gas, bytesConstRef _init, OnOpFunc const&)
{ {
Address na = right160(sha3(rlpList(myAddress, get<1>(addresses[myAddress]))));
Transaction t; Transaction t;
t.value = _endowment; t.value = _endowment;
t.gasPrice = gasPrice; t.gasPrice = gasPrice;
t.gas = *_gas; t.gas = *_gas;
t.data = _init.toBytes(); 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; t.type = eth::Transaction::ContractCreation;
callcreates.push_back(t); 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) 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; Transaction t;
t.value = _value; t.value = _value;
@ -72,101 +74,103 @@ bool FakeExtVM::call(Address _receiveAddress, u256 _value, bytesConstRef _data,
t.type = eth::Transaction::MessageCall; t.type = eth::Transaction::MessageCall;
t.receiveAddress = _receiveAddress; t.receiveAddress = _receiveAddress;
callcreates.push_back(t); 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; 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) 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 << " MEMORY" << std::endl << memDump(vm.memory());
o << " STORAGE" << std::endl; 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)) for (auto const& i: std::get<2>(ext.addresses.find(ext.myAddress)->second))
o << std::showbase << std::hex << i.first << ": " << i.second << std::endl; 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 { 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) void executeTests(const string& _name)
{ {
const char* ptestPath = getenv("ETHEREUM_TEST_PATH"); const char* ptestPath = getenv("ETHEREUM_TEST_PATH");

16
test/vm.h
View File

@ -41,12 +41,12 @@ namespace dev { namespace test {
struct FakeExtVMFailure : virtual Exception {}; 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 class FakeExtVM: public eth::ExtVMFace
{ {
@ -82,7 +82,7 @@ public:
void importCallCreates(json_spirit::mArray& _callcreates); void importCallCreates(json_spirit::mArray& _callcreates);
eth::OnOpFunc simpleTrace(); 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; std::map<Address, std::tuple<u256, u256, std::map<u256, u256>, bytes>> addresses;
eth::Transactions callcreates; eth::Transactions callcreates;
@ -91,7 +91,7 @@ public:
u256 gas; u256 gas;
private: private:
FakeState m_s; //FakeState m_s;
eth::Manifest m_ms; eth::Manifest m_ms;
}; };

83
test/vmSha3TestFiller.json
View File

@ -137,8 +137,89 @@
"gasPrice" : "100000000000000", "gasPrice" : "100000000000000",
"gas" : "10000" "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"
}
}
} }

Write Preview
Loading…
Cancel
Save