cerc-io/solidity
16
0
Fork 0
mirror of https://github.com/ethereum/solidity synced 2023-10-03 13:03:40 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

Restructure state tests. Remove FakeStateClass

Browse Source
This commit is contained in:
Christoph Jentzsch 2014-10-29 17:25:02 +01:00
parent 3381372200
commit 3565d42a14
7 changed files with 782 additions and 257 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

191
TestHelper.cpp
View File

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

44
TestHelper.h
View File

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

248
state.cpp
View File

@ -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();
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;
//}

95
stateOriginal.cpp Normal file
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;
}

358
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&)
{
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<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");

16
vm.h
View File

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

87
vmSha3TestFiller.json
View File

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