Browse Source
Conflicts: libethereum/Executive.cpp libethereum/Executive.h libethereum/State.cppcl-refactor
Paweł Bylica
10 years ago
35 changed files with 639 additions and 690 deletions
@ -1,46 +0,0 @@ |
|||
/*
|
|||
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 Manifest.cpp
|
|||
* @author Gav Wood <i@gavwood.com> |
|||
* @date 2014 |
|||
*/ |
|||
|
|||
#include "Manifest.h" |
|||
using namespace std; |
|||
using namespace dev; |
|||
using namespace dev::eth; |
|||
|
|||
Manifest::Manifest(bytesConstRef _r) |
|||
{ |
|||
RLP r(_r); |
|||
from = r[0].toHash<Address>(); |
|||
to = r[1].toHash<Address>(); |
|||
value = r[2].toInt<u256>(); |
|||
altered = r[3].toVector<u256>(); |
|||
input = r[4].toBytes(); |
|||
output = r[5].toBytes(); |
|||
for (auto const& i: r[6]) |
|||
internal.emplace_back(i.data()); |
|||
} |
|||
|
|||
void Manifest::streamRLP(RLPStream& _s) const |
|||
{ |
|||
_s.appendList(7) << from << to << value << altered << input << output; |
|||
_s.appendList(internal.size()); |
|||
for (auto const& i: internal) |
|||
i.streamRLP(_s); |
|||
} |
|||
@ -1,73 +0,0 @@ |
|||
/*
|
|||
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 Manifest.h
|
|||
* @author Gav Wood <i@gavwood.com> |
|||
* @date 2014 |
|||
*/ |
|||
|
|||
#pragma once |
|||
|
|||
#include <iostream> |
|||
#include <sstream> |
|||
#include <libdevcore/RLP.h> |
|||
#include <libethcore/CommonEth.h> |
|||
|
|||
namespace dev |
|||
{ |
|||
namespace eth |
|||
{ |
|||
|
|||
struct Manifest; |
|||
using Manifests = std::vector<Manifest>; |
|||
|
|||
/**
|
|||
* @brief A record of the state-interaction of a transaction/call/create. |
|||
*/ |
|||
struct Manifest |
|||
{ |
|||
Manifest() {} |
|||
Manifest(bytesConstRef _r); |
|||
void streamRLP(RLPStream& _s) const; |
|||
|
|||
h256 bloom() const { h256 ret = from.bloom() | to.bloom(); for (auto const& i: internal) ret |= i.bloom(); for (auto const& i: altered) ret |= h256(i).bloom(); return ret; } |
|||
|
|||
std::string toString(unsigned _indent = 0) const |
|||
{ |
|||
std::ostringstream oss; |
|||
oss << std::string(_indent * 3, ' ') << from << " -> " << to << " [" << value << "]: {"; |
|||
if (internal.size()) |
|||
{ |
|||
oss << std::endl; |
|||
for (auto const& m: internal) |
|||
oss << m.toString(_indent + 1) << std::endl; |
|||
oss << std::string(_indent * 3, ' '); |
|||
} |
|||
oss << "} I:" << toHex(input) << "; O:" << toHex(output); |
|||
return oss.str(); |
|||
} |
|||
|
|||
Address from; |
|||
Address to; |
|||
u256 value; |
|||
u256s altered; |
|||
bytes input; |
|||
bytes output; |
|||
Manifests internal; |
|||
}; |
|||
|
|||
} |
|||
} |
|||
@ -1,28 +0,0 @@ |
|||
/*
|
|||
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 PastMessage.cpp
|
|||
* @author Gav Wood <i@gavwood.com> |
|||
* @date 2014 |
|||
*/ |
|||
|
|||
#include "PastMessage.h" |
|||
using namespace std; |
|||
using namespace dev; |
|||
using namespace dev::eth; |
|||
|
|||
#pragma GCC diagnostic ignored "-Wunused-variable" |
|||
namespace { char dummy; }; |
|||
@ -1,56 +0,0 @@ |
|||
/*
|
|||
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 PastMessage.h
|
|||
* @author Gav Wood <i@gavwood.com> |
|||
* @date 2014 |
|||
*/ |
|||
|
|||
#pragma once |
|||
|
|||
#include <libdevcore/Common.h> |
|||
#include <libethcore/CommonEth.h> |
|||
#include "Manifest.h" |
|||
|
|||
namespace dev |
|||
{ |
|||
namespace eth |
|||
{ |
|||
|
|||
struct PastMessage |
|||
{ |
|||
PastMessage(Manifest const& _m, std::vector<unsigned> _path, Address _o): to(_m.to), from(_m.from), value(_m.value), input(_m.input), output(_m.output), path(_path), origin(_o) {} |
|||
|
|||
PastMessage& polish(h256 _b, u256 _ts, unsigned _n, Address _coinbase) { block = _b; timestamp = _ts; number = _n; coinbase = _coinbase; return *this; } |
|||
|
|||
Address to; ///< The receiving address of the transaction. Address() in the case of a creation.
|
|||
Address from; ///< The receiving address of the transaction. Address() in the case of a creation.
|
|||
u256 value; ///< The value associated with the call.
|
|||
bytes input; ///< The data associated with the message, or the initialiser if it's a creation transaction.
|
|||
bytes output; ///< The data returned by the message, or the body code if it's a creation transaction.
|
|||
|
|||
std::vector<unsigned> path; ///< Call path into the block transaction. size() is always > 0. First item is the transaction index in the block.
|
|||
Address origin; ///< Originating sender of the transaction.
|
|||
Address coinbase; ///< Block coinbase.
|
|||
h256 block; ///< Block hash.
|
|||
u256 timestamp; ///< Block timestamp.
|
|||
unsigned number; ///< Block number.
|
|||
}; |
|||
|
|||
typedef std::vector<PastMessage> PastMessages; |
|||
|
|||
} |
|||
} |
|||
@ -0,0 +1,161 @@ |
|||
|
|||
/*
|
|||
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/>.
|
|||
*/ |
|||
/**
|
|||
* @author Christian <c@ethdev.com> |
|||
* @date 2014 |
|||
* Framework for executing Solidity contracts and testing them against C++ implementation. |
|||
*/ |
|||
|
|||
#pragma once |
|||
|
|||
#include <string> |
|||
#include <tuple> |
|||
#include <boost/test/unit_test.hpp> |
|||
#include <libethereum/State.h> |
|||
#include <libethereum/Executive.h> |
|||
#include <libsolidity/CompilerStack.h> |
|||
|
|||
namespace dev |
|||
{ |
|||
/// Provides additional overloads for toBigEndian to encode arguments and return values.
|
|||
inline bytes toBigEndian(byte _value) { return bytes({_value}); } |
|||
inline bytes toBigEndian(bool _value) { return bytes({byte(_value)}); } |
|||
|
|||
namespace solidity |
|||
{ |
|||
namespace test |
|||
{ |
|||
|
|||
class ExecutionFramework |
|||
{ |
|||
public: |
|||
ExecutionFramework() { g_logVerbosity = 0; } |
|||
|
|||
bytes const& compileAndRun(std::string const& _sourceCode, u256 const& _value = 0, std::string const& _contractName = "") |
|||
{ |
|||
dev::solidity::CompilerStack compiler; |
|||
compiler.compile(_sourceCode, m_optimize); |
|||
bytes code = compiler.getBytecode(_contractName); |
|||
sendMessage(code, true, _value); |
|||
BOOST_REQUIRE(!m_output.empty()); |
|||
return m_output; |
|||
} |
|||
|
|||
bytes const& callContractFunction(byte _index, bytes const& _data = bytes(), u256 const& _value = 0) |
|||
{ |
|||
sendMessage(bytes(1, _index) + _data, false, _value); |
|||
return m_output; |
|||
} |
|||
|
|||
template <class... Args> |
|||
bytes const& callContractFunction(byte _index, Args const&... _arguments) |
|||
{ |
|||
return callContractFunction(_index, argsToBigEndian(_arguments...)); |
|||
} |
|||
|
|||
template <class CppFunction, class... Args> |
|||
void testSolidityAgainstCpp(byte _index, CppFunction const& _cppFunction, Args const&... _arguments) |
|||
{ |
|||
bytes solidityResult = callContractFunction(_index, _arguments...); |
|||
bytes cppResult = callCppAndEncodeResult(_cppFunction, _arguments...); |
|||
BOOST_CHECK_MESSAGE(solidityResult == cppResult, "Computed values do not match." |
|||
"\nSolidity: " + toHex(solidityResult) + "\nC++: " + toHex(cppResult)); |
|||
} |
|||
|
|||
template <class CppFunction, class... Args> |
|||
void testSolidityAgainstCppOnRange(byte _index, CppFunction const& _cppFunction, |
|||
u256 const& _rangeStart, u256 const& _rangeEnd) |
|||
{ |
|||
for (u256 argument = _rangeStart; argument < _rangeEnd; ++argument) |
|||
{ |
|||
bytes solidityResult = callContractFunction(_index, argument); |
|||
bytes cppResult = callCppAndEncodeResult(_cppFunction, argument); |
|||
BOOST_CHECK_MESSAGE(solidityResult == cppResult, "Computed values do not match." |
|||
"\nSolidity: " + toHex(solidityResult) + "\nC++: " + toHex(cppResult) + |
|||
"\nArgument: " + toHex(toBigEndian(argument))); |
|||
} |
|||
} |
|||
|
|||
private: |
|||
template <class FirstArg, class... Args> |
|||
bytes argsToBigEndian(FirstArg const& _firstArg, Args const&... _followingArgs) const |
|||
{ |
|||
return toBigEndian(_firstArg) + argsToBigEndian(_followingArgs...); |
|||
} |
|||
|
|||
bytes argsToBigEndian() const { return bytes(); } |
|||
|
|||
template <class CppFunction, class... Args> |
|||
auto callCppAndEncodeResult(CppFunction const& _cppFunction, Args const&... _arguments) |
|||
-> typename std::enable_if<std::is_void<decltype(_cppFunction(_arguments...))>::value, bytes>::type |
|||
{ |
|||
_cppFunction(_arguments...); |
|||
return bytes(); |
|||
} |
|||
template <class CppFunction, class... Args> |
|||
auto callCppAndEncodeResult(CppFunction const& _cppFunction, Args const&... _arguments) |
|||
-> typename std::enable_if<!std::is_void<decltype(_cppFunction(_arguments...))>::value, bytes>::type |
|||
{ |
|||
return toBigEndian(_cppFunction(_arguments...)); |
|||
} |
|||
|
|||
void sendMessage(bytes const& _data, bool _isCreation, u256 const& _value = 0) |
|||
{ |
|||
m_state.addBalance(m_sender, _value); // just in case
|
|||
eth::Executive executive(m_state); |
|||
eth::Transaction t = _isCreation ? eth::Transaction(_value, m_gasPrice, m_gas, _data, 0, KeyPair::create().sec()) |
|||
: eth::Transaction(_value, m_gasPrice, m_gas, m_contractAddress, _data, 0, KeyPair::create().sec()); |
|||
bytes transactionRLP = t.rlp(); |
|||
try |
|||
{ |
|||
// this will throw since the transaction is invalid, but it should nevertheless store the transaction
|
|||
executive.setup(&transactionRLP); |
|||
} |
|||
catch (...) {} |
|||
if (_isCreation) |
|||
{ |
|||
BOOST_REQUIRE(!executive.create(m_sender, _value, m_gasPrice, m_gas, &_data, m_sender)); |
|||
m_contractAddress = executive.newAddress(); |
|||
BOOST_REQUIRE(m_contractAddress); |
|||
BOOST_REQUIRE(m_state.addressHasCode(m_contractAddress)); |
|||
} |
|||
else |
|||
{ |
|||
BOOST_REQUIRE(m_state.addressHasCode(m_contractAddress)); |
|||
BOOST_REQUIRE(!executive.call(m_contractAddress, m_sender, _value, m_gasPrice, &_data, m_gas, m_sender)); |
|||
} |
|||
BOOST_REQUIRE(executive.go()); |
|||
m_state.noteSending(m_sender); |
|||
executive.finalize(); |
|||
m_output = executive.out().toVector(); |
|||
} |
|||
|
|||
protected: |
|||
bool m_optimize = false; |
|||
Address m_sender; |
|||
Address m_contractAddress; |
|||
eth::State m_state; |
|||
u256 const m_gasPrice = 100 * eth::szabo; |
|||
u256 const m_gas = 1000000; |
|||
bytes m_output; |
|||
}; |
|||
|
|||
} |
|||
} |
|||
} // end namespaces
|
|||
|
|||
@ -0,0 +1,131 @@ |
|||
|
|||
/*
|
|||
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/>.
|
|||
*/ |
|||
/**
|
|||
* @author Christian <c@ethdev.com> |
|||
* @date 2014 |
|||
* Tests for the Solidity optimizer. |
|||
*/ |
|||
|
|||
#include <string> |
|||
#include <tuple> |
|||
#include <boost/test/unit_test.hpp> |
|||
#include <boost/lexical_cast.hpp> |
|||
#include <test/solidityExecutionFramework.h> |
|||
|
|||
using namespace std; |
|||
|
|||
namespace dev |
|||
{ |
|||
namespace solidity |
|||
{ |
|||
namespace test |
|||
{ |
|||
|
|||
class OptimizerTestFramework: public ExecutionFramework |
|||
{ |
|||
public: |
|||
OptimizerTestFramework() { } |
|||
/// Compiles the source code with and without optimizing.
|
|||
void compileBothVersions(unsigned _expectedSizeDecrease, std::string const& _sourceCode, u256 const& _value = 0, std::string const& _contractName = "") { |
|||
m_optimize = false; |
|||
bytes nonOptimizedBytecode = compileAndRun(_sourceCode, _value, _contractName); |
|||
m_nonOptimizedContract = m_contractAddress; |
|||
m_optimize = true; |
|||
bytes optimizedBytecode = compileAndRun(_sourceCode, _value, _contractName); |
|||
int sizeDiff = nonOptimizedBytecode.size() - optimizedBytecode.size(); |
|||
BOOST_CHECK_MESSAGE(sizeDiff >= _expectedSizeDecrease, "Bytecode did only shrink by " |
|||
+ boost::lexical_cast<string>(sizeDiff) + " bytes, expected: " |
|||
+ boost::lexical_cast<string>(_expectedSizeDecrease)); |
|||
m_optimizedContract = m_contractAddress; |
|||
} |
|||
|
|||
template <class... Args> |
|||
void compareVersions(byte _index, Args const&... _arguments) |
|||
{ |
|||
m_contractAddress = m_nonOptimizedContract; |
|||
bytes nonOptimizedOutput = callContractFunction(_index, _arguments...); |
|||
m_contractAddress = m_optimizedContract; |
|||
bytes optimizedOutput = callContractFunction(_index, _arguments...); |
|||
BOOST_CHECK_MESSAGE(nonOptimizedOutput == optimizedOutput, "Computed values do not match." |
|||
"\nNon-Optimized: " + toHex(nonOptimizedOutput) + |
|||
"\nOptimized: " + toHex(optimizedOutput)); |
|||
} |
|||
|
|||
protected: |
|||
Address m_optimizedContract; |
|||
Address m_nonOptimizedContract; |
|||
}; |
|||
|
|||
BOOST_FIXTURE_TEST_SUITE(SolidityOptimizerTest, OptimizerTestFramework) |
|||
|
|||
BOOST_AUTO_TEST_CASE(smoke_test) |
|||
{ |
|||
char const* sourceCode = R"( |
|||
contract test { |
|||
function f(uint a) returns (uint b) { |
|||
return a; |
|||
} |
|||
})"; |
|||
compileBothVersions(4, sourceCode); |
|||
compareVersions(0, u256(7)); |
|||
} |
|||
|
|||
BOOST_AUTO_TEST_CASE(large_integers) |
|||
{ |
|||
char const* sourceCode = R"( |
|||
contract test { |
|||
function f() returns (uint a, uint b) { |
|||
a = 0x234234872642837426347000000; |
|||
b = 0x110000000000000000000000002; |
|||
} |
|||
})"; |
|||
compileBothVersions(28, sourceCode); |
|||
compareVersions(0); |
|||
} |
|||
|
|||
BOOST_AUTO_TEST_CASE(invariants) |
|||
{ |
|||
char const* sourceCode = R"( |
|||
contract test { |
|||
function f(uint a) returns (uint b) { |
|||
return (((a + (1 - 1)) ^ 0) | 0) & (uint(0) - 1); |
|||
} |
|||
})"; |
|||
compileBothVersions(19, sourceCode); |
|||
compareVersions(0, u256(0x12334664)); |
|||
} |
|||
|
|||
BOOST_AUTO_TEST_CASE(unused_expressions) |
|||
{ |
|||
char const* sourceCode = R"( |
|||
contract test { |
|||
uint data; |
|||
function f() returns (uint a, uint b) { |
|||
10 + 20; |
|||
data; |
|||
} |
|||
})"; |
|||
compileBothVersions(11, sourceCode); |
|||
compareVersions(0); |
|||
} |
|||
|
|||
BOOST_AUTO_TEST_SUITE_END() |
|||
|
|||
} |
|||
} |
|||
} // end namespaces
|
|||
Loading…
Reference in new issue