cerc-io/solidity
10
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

Merge remote-tracking branch 'upstream/develop' into evmjit_stack

Browse Source 
Conflicts:
	evmjit/libevmjit/BasicBlock.cpp
	evmjit/libevmjit/BasicBlock.h
This commit is contained in:
Paweł Bylica 2015-08-11 10:01:31 +02:00
commit 035a93a356
12 changed files with 1032 additions and 174 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
CMakeLists.txt
View File

@ -33,6 +33,7 @@ endif()
if (SOLIDITY) if (SOLIDITY)
add_subdirectory(libsolidity) add_subdirectory(libsolidity)
add_subdirectory(contracts)
endif () endif ()
if (JSONRPC) if (JSONRPC)
add_subdirectory(libweb3jsonrpc) add_subdirectory(libweb3jsonrpc)

206
TestHelper.cpp
View File

@ -25,6 +25,7 @@
#include <chrono> #include <chrono>
#include <libethcore/EthashAux.h> #include <libethcore/EthashAux.h>
#include <libethereum/Client.h> #include <libethereum/Client.h>
#include <libevm/ExtVMFace.h>
#include <liblll/Compiler.h> #include <liblll/Compiler.h>
#include <libevm/VMFactory.h> #include <libevm/VMFactory.h>
#include "Stats.h" #include "Stats.h"
@ -61,10 +62,10 @@ void connectClients(Client& c1, Client& c2)
#endif #endif
} }
void mine(State& s, BlockChain const& _bc) void mine(Block& s, BlockChain const& _bc)
{ {
std::unique_ptr<SealEngineFace> sealer(Ethash::createSealEngine()); std::unique_ptr<SealEngineFace> sealer(Ethash::createSealEngine());
s.commitToMine(_bc); s.commitToSeal(_bc);
Notified<bytes> sealed; Notified<bytes> sealed;
sealer->onSealGenerated([&](bytes const& sealedHeader){ sealed = sealedHeader; }); sealer->onSealGenerated([&](bytes const& sealedHeader){ sealed = sealedHeader; });
sealer->generateSeal(s.info()); sealer->generateSeal(s.info());
@ -81,7 +82,7 @@ void mine(Ethash::BlockHeader& _bi)
sealer->generateSeal(_bi); sealer->generateSeal(_bi);
sealed.waitNot({}); sealed.waitNot({});
sealer.reset(); sealer.reset();
_bi = Ethash::BlockHeader(sealed, IgnoreSeal, h256{}, HeaderData); _bi = Ethash::BlockHeader(sealed, CheckNothing, h256{}, HeaderData);
} }
} }
@ -94,22 +95,43 @@ struct MissingFields : virtual Exception {};
bigint const c_max256plus1 = bigint(1) << 256; bigint const c_max256plus1 = bigint(1) << 256;
ImportTest::ImportTest(json_spirit::mObject& _o, bool isFiller): ImportTest::ImportTest(json_spirit::mObject& _o, bool isFiller, testType testTemplate):
m_statePre(OverlayDB(), eth::BaseState::Empty, Address(_o["env"].get_obj()["currentCoinbase"].get_str())), m_statePre(OverlayDB(), eth::BaseState::Empty),
m_statePost(OverlayDB(), eth::BaseState::Empty, Address(_o["env"].get_obj()["currentCoinbase"].get_str())), m_statePost(OverlayDB(), eth::BaseState::Empty),
m_TestObject(_o) m_testObject(_o)
{ {
importEnv(_o["env"].get_obj()); if (testTemplate == testType::StateTests)
importState(_o["pre"].get_obj(), m_statePre);
importTransaction(_o["transaction"].get_obj());
if (!isFiller)
{ {
importState(_o["post"].get_obj(), m_statePost); importEnv(_o["env"].get_obj());
m_environment.sub.logs = importLog(_o["logs"].get_array()); importTransaction(_o["transaction"].get_obj());
importState(_o["pre"].get_obj(), m_statePre);
if (!isFiller)
{
if (_o.count("post"))
importState(_o["post"].get_obj(), m_statePost);
else
importState(_o["postState"].get_obj(), m_statePost);
m_logsExpected = importLog(_o["logs"].get_array());
}
} }
} }
//executes an imported transacton on preState
bytes ImportTest::executeTest()
{
ExecutionResult res;
eth::State tmpState = m_statePre;
std::pair<ExecutionResult, TransactionReceipt> execOut = m_statePre.execute(m_envInfo, m_transaction);
res = execOut.first;
m_logs = execOut.second.log();
m_statePre.commit();
m_statePost = m_statePre;
m_statePre = tmpState;
return res.output;
}
json_spirit::mObject& ImportTest::makeAllFieldsHex(json_spirit::mObject& _o) json_spirit::mObject& ImportTest::makeAllFieldsHex(json_spirit::mObject& _o)
{ {
static const set<string> hashes {"bloom" , "coinbase", "hash", "mixHash", "parentHash", "receiptTrie", static const set<string> hashes {"bloom" , "coinbase", "hash", "mixHash", "parentHash", "receiptTrie",
@ -138,105 +160,35 @@ json_spirit::mObject& ImportTest::makeAllFieldsHex(json_spirit::mObject& _o)
void ImportTest::importEnv(json_spirit::mObject& _o) void ImportTest::importEnv(json_spirit::mObject& _o)
{ {
assert(_o.count("previousHash") > 0);
assert(_o.count("currentGasLimit") > 0); assert(_o.count("currentGasLimit") > 0);
assert(_o.count("currentDifficulty") > 0); assert(_o.count("currentDifficulty") > 0);
assert(_o.count("currentNumber") > 0);
assert(_o.count("currentTimestamp") > 0); assert(_o.count("currentTimestamp") > 0);
assert(_o.count("currentCoinbase") > 0); assert(_o.count("currentCoinbase") > 0);
assert(_o.count("currentNumber") > 0); m_envInfo.setGasLimit(toInt(_o["currentGasLimit"]));
m_envInfo.setDifficulty(toInt(_o["currentDifficulty"]));
RLPStream rlpStream; m_envInfo.setNumber(toInt(_o["currentNumber"]));
rlpStream.appendList(BlockInfo::BasicFields); m_envInfo.setTimestamp(toInt(_o["currentTimestamp"]));
m_envInfo.setBeneficiary(Address(_o["currentCoinbase"].get_str()));
rlpStream << h256(_o["previousHash"].get_str()); m_envInfo.setLastHashes( lastHashes( m_envInfo.number() ) );
rlpStream << EmptyListSHA3;
rlpStream << Address(_o["currentCoinbase"].get_str());
rlpStream << h256(); // stateRoot
rlpStream << EmptyTrie; // transactionTrie
rlpStream << EmptyTrie; // receiptTrie
rlpStream << LogBloom(); // bloom
rlpStream << toInt(_o["currentDifficulty"]);
rlpStream << toInt(_o["currentNumber"]);
rlpStream << toInt(_o["currentGasLimit"]);
rlpStream << 0; //gasUsed
rlpStream << toInt(_o["currentTimestamp"]);
rlpStream << std::string(); //extra data
m_environment.currentBlock = BlockInfo(rlpStream.out(), CheckEverything, h256{}, HeaderData);
m_statePre.m_previousBlock = m_environment.previousBlock;
m_statePre.m_currentBlock = m_environment.currentBlock;
} }
// import state from not fully declared json_spirit::mObject, writing to _stateOptionsMap which fields were defined in json // import state from not fully declared json_spirit::mObject, writing to _stateOptionsMap which fields were defined in json
void ImportTest::importState(json_spirit::mObject& _o, State& _state, stateOptionsMap& _stateOptionsMap) void ImportTest::importState(json_spirit::mObject& _o, State& _state, AccountMaskMap& o_mask)
{ {
for (auto& i: _o) std::string jsondata = json_spirit::write_string((json_spirit::mValue)_o, false);
{ _state.populateFrom(jsonToAccountMap(jsondata, &o_mask));
json_spirit::mObject o = i.second.get_obj();
ImportStateOptions stateOptions;
u256 balance = 0;
u256 nonce = 0;
if (o.count("balance") > 0)
{
stateOptions.m_bHasBalance = true;
if (bigint(o["balance"].get_str()) >= c_max256plus1)
BOOST_THROW_EXCEPTION(ValueTooLarge() << errinfo_comment("State 'balance' is equal or greater than 2**256") );
balance = toInt(o["balance"]);
}
if (o.count("nonce") > 0)
{
stateOptions.m_bHasNonce = true;
if (bigint(o["nonce"].get_str()) >= c_max256plus1)
BOOST_THROW_EXCEPTION(ValueTooLarge() << errinfo_comment("State 'nonce' is equal or greater than 2**256") );
nonce = toInt(o["nonce"]);
}
Address address = Address(i.first);
bytes code;
if (o.count("code") > 0)
{
code = importCode(o);
stateOptions.m_bHasCode = true;
}
if (!code.empty())
{
_state.m_cache[address] = Account(balance, Account::ContractConception);
_state.m_cache[address].setCode(std::move(code));
}
else
_state.m_cache[address] = Account(balance, Account::NormalCreation);
if (o.count("storage") > 0)
{
stateOptions.m_bHasStorage = true;
for (auto const& j: o["storage"].get_obj())
_state.setStorage(address, toInt(j.first), toInt(j.second));
}
for (int i = 0; i < nonce; ++i)
_state.noteSending(address);
_state.ensureCached(address, false, false);
_stateOptionsMap[address] = stateOptions;
}
} }
void ImportTest::importState(json_spirit::mObject& _o, State& _state) void ImportTest::importState(json_spirit::mObject& _o, State& _state)
{ {
stateOptionsMap importedMap; AccountMaskMap mask;
importState(_o, _state, importedMap); importState(_o, _state, mask);
for (auto& stateOptionMap : importedMap) for (auto const& i: mask)
{
//check that every parameter was declared in state object //check that every parameter was declared in state object
if (!stateOptionMap.second.isAllSet()) if (!i.second.allSet())
BOOST_THROW_EXCEPTION(MissingFields() << errinfo_comment("Import State: Missing state fields!")); BOOST_THROW_EXCEPTION(MissingFields() << errinfo_comment("Import State: Missing state fields!"));
}
} }
void ImportTest::importTransaction(json_spirit::mObject& _o) void ImportTest::importTransaction(json_spirit::mObject& _o)
@ -285,7 +237,7 @@ void ImportTest::importTransaction(json_spirit::mObject& _o)
} }
} }
void ImportTest::checkExpectedState(State const& _stateExpect, State const& _statePost, stateOptionsMap const _expectedStateOptions, WhenError _throw) void ImportTest::compareStates(State const& _stateExpect, State const& _statePost, AccountMaskMap const _expectedStateOptions, WhenError _throw)
{ {
#define CHECK(a,b) \ #define CHECK(a,b) \
{ \ { \
@ -300,7 +252,7 @@ void ImportTest::checkExpectedState(State const& _stateExpect, State const& _sta
CHECK(_statePost.addressInUse(a.first), "Filling Test: " << a.first << " missing expected address!"); CHECK(_statePost.addressInUse(a.first), "Filling Test: " << a.first << " missing expected address!");
if (_statePost.addressInUse(a.first)) if (_statePost.addressInUse(a.first))
{ {
ImportStateOptions addressOptions(true); AccountMask addressOptions(true);
if(_expectedStateOptions.size()) if(_expectedStateOptions.size())
{ {
try try
@ -314,15 +266,15 @@ void ImportTest::checkExpectedState(State const& _stateExpect, State const& _sta
} }
} }
if (addressOptions.m_bHasBalance) if (addressOptions.hasBalance())
CHECK((_stateExpect.balance(a.first) == _statePost.balance(a.first)), CHECK((_stateExpect.balance(a.first) == _statePost.balance(a.first)),
"Check State: " << a.first << ": incorrect balance " << _statePost.balance(a.first) << ", expected " << _stateExpect.balance(a.first)); "Check State: " << a.first << ": incorrect balance " << _statePost.balance(a.first) << ", expected " << _stateExpect.balance(a.first));
if (addressOptions.m_bHasNonce) if (addressOptions.hasNonce())
CHECK((_stateExpect.transactionsFrom(a.first) == _statePost.transactionsFrom(a.first)), CHECK((_stateExpect.transactionsFrom(a.first) == _statePost.transactionsFrom(a.first)),
"Check State: " << a.first << ": incorrect nonce " << _statePost.transactionsFrom(a.first) << ", expected " << _stateExpect.transactionsFrom(a.first)); "Check State: " << a.first << ": incorrect nonce " << _statePost.transactionsFrom(a.first) << ", expected " << _stateExpect.transactionsFrom(a.first));
if (addressOptions.m_bHasStorage) if (addressOptions.hasStorage())
{ {
unordered_map<u256, u256> stateStorage = _statePost.storage(a.first); unordered_map<u256, u256> stateStorage = _statePost.storage(a.first);
for (auto const& s: _stateExpect.storage(a.first)) for (auto const& s: _stateExpect.storage(a.first))
@ -336,52 +288,52 @@ void ImportTest::checkExpectedState(State const& _stateExpect, State const& _sta
"Check State: " << a.first << ": incorrect storage [" << s.first << "] = " << toHex(s.second) << ", expected [" << s.first << "] = " << toHex(stateStorage[s.first])); "Check State: " << a.first << ": incorrect storage [" << s.first << "] = " << toHex(s.second) << ", expected [" << s.first << "] = " << toHex(stateStorage[s.first]));
} }
if (addressOptions.m_bHasCode) if (addressOptions.hasCode())
CHECK((_stateExpect.code(a.first) == _statePost.code(a.first)), CHECK((_stateExpect.code(a.first) == _statePost.code(a.first)),
"Check State: " << a.first << ": incorrect code '" << toHex(_statePost.code(a.first)) << "', expected '" << toHex(_stateExpect.code(a.first)) << "'"); "Check State: " << a.first << ": incorrect code '" << toHex(_statePost.code(a.first)) << "', expected '" << toHex(_stateExpect.code(a.first)) << "'");
} }
} }
} }
void ImportTest::exportTest(bytes const& _output, State const& _statePost) void ImportTest::exportTest(bytes const& _output)
{ {
// export output // export output
m_TestObject["out"] = (_output.size() > 4096 && !Options::get().fulloutput) ? "#" + toString(_output.size()) : toHex(_output, 2, HexPrefix::Add); m_testObject["out"] = (_output.size() > 4096 && !Options::get().fulloutput) ? "#" + toString(_output.size()) : toHex(_output, 2, HexPrefix::Add);
// compare expected output with post output // compare expected output with post output
if (m_TestObject.count("expectOut") > 0) if (m_testObject.count("expectOut") > 0)
{ {
std::string warning = "Check State: Error! Unexpected output: " + m_TestObject["out"].get_str() + " Expected: " + m_TestObject["expectOut"].get_str(); std::string warning = "Check State: Error! Unexpected output: " + m_testObject["out"].get_str() + " Expected: " + m_testObject["expectOut"].get_str();
if (Options::get().checkState) if (Options::get().checkState)
{TBOOST_CHECK_MESSAGE((m_TestObject["out"].get_str() == m_TestObject["expectOut"].get_str()), warning);} {TBOOST_CHECK_MESSAGE((m_testObject["out"].get_str() == m_testObject["expectOut"].get_str()), warning);}
else else
TBOOST_WARN_MESSAGE((m_TestObject["out"].get_str() == m_TestObject["expectOut"].get_str()), warning); TBOOST_WARN_MESSAGE((m_testObject["out"].get_str() == m_testObject["expectOut"].get_str()), warning);
m_TestObject.erase(m_TestObject.find("expectOut")); m_testObject.erase(m_testObject.find("expectOut"));
} }
// export logs // export logs
m_TestObject["logs"] = exportLog(_statePost.pending().size() ? _statePost.log(0) : LogEntries()); m_testObject["logs"] = exportLog(m_logs);
// compare expected state with post state // compare expected state with post state
if (m_TestObject.count("expect") > 0) if (m_testObject.count("expect") > 0)
{ {
stateOptionsMap stateMap; eth::AccountMaskMap stateMap;
State expectState(OverlayDB(), eth::BaseState::Empty); State expectState(OverlayDB(), eth::BaseState::Empty);
importState(m_TestObject["expect"].get_obj(), expectState, stateMap); importState(m_testObject["expect"].get_obj(), expectState, stateMap);
checkExpectedState(expectState, _statePost, stateMap, Options::get().checkState ? WhenError::Throw : WhenError::DontThrow); compareStates(expectState, m_statePost, stateMap, Options::get().checkState ? WhenError::Throw : WhenError::DontThrow);
m_TestObject.erase(m_TestObject.find("expect")); m_testObject.erase(m_testObject.find("expect"));
} }
// export post state // export post state
m_TestObject["post"] = fillJsonWithState(_statePost); m_testObject["post"] = fillJsonWithState(m_statePost);
m_TestObject["postStateRoot"] = toHex(_statePost.rootHash().asBytes()); m_testObject["postStateRoot"] = toHex(m_statePost.rootHash().asBytes());
// export pre state // export pre state
m_TestObject["pre"] = fillJsonWithState(m_statePre); m_testObject["pre"] = fillJsonWithState(m_statePre);
m_TestObject["env"] = makeAllFieldsHex(m_TestObject["env"].get_obj()); m_testObject["env"] = makeAllFieldsHex(m_testObject["env"].get_obj());
m_TestObject["transaction"] = makeAllFieldsHex(m_TestObject["transaction"].get_obj()); m_testObject["transaction"] = makeAllFieldsHex(m_testObject["transaction"].get_obj());
} }
json_spirit::mObject fillJsonWithTransaction(Transaction _txn) json_spirit::mObject fillJsonWithTransaction(Transaction _txn)
@ -843,7 +795,7 @@ dev::eth::Ethash::BlockHeader constructHeader(
rlpStream << _parentHash << _sha3Uncles << _coinbaseAddress << _stateRoot << _transactionsRoot << _receiptsRoot << _logBloom rlpStream << _parentHash << _sha3Uncles << _coinbaseAddress << _stateRoot << _transactionsRoot << _receiptsRoot << _logBloom
<< _difficulty << _number << _gasLimit << _gasUsed << _timestamp << _extraData << h256{} << Nonce{}; << _difficulty << _number << _gasLimit << _gasUsed << _timestamp << _extraData << h256{} << Nonce{};
return Ethash::BlockHeader(rlpStream.out(), IgnoreSeal, h256{}, HeaderData); return Ethash::BlockHeader(rlpStream.out(), CheckNothing, h256{}, HeaderData);
} }
void updateEthashSeal(dev::eth::Ethash::BlockHeader& _header, h256 const& _mixHash, dev::eth::Nonce const& _nonce) void updateEthashSeal(dev::eth::Ethash::BlockHeader& _header, h256 const& _mixHash, dev::eth::Nonce const& _nonce)
@ -857,7 +809,7 @@ void updateEthashSeal(dev::eth::Ethash::BlockHeader& _header, h256 const& _mixHa
header << sourceRlp[i]; header << sourceRlp[i];
header << _mixHash << _nonce; header << _mixHash << _nonce;
_header = Ethash::BlockHeader(header.out(), IgnoreSeal, h256{}, HeaderData); _header = Ethash::BlockHeader(header.out(), CheckNothing, h256{}, HeaderData);
} }
namespace namespace

42
TestHelper.h
View File

@ -32,6 +32,7 @@
#include <libevm/ExtVMFace.h> #include <libevm/ExtVMFace.h>
#include <libtestutils/Common.h> #include <libtestutils/Common.h>
#ifdef NOBOOST #ifdef NOBOOST
#define TBOOST_REQUIRE(arg) if(arg == false) throw dev::Exception(); #define TBOOST_REQUIRE(arg) if(arg == false) throw dev::Exception();
#define TBOOST_REQUIRE_EQUAL(arg1, arg2) if(arg1 != arg2) throw dev::Exception(); #define TBOOST_REQUIRE_EQUAL(arg1, arg2) if(arg1 != arg2) throw dev::Exception();
@ -62,7 +63,7 @@ class State;
void mine(Client& c, int numBlocks); void mine(Client& c, int numBlocks);
void connectClients(Client& c1, Client& c2); void connectClients(Client& c1, Client& c2);
void mine(State& _s, BlockChain const& _bc); void mine(Block& _s, BlockChain const& _bc);
void mine(Ethash::BlockHeader& _bi); void mine(Ethash::BlockHeader& _bi);
} }
@ -122,45 +123,44 @@ namespace test
} \ } \
while (0) while (0)
struct ImportStateOptions enum class testType
{ {
ImportStateOptions(bool _bSetAll = false):m_bHasBalance(_bSetAll), m_bHasNonce(_bSetAll), m_bHasCode(_bSetAll), m_bHasStorage(_bSetAll) {} StateTests,
bool isAllSet() {return m_bHasBalance && m_bHasNonce && m_bHasCode && m_bHasStorage;} BlockChainTests,
bool m_bHasBalance; Other
bool m_bHasNonce;
bool m_bHasCode;
bool m_bHasStorage;
}; };
typedef std::map<Address, ImportStateOptions> stateOptionsMap;
class ImportTest class ImportTest
{ {
public: public:
ImportTest(json_spirit::mObject& _o): m_TestObject(_o) {} ImportTest(json_spirit::mObject& _o, bool isFiller, testType testTemplate = testType::StateTests);
ImportTest(json_spirit::mObject& _o, bool isFiller);
// imports // imports
void importEnv(json_spirit::mObject& _o); void importEnv(json_spirit::mObject& _o);
static void importState(json_spirit::mObject& _o, eth::State& _state); static void importState(json_spirit::mObject& _o, eth::State& _state);
static void importState(json_spirit::mObject& _o, eth::State& _state, stateOptionsMap& _stateOptionsMap); static void importState(json_spirit::mObject& _o, eth::State& _state, eth::AccountMaskMap& o_mask);
void importTransaction(json_spirit::mObject& _o); void importTransaction(json_spirit::mObject& _o);
static json_spirit::mObject& makeAllFieldsHex(json_spirit::mObject& _o); static json_spirit::mObject& makeAllFieldsHex(json_spirit::mObject& _o);
void exportTest(bytes const& _output, eth::State const& _statePost); bytes executeTest();
static void checkExpectedState(eth::State const& _stateExpect, eth::State const& _statePost, stateOptionsMap const _expectedStateOptions = stateOptionsMap(), WhenError _throw = WhenError::Throw); void exportTest(bytes const& _output);
static void compareStates(eth::State const& _stateExpect, eth::State const& _statePost, eth::AccountMaskMap const _expectedStateOptions = eth::AccountMaskMap(), WhenError _throw = WhenError::Throw);
eth::State m_statePre; eth::State m_statePre;
eth::State m_statePost; eth::State m_statePost;
eth::ExtVMFace m_environment; eth::EnvInfo m_envInfo;
eth::Transaction m_transaction; eth::Transaction m_transaction;
eth::LogEntries m_logs;
eth::LogEntries m_logsExpected;
private: private:
json_spirit::mObject& m_TestObject; json_spirit::mObject& m_testObject;
}; };
class ZeroGasPricer: public eth::GasPricer class ZeroGasPricer: public eth::GasPricer
{ {
protected: protected:
u256 ask(eth::State const&) const override { return 0; } u256 ask(eth::Block const&) const override { return 0; }
u256 bid(eth::TransactionPriority = eth::TransactionPriority::Medium) const override { return 0; } u256 bid(eth::TransactionPriority = eth::TransactionPriority::Medium) const override { return 0; }
}; };
@ -205,7 +205,7 @@ void doVMTests(json_spirit::mValue& v, bool _fillin);
void doBlockchainTests(json_spirit::mValue& _v, bool _fillin); void doBlockchainTests(json_spirit::mValue& _v, bool _fillin);
void doRlpTests(json_spirit::mValue& v, bool _fillin); void doRlpTests(json_spirit::mValue& v, bool _fillin);
template<typename mapType> /*template<typename mapType>
void checkAddresses(mapType& _expectedAddrs, mapType& _resultAddrs) void checkAddresses(mapType& _expectedAddrs, mapType& _resultAddrs)
{ {
for (auto& resultPair : _resultAddrs) for (auto& resultPair : _resultAddrs)
@ -216,7 +216,7 @@ void checkAddresses(mapType& _expectedAddrs, mapType& _resultAddrs)
TBOOST_ERROR("Missing result address " << resultAddr); TBOOST_ERROR("Missing result address " << resultAddr);
} }
TBOOST_CHECK((_expectedAddrs == _resultAddrs)); TBOOST_CHECK((_expectedAddrs == _resultAddrs));
} }*/
class Options class Options
{ {
@ -239,7 +239,7 @@ public:
bool inputLimits = false; bool inputLimits = false;
bool bigData = false; bool bigData = false;
bool wallet = false; bool wallet = false;
bool nonetwork = false; bool nonetwork = true;
bool nodag = true; bool nodag = true;
/// @} /// @}

13
TestUtils.cpp
View File

@ -101,7 +101,9 @@ void ClientBaseFixture::enumerateClients(std::function<void(Json::Value const&,
{ {
enumerateBlockchains([&callback](Json::Value const& _json, BlockChain const& _bc, State _state) -> void enumerateBlockchains([&callback](Json::Value const& _json, BlockChain const& _bc, State _state) -> void
{ {
FixedClient client(_bc, _state); cerr << "void ClientBaseFixture::enumerateClients. FixedClient now accepts block not sate!" << endl;
_state.commit(); //unused variable. remove this line
FixedClient client(_bc, eth::Block {});
callback(_json, client); callback(_json, client);
}); });
} }
@ -118,12 +120,3 @@ void ParallelClientBaseFixture::enumerateClients(std::function<void(Json::Value
}); });
} }
MoveNonceToTempDir::MoveNonceToTempDir()
{
crypto::Nonce::setSeedFilePath(m_dir.path() + "/seed");
}
MoveNonceToTempDir::~MoveNonceToTempDir()
{
crypto::Nonce::reset();
}

8
TestUtils.h
View File

@ -79,13 +79,5 @@ struct JsonRpcFixture: public ClientBaseFixture
}; };
struct MoveNonceToTempDir
{
MoveNonceToTempDir();
~MoveNonceToTempDir();
private:
TransientDirectory m_dir;
};
} }
} }

497
contracts/AuctionRegistrar.cpp Normal file
View File

@ -0,0 +1,497 @@
/*
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 2015
* Tests for a fixed fee registrar contract.
*/
#include <string>
#include <tuple>
#include <boost/test/unit_test.hpp>
#include <libdevcore/Hash.h>
#include <libethcore/ABI.h>
#include <test/libsolidity/solidityExecutionFramework.h>
using namespace std;
namespace dev
{
namespace solidity
{
namespace test
{
namespace
{
static char const* registrarCode = R"DELIMITER(
//sol
contract NameRegister {
function addr(string _name) constant returns (address o_owner);
function name(address _owner) constant returns (string o_name);
}
contract Registrar is NameRegister {
event Changed(string indexed name);
event PrimaryChanged(string indexed name, address indexed addr);
function owner(string _name) constant returns (address o_owner);
function addr(string _name) constant returns (address o_address);
function subRegistrar(string _name) constant returns (address o_subRegistrar);
function content(string _name) constant returns (bytes32 o_content);
function name(address _owner) constant returns (string o_name);
}
contract AuctionSystem {
event AuctionEnded(string indexed _name, address _winner);
event NewBid(string indexed _name, address _bidder, uint _value);
/// Function that is called once an auction ends.
function onAuctionEnd(string _name) internal;
function bid(string _name, address _bidder, uint _value) internal {
var auction = m_auctions[_name];
if (auction.endDate > 0 && now > auction.endDate)
{
AuctionEnded(_name, auction.highestBidder);
onAuctionEnd(_name);
delete m_auctions[_name];
return;
}
if (msg.value > auction.highestBid)
{
// new bid on auction
auction.secondHighestBid = auction.highestBid;
auction.sumOfBids += _value;
auction.highestBid = _value;
auction.highestBidder = _bidder;
auction.endDate = now + c_biddingTime;
NewBid(_name, _bidder, _value);
}
}
uint constant c_biddingTime = 7 days;
struct Auction {
address highestBidder;
uint highestBid;
uint secondHighestBid;
uint sumOfBids;
uint endDate;
}
mapping(string => Auction) m_auctions;
}
contract GlobalRegistrar is Registrar, AuctionSystem {
struct Record {
address owner;
address primary;
address subRegistrar;
bytes32 content;
uint renewalDate;
}
uint constant c_renewalInterval = 1 years;
uint constant c_freeBytes = 12;
function Registrar() {
// TODO: Populate with hall-of-fame.
}
function() {
// prevent people from just sending funds to the registrar
__throw();
}
function onAuctionEnd(string _name) internal {
var auction = m_auctions[_name];
var record = m_toRecord[_name];
if (record.owner != 0)
record.owner.send(auction.sumOfBids - auction.highestBid / 100);
else
auction.highestBidder.send(auction.highestBid - auction.secondHighestBid);
record.renewalDate = now + c_renewalInterval;
record.owner = auction.highestBidder;
Changed(_name);
}
function reserve(string _name) external {
if (bytes(_name).length == 0)
__throw();
bool needAuction = requiresAuction(_name);
if (needAuction)
{
if (now < m_toRecord[_name].renewalDate)
__throw();
bid(_name, msg.sender, msg.value);
}
else
{
Record record = m_toRecord[_name];
if (record.owner != 0)
__throw();
m_toRecord[_name].owner = msg.sender;
Changed(_name);
}
}
function requiresAuction(string _name) internal returns (bool) {
return bytes(_name).length < c_freeBytes;
}
modifier onlyrecordowner(string _name) { if (m_toRecord[_name].owner == msg.sender) _ }
function transfer(string _name, address _newOwner) onlyrecordowner(_name) {
m_toRecord[_name].owner = _newOwner;
Changed(_name);
}
function disown(string _name) onlyrecordowner(_name) {
if (stringsEqual(m_toName[m_toRecord[_name].primary], _name))
{
PrimaryChanged(_name, m_toRecord[_name].primary);
m_toName[m_toRecord[_name].primary] = "";
}
delete m_toRecord[_name];
Changed(_name);
}
function setAddress(string _name, address _a, bool _primary) onlyrecordowner(_name) {
m_toRecord[_name].primary = _a;
if (_primary)
{
PrimaryChanged(_name, _a);
m_toName[_a] = _name;
}
Changed(_name);
}
function setSubRegistrar(string _name, address _registrar) onlyrecordowner(_name) {
m_toRecord[_name].subRegistrar = _registrar;
Changed(_name);
}
function setContent(string _name, bytes32 _content) onlyrecordowner(_name) {
m_toRecord[_name].content = _content;
Changed(_name);
}
function stringsEqual(string storage _a, string memory _b) internal returns (bool) {
bytes storage a = bytes(_a);
bytes memory b = bytes(_b);
if (a.length != b.length)
return false;
// @todo unroll this loop
for (uint i = 0; i < a.length; i ++)
if (a[i] != b[i])
return false;
return true;
}
function owner(string _name) constant returns (address) { return m_toRecord[_name].owner; }
function addr(string _name) constant returns (address) { return m_toRecord[_name].primary; }
function subRegistrar(string _name) constant returns (address) { return m_toRecord[_name].subRegistrar; }
function content(string _name) constant returns (bytes32) { return m_toRecord[_name].content; }
function name(address _addr) constant returns (string o_name) { return m_toName[_addr]; }
function __throw() internal {
// workaround until we have "throw"
uint[] x; x[1];
}
mapping (address => string) m_toName;
mapping (string => Record) m_toRecord;
}
)DELIMITER";
static unique_ptr<bytes> s_compiledRegistrar;
class AuctionRegistrarTestFramework: public ExecutionFramework
{
protected:
void deployRegistrar()
{
if (!s_compiledRegistrar)
{
m_optimize = true;
m_compiler.reset(false, m_addStandardSources);
m_compiler.addSource("", registrarCode);
ETH_TEST_REQUIRE_NO_THROW(m_compiler.compile(m_optimize, m_optimizeRuns), "Compiling contract failed");
s_compiledRegistrar.reset(new bytes(m_compiler.getBytecode("GlobalRegistrar")));
}
sendMessage(*s_compiledRegistrar, true);
BOOST_REQUIRE(!m_output.empty());
}
using ContractInterface = ExecutionFramework::ContractInterface;
class RegistrarInterface: public ContractInterface
{
public:
RegistrarInterface(ExecutionFramework& _framework): ContractInterface(_framework) {}
void reserve(string const& _name)
{
callString("reserve", _name);
}
u160 owner(string const& _name)
{
return callStringReturnsAddress("owner", _name);
}
void setAddress(string const& _name, u160 const& _address, bool _primary)
{
callStringAddressBool("setAddress", _name, _address, _primary);
}
u160 addr(string const& _name)
{
return callStringReturnsAddress("addr", _name);
}
string name(u160 const& _addr)
{
return callAddressReturnsString("name", _addr);
}
void setSubRegistrar(string const& _name, u160 const& _address)
{
callStringAddress("setSubRegistrar", _name, _address);
}
u160 subRegistrar(string const& _name)
{
return callStringReturnsAddress("subRegistrar", _name);
}
void setContent(string const& _name, h256 const& _content)
{
callStringBytes32("setContent", _name, _content);
}
h256 content(string const& _name)
{
return callStringReturnsBytes32("content", _name);
}
void transfer(string const& _name, u160 const& _target)
{
return callStringAddress("transfer", _name, _target);
}
void disown(string const& _name)
{
return callString("disown", _name);
}
};
u256 const m_biddingTime = u256(7 * 24 * 3600);
u256 const m_renewalInterval = u256(365 * 24 * 3600);
};
}
/// This is a test suite that tests optimised code!
BOOST_FIXTURE_TEST_SUITE(SolidityAuctionRegistrar, AuctionRegistrarTestFramework)
BOOST_AUTO_TEST_CASE(creation)
{
deployRegistrar();
}
BOOST_AUTO_TEST_CASE(reserve)
{
// Test that reserving works for long strings
deployRegistrar();
vector<string> names{"abcabcabcabcabc", "defdefdefdefdef", "ghighighighighighighighighighighighighighighi"};
m_sender = Address(0x123);
RegistrarInterface registrar(*this);
// should not work
registrar.reserve("");
BOOST_CHECK_EQUAL(registrar.owner(""), u160(0));
for (auto const& name: names)
{
registrar.reserve(name);
BOOST_CHECK_EQUAL(registrar.owner(name), u160(0x123));
}
}
BOOST_AUTO_TEST_CASE(double_reserve_long)
{
// Test that it is not possible to re-reserve from a different address.
deployRegistrar();
string name = "abcabcabcabcabcabcabcabcabcabca";
m_sender = Address(0x123);
RegistrarInterface registrar(*this);
registrar.reserve(name);
BOOST_CHECK_EQUAL(registrar.owner(name), u160(0x123));
m_sender = Address(0x124);
registrar.reserve(name);
BOOST_CHECK_EQUAL(registrar.owner(name), u160(0x123));
}
BOOST_AUTO_TEST_CASE(properties)
{
// Test setting and retrieving the various properties works.
deployRegistrar();
RegistrarInterface registrar(*this);
string names[] = {"abcaeouoeuaoeuaoeu", "defncboagufra,fui", "ghagpyajfbcuajouhaeoi"};
size_t addr = 0x9872543;
for (string const& name: names)
{
addr++;
size_t sender = addr + 10007;
m_sender = Address(sender);
// setting by sender works
registrar.reserve(name);
BOOST_CHECK_EQUAL(registrar.owner(name), u160(sender));
registrar.setAddress(name, addr, true);
BOOST_CHECK_EQUAL(registrar.addr(name), u160(addr));
registrar.setSubRegistrar(name, addr + 20);
BOOST_CHECK_EQUAL(registrar.subRegistrar(name), u160(addr + 20));
registrar.setContent(name, h256(u256(addr + 90)));
BOOST_CHECK_EQUAL(registrar.content(name), h256(u256(addr + 90)));
// but not by someone else
m_sender = Address(h256(addr + 10007 - 1));
BOOST_CHECK_EQUAL(registrar.owner(name), u160(sender));
registrar.setAddress(name, addr + 1, true);
BOOST_CHECK_EQUAL(registrar.addr(name), u160(addr));
registrar.setSubRegistrar(name, addr + 20 + 1);
BOOST_CHECK_EQUAL(registrar.subRegistrar(name), u160(addr + 20));
registrar.setContent(name, h256(u256(addr + 90 + 1)));
BOOST_CHECK_EQUAL(registrar.content(name), h256(u256(addr + 90)));
}
}
BOOST_AUTO_TEST_CASE(transfer)
{
deployRegistrar();
string name = "abcaoeguaoucaeoduceo";
m_sender = Address(0x123);
RegistrarInterface registrar(*this);
registrar.reserve(name);
registrar.setContent(name, h256(u256(123)));
registrar.transfer(name, u160(555));
BOOST_CHECK_EQUAL(registrar.owner(name), u160(555));
BOOST_CHECK_EQUAL(registrar.content(name), h256(u256(123)));
}
BOOST_AUTO_TEST_CASE(disown)
{
deployRegistrar();
string name = "abcaoeguaoucaeoduceo";
m_sender = Address(0x123);
RegistrarInterface registrar(*this);
registrar.reserve(name);
registrar.setContent(name, h256(u256(123)));
registrar.setAddress(name, u160(124), true);
registrar.setSubRegistrar(name, u160(125));
BOOST_CHECK_EQUAL(registrar.name(u160(124)), name);
// someone else tries disowning
m_sender = Address(0x128);
registrar.disown(name);
BOOST_CHECK_EQUAL(registrar.owner(name), 0x123);
m_sender = Address(0x123);
registrar.disown(name);
BOOST_CHECK_EQUAL(registrar.owner(name), 0);
BOOST_CHECK_EQUAL(registrar.addr(name), 0);
BOOST_CHECK_EQUAL(registrar.subRegistrar(name), 0);
BOOST_CHECK_EQUAL(registrar.content(name), h256());
BOOST_CHECK_EQUAL(registrar.name(u160(124)), "");
}
BOOST_AUTO_TEST_CASE(auction_simple)
{
deployRegistrar();
string name = "x";
m_sender = Address(0x123);
RegistrarInterface registrar(*this);
// initiate auction
registrar.setNextValue(8);
registrar.reserve(name);
BOOST_CHECK_EQUAL(registrar.owner(name), 0);
// "wait" until auction end
m_envInfo.setTimestamp(m_envInfo.timestamp() + m_biddingTime + 10);
// trigger auction again
registrar.reserve(name);
BOOST_CHECK_EQUAL(registrar.owner(name), 0x123);
}
BOOST_AUTO_TEST_CASE(auction_bidding)
{
deployRegistrar();
string name = "x";
m_sender = Address(0x123);
RegistrarInterface registrar(*this);
// initiate auction
registrar.setNextValue(8);
registrar.reserve(name);
BOOST_CHECK_EQUAL(registrar.owner(name), 0);
// overbid self
m_envInfo.setTimestamp(m_biddingTime - 10);
registrar.setNextValue(12);
registrar.reserve(name);
// another bid by someone else
m_sender = Address(0x124);
m_envInfo.setTimestamp(2 * m_biddingTime - 50);
registrar.setNextValue(13);
registrar.reserve(name);
BOOST_CHECK_EQUAL(registrar.owner(name), 0);
// end auction by first bidder (which is not highest) trying to overbid again (too late)
m_sender = Address(0x123);
m_envInfo.setTimestamp(4 * m_biddingTime);
registrar.setNextValue(20);
registrar.reserve(name);
BOOST_CHECK_EQUAL(registrar.owner(name), 0x124);
}
BOOST_AUTO_TEST_CASE(auction_renewal)
{
deployRegistrar();
string name = "x";
RegistrarInterface registrar(*this);
// register name by auction
m_sender = Address(0x123);
registrar.setNextValue(8);
registrar.reserve(name);
m_envInfo.setTimestamp(4 * m_biddingTime);
registrar.reserve(name);
BOOST_CHECK_EQUAL(registrar.owner(name), 0x123);
// try to re-register before interval end
m_sender = Address(0x222);
registrar.setNextValue(80);
m_envInfo.setTimestamp(m_envInfo.timestamp() + m_renewalInterval - 1);
registrar.reserve(name);
m_envInfo.setTimestamp(m_envInfo.timestamp() + m_biddingTime);
// if there is a bug in the renewal logic, this would transfer the ownership to 0x222,
// but if there is no bug, this will initiate the auction, albeit with a zero bid
registrar.reserve(name);
BOOST_CHECK_EQUAL(registrar.owner(name), 0x123);
m_envInfo.setTimestamp(m_envInfo.timestamp() + 2);
registrar.setNextValue(80);
registrar.reserve(name);
BOOST_CHECK_EQUAL(registrar.owner(name), 0x123);
m_envInfo.setTimestamp(m_envInfo.timestamp() + m_biddingTime + 2);
registrar.reserve(name);
BOOST_CHECK_EQUAL(registrar.owner(name), 0x222);
}
BOOST_AUTO_TEST_SUITE_END()
}
}
} // end namespaces

5
contracts/CMakeLists.txt Normal file
View File

@ -0,0 +1,5 @@
cmake_policy(SET CMP0015 NEW)
aux_source_directory(. SRCS)
add_sources(${SRCS})

242
contracts/FixedFeeRegistrar.cpp Normal file
View File

@ -0,0 +1,242 @@
/*
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 2015
* Tests for a fixed fee registrar contract.
*/
#include <string>
#include <tuple>
#include <boost/test/unit_test.hpp>
#include <libdevcore/Hash.h>
#include <test/libsolidity/solidityExecutionFramework.h>
using namespace std;
namespace dev
{
namespace solidity
{
namespace test
{
namespace
{
static char const* registrarCode = R"DELIMITER(
//sol FixedFeeRegistrar
// Simple global registrar with fixed-fee reservations.
// @authors:
// Gav Wood <g@ethdev.com>
contract Registrar {
event Changed(string indexed name);
function owner(string _name) constant returns (address o_owner);
function addr(string _name) constant returns (address o_address);
function subRegistrar(string _name) constant returns (address o_subRegistrar);
function content(string _name) constant returns (bytes32 o_content);
}
contract FixedFeeRegistrar is Registrar {
struct Record {
address addr;
address subRegistrar;
bytes32 content;
address owner;
}
modifier onlyrecordowner(string _name) { if (m_record(_name).owner == msg.sender) _ }
function reserve(string _name) {
Record rec = m_record(_name);
if (rec.owner == 0 && msg.value >= c_fee) {
rec.owner = msg.sender;
Changed(_name);
}
}
function disown(string _name, address _refund) onlyrecordowner(_name) {
delete m_recordData[uint(sha3(_name)) / 8];
_refund.send(c_fee);
Changed(_name);
}
function transfer(string _name, address _newOwner) onlyrecordowner(_name) {
m_record(_name).owner = _newOwner;
Changed(_name);
}
function setAddr(string _name, address _a) onlyrecordowner(_name) {
m_record(_name).addr = _a;
Changed(_name);
}
function setSubRegistrar(string _name, address _registrar) onlyrecordowner(_name) {
m_record(_name).subRegistrar = _registrar;
Changed(_name);
}
function setContent(string _name, bytes32 _content) onlyrecordowner(_name) {
m_record(_name).content = _content;
Changed(_name);
}
function record(string _name) constant returns (address o_addr, address o_subRegistrar, bytes32 o_content, address o_owner) {
Record rec = m_record(_name);
o_addr = rec.addr;
o_subRegistrar = rec.subRegistrar;
o_content = rec.content;
o_owner = rec.owner;
}
function addr(string _name) constant returns (address) { return m_record(_name).addr; }
function subRegistrar(string _name) constant returns (address) { return m_record(_name).subRegistrar; }
function content(string _name) constant returns (bytes32) { return m_record(_name).content; }
function owner(string _name) constant returns (address) { return m_record(_name).owner; }
Record[2**253] m_recordData;
function m_record(string _name) constant internal returns (Record storage o_record) {
return m_recordData[uint(sha3(_name)) / 8];
}
uint constant c_fee = 69 ether;
}
)DELIMITER";
static unique_ptr<bytes> s_compiledRegistrar;
class RegistrarTestFramework: public ExecutionFramework
{
protected:
void deployRegistrar()
{
if (!s_compiledRegistrar)
{
m_optimize = true;
m_compiler.reset(false, m_addStandardSources);
m_compiler.addSource("", registrarCode);
ETH_TEST_REQUIRE_NO_THROW(m_compiler.compile(m_optimize, m_optimizeRuns), "Compiling contract failed");
s_compiledRegistrar.reset(new bytes(m_compiler.getBytecode("FixedFeeRegistrar")));
}
sendMessage(*s_compiledRegistrar, true);
BOOST_REQUIRE(!m_output.empty());
}
u256 const m_fee = u256("69000000000000000000");
};
}
/// This is a test suite that tests optimised code!
BOOST_FIXTURE_TEST_SUITE(SolidityFixedFeeRegistrar, RegistrarTestFramework)
BOOST_AUTO_TEST_CASE(creation)
{
deployRegistrar();
}
BOOST_AUTO_TEST_CASE(reserve)
{
// Test that reserving works and fee is taken into account.
deployRegistrar();
string name[] = {"abc", "def", "ghi"};
m_sender = Address(0x123);
BOOST_REQUIRE(callContractFunctionWithValue("reserve(string)", m_fee, encodeDyn(name[0])) == encodeArgs());
BOOST_CHECK(callContractFunction("owner(string)", encodeDyn(name[0])) == encodeArgs(h256(0x123)));
BOOST_REQUIRE(callContractFunctionWithValue("reserve(string)", m_fee + 1, encodeDyn(name[1])) == encodeArgs());
BOOST_CHECK(callContractFunction("owner(string)", encodeDyn(name[1])) == encodeArgs(h256(0x123)));
BOOST_REQUIRE(callContractFunctionWithValue("reserve(string)", m_fee - 1, encodeDyn(name[2])) == encodeArgs());
BOOST_CHECK(callContractFunction("owner(string)", encodeDyn(name[2])) == encodeArgs(h256(0)));
}
BOOST_AUTO_TEST_CASE(double_reserve)
{
// Test that it is not possible to re-reserve from a different address.
deployRegistrar();
string name = "abc";
m_sender = Address(0x123);
BOOST_REQUIRE(callContractFunctionWithValue("reserve(string)", m_fee, encodeDyn(name)) == encodeArgs());
BOOST_CHECK(callContractFunction("owner(string)", encodeDyn(name)) == encodeArgs(h256(0x123)));
m_sender = Address(0x124);
BOOST_REQUIRE(callContractFunctionWithValue("reserve(string)", m_fee, encodeDyn(name)) == encodeArgs());
BOOST_CHECK(callContractFunction("owner(string)", encodeDyn(name)) == encodeArgs(h256(0x123)));
}
BOOST_AUTO_TEST_CASE(properties)
{
// Test setting and retrieving the various properties works.
deployRegistrar();
string names[] = {"abc", "def", "ghi"};
size_t addr = 0x9872543;
for (string const& name: names)
{
addr++;
size_t sender = addr + 10007;
m_sender = Address(sender);
// setting by sender works
BOOST_REQUIRE(callContractFunctionWithValue("reserve(string)", m_fee, encodeDyn(name)) == encodeArgs());
BOOST_CHECK(callContractFunction("owner(string)", encodeDyn(name)) == encodeArgs(u256(sender)));
BOOST_CHECK(callContractFunction("setAddr(string,address)", u256(0x40), u256(addr), u256(name.length()), name) == encodeArgs());
BOOST_CHECK(callContractFunction("addr(string)", encodeDyn(name)) == encodeArgs(addr));
BOOST_CHECK(callContractFunction("setSubRegistrar(string,address)", u256(0x40), addr + 20, u256(name.length()), name) == encodeArgs());
BOOST_CHECK(callContractFunction("subRegistrar(string)", encodeDyn(name)) == encodeArgs(addr + 20));
BOOST_CHECK(callContractFunction("setContent(string,bytes32)", u256(0x40), addr + 90, u256(name.length()), name) == encodeArgs());
BOOST_CHECK(callContractFunction("content(string)", encodeDyn(name)) == encodeArgs(addr + 90));
// but not by someone else
m_sender = Address(h256(addr + 10007 - 1));
BOOST_CHECK(callContractFunction("owner(string)", encodeDyn(name)) == encodeArgs(sender));
BOOST_CHECK(callContractFunction("setAddr(string,address)", u256(0x40), addr + 1, u256(name.length()), name) == encodeArgs());
BOOST_CHECK(callContractFunction("addr(string)", encodeDyn(name)) == encodeArgs(addr));
BOOST_CHECK(callContractFunction("setSubRegistrar(string,address)", u256(0x40), addr + 20 + 1, u256(name.length()), name) == encodeArgs());
BOOST_CHECK(callContractFunction("subRegistrar(string)", encodeDyn(name)) == encodeArgs(addr + 20));
BOOST_CHECK(callContractFunction("setContent(string,bytes32)", u256(0x40), addr + 90 + 1, u256(name.length()), name) == encodeArgs());
BOOST_CHECK(callContractFunction("content(string)", encodeDyn(name)) == encodeArgs(addr + 90));
}
}
BOOST_AUTO_TEST_CASE(transfer)
{
deployRegistrar();
string name = "abc";
m_sender = Address(0x123);
BOOST_REQUIRE(callContractFunctionWithValue("reserve(string)", m_fee, encodeDyn(name)) == encodeArgs());
BOOST_CHECK(callContractFunction("setContent(string,bytes32)", u256(0x40), u256(123), u256(name.length()), name) == encodeArgs());
BOOST_CHECK(callContractFunction("transfer(string,address)", u256(0x40), u256(555), u256(name.length()), name) == encodeArgs());
BOOST_CHECK(callContractFunction("owner(string)", encodeDyn(name)) == encodeArgs(u256(555)));
BOOST_CHECK(callContractFunction("content(string)", encodeDyn(name)) == encodeArgs(u256(123)));
}
BOOST_AUTO_TEST_CASE(disown)
{
deployRegistrar();
string name = "abc";
m_sender = Address(0x123);
BOOST_REQUIRE(callContractFunctionWithValue("reserve(string)", m_fee, encodeDyn(name)) == encodeArgs());
BOOST_CHECK(callContractFunction("setContent(string,bytes32)", u256(0x40), u256(123), u256(name.length()), name) == encodeArgs());
BOOST_CHECK(callContractFunction("setAddr(string,address)", u256(0x40), u256(124), u256(name.length()), name) == encodeArgs());
BOOST_CHECK(callContractFunction("setSubRegistrar(string,address)", u256(0x40), u256(125), u256(name.length()), name) == encodeArgs());
BOOST_CHECK_EQUAL(m_state.balance(Address(0x124)), 0);
BOOST_CHECK(callContractFunction("disown(string,address)", u256(0x40), u256(0x124), name.size(), name) == encodeArgs());
BOOST_CHECK_EQUAL(m_state.balance(Address(0x124)), m_fee);
BOOST_CHECK(callContractFunction("owner(string)", encodeDyn(name)) == encodeArgs(u256(0)));
BOOST_CHECK(callContractFunction("content(string)", encodeDyn(name)) == encodeArgs(u256(0)));
BOOST_CHECK(callContractFunction("addr(string)", encodeDyn(name)) == encodeArgs(u256(0)));
BOOST_CHECK(callContractFunction("subRegistrar(string)", encodeDyn(name)) == encodeArgs(u256(0)));
}
BOOST_AUTO_TEST_SUITE_END()
}
}
} // end namespaces

4
libsolidity/SolidityWallet.cpp → contracts/Wallet.cpp
View File

@ -545,7 +545,7 @@ BOOST_AUTO_TEST_CASE(multisig_value_transfer)
// 4 owners, set required to 3 // 4 owners, set required to 3
BOOST_REQUIRE(callContractFunction("changeRequirement(uint256)", u256(3)) == encodeArgs()); BOOST_REQUIRE(callContractFunction("changeRequirement(uint256)", u256(3)) == encodeArgs());
// check that balance is and stays zero at destination address // check that balance is and stays zero at destination address
h256 opHash("8f27f478ebcfaf28b0c354f4809ace8087000d668b89c8bc3b1b608bfdbe6654"); h256 opHash("6244b4fa93f73e09db0ae52750095ca0364a76b72bc01723c97011fcb876cc9e");
BOOST_CHECK_EQUAL(m_state.balance(Address(0x05)), 0); BOOST_CHECK_EQUAL(m_state.balance(Address(0x05)), 0);
m_sender = Address(0x12); m_sender = Address(0x12);
BOOST_REQUIRE(callContractFunction("execute(address,uint256,bytes)", h256(0x05), 100, 0x60, 0x00) == encodeArgs(opHash)); BOOST_REQUIRE(callContractFunction("execute(address,uint256,bytes)", h256(0x05), 100, 0x60, 0x00) == encodeArgs(opHash));
@ -596,7 +596,7 @@ BOOST_AUTO_TEST_CASE(revoke_transaction)
BOOST_REQUIRE(callContractFunction("changeRequirement(uint256)", u256(3)) == encodeArgs()); BOOST_REQUIRE(callContractFunction("changeRequirement(uint256)", u256(3)) == encodeArgs());
// create a transaction // create a transaction
Address deployer = m_sender; Address deployer = m_sender;
h256 opHash("8f27f478ebcfaf28b0c354f4809ace8087000d668b89c8bc3b1b608bfdbe6654"); h256 opHash("6244b4fa93f73e09db0ae52750095ca0364a76b72bc01723c97011fcb876cc9e");
BOOST_CHECK_EQUAL(m_state.balance(Address(0x05)), 0); BOOST_CHECK_EQUAL(m_state.balance(Address(0x05)), 0);
m_sender = Address(0x12); m_sender = Address(0x12);
BOOST_REQUIRE(callContractFunction("execute(address,uint256,bytes)", h256(0x05), 100, 0x60, 0x00) == encodeArgs(opHash)); BOOST_REQUIRE(callContractFunction("execute(address,uint256,bytes)", h256(0x05), 100, 0x60, 0x00) == encodeArgs(opHash));

70
libsolidity/SolidityEndToEndTest.cpp
View File

@ -1151,8 +1151,10 @@ BOOST_AUTO_TEST_CASE(blockchain)
" blockNumber = block.number;\n" " blockNumber = block.number;\n"
" }\n" " }\n"
"}\n"; "}\n";
m_envInfo.setBeneficiary(Address(0x123));
m_envInfo.setNumber(7);
compileAndRun(sourceCode, 27); compileAndRun(sourceCode, 27);
BOOST_CHECK(callContractFunctionWithValue("someInfo()", 28) == encodeArgs(28, 0, 1)); BOOST_CHECK(callContractFunctionWithValue("someInfo()", 28) == encodeArgs(28, 0x123, 7));
} }
BOOST_AUTO_TEST_CASE(msg_sig) BOOST_AUTO_TEST_CASE(msg_sig)
@ -1187,12 +1189,14 @@ BOOST_AUTO_TEST_CASE(msg_sig_after_internal_call_is_same)
BOOST_AUTO_TEST_CASE(now) BOOST_AUTO_TEST_CASE(now)
{ {
char const* sourceCode = "contract test {\n" char const* sourceCode = "contract test {\n"
" function someInfo() returns (bool success) {\n" " function someInfo() returns (bool equal, uint val) {\n"
" return block.timestamp == now && now > 0;\n" " equal = block.timestamp == now;\n"
" val = now;\n"
" }\n" " }\n"
"}\n"; "}\n";
m_envInfo.setTimestamp(9);
compileAndRun(sourceCode); compileAndRun(sourceCode);
BOOST_CHECK(callContractFunction("someInfo()") == encodeArgs(true)); BOOST_CHECK(callContractFunction("someInfo()") == encodeArgs(true, 9));
} }
BOOST_AUTO_TEST_CASE(type_conversions_cleanup) BOOST_AUTO_TEST_CASE(type_conversions_cleanup)
@ -5099,6 +5103,64 @@ BOOST_AUTO_TEST_CASE(memory_structs_with_mappings)
BOOST_CHECK(callContractFunction("f()") == encodeArgs(u256(0))); BOOST_CHECK(callContractFunction("f()") == encodeArgs(u256(0)));
} }
BOOST_AUTO_TEST_CASE(string_bytes_conversion)
{
char const* sourceCode = R"(
contract Test {
string s;
bytes b;
function f(string _s, uint n) returns (byte) {
b = bytes(_s);
s = string(b);
return bytes(s)[n];
}
function l() returns (uint) { return bytes(s).length; }
}
)";
compileAndRun(sourceCode, 0, "Test");
BOOST_CHECK(callContractFunction(
"f(string,uint256)",
u256(0x40),
u256(2),
u256(6),
string("abcdef")
) == encodeArgs("c"));
BOOST_CHECK(callContractFunction("l()") == encodeArgs(u256(6)));
}
BOOST_AUTO_TEST_CASE(string_as_mapping_key)
{
char const* sourceCode = R"(
contract Test {
mapping(string => uint) data;
function set(string _s, uint _v) { data[_s] = _v; }
function get(string _s) returns (uint) { return data[_s]; }
}
)";
compileAndRun(sourceCode, 0, "Test");
vector<string> strings{
"Hello, World!",
"Hello, World!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!1111",
"",
"1"
};
for (unsigned i = 0; i < strings.size(); i++)
BOOST_CHECK(callContractFunction(
"set(string,uint256)",
u256(0x40),
u256(7 + i),
u256(strings[i].size()),
strings[i]
) == encodeArgs());
for (unsigned i = 0; i < strings.size(); i++)
BOOST_CHECK(callContractFunction(
"get(string)",
u256(0x20),
u256(strings[i].size()),
strings[i]
) == encodeArgs(u256(7 + i)));
}
BOOST_AUTO_TEST_SUITE_END() BOOST_AUTO_TEST_SUITE_END()
} }

45
libsolidity/SolidityNameAndTypeResolution.cpp
View File

@ -1883,6 +1883,34 @@ BOOST_AUTO_TEST_CASE(positive_integers_to_unsigned_out_of_bound)
BOOST_CHECK_THROW(parseTextAndResolveNames(sourceCode), TypeError); BOOST_CHECK_THROW(parseTextAndResolveNames(sourceCode), TypeError);
} }
BOOST_AUTO_TEST_CASE(integer_boolean_operators)
{
char const* sourceCode1 = R"(
contract test { function() { uint x = 1; uint y = 2; x || y; } }
)";
BOOST_CHECK_THROW(parseTextAndResolveNames(sourceCode1), TypeError);
char const* sourceCode2 = R"(
contract test { function() { uint x = 1; uint y = 2; x && y; } }
)";
BOOST_CHECK_THROW(parseTextAndResolveNames(sourceCode2), TypeError);
char const* sourceCode3 = R"(
contract test { function() { uint x = 1; !x; } }
)";
BOOST_CHECK_THROW(parseTextAndResolveNames(sourceCode3), TypeError);
}
BOOST_AUTO_TEST_CASE(reference_compare_operators)
{
char const* sourceCode1 = R"(
contract test { bytes a; bytes b; function() { a == b; } }
)";
BOOST_CHECK_THROW(parseTextAndResolveNames(sourceCode1), TypeError);
char const* sourceCode2 = R"(
contract test { struct s {uint a;} s x; s y; function() { x == y; } }
)";
BOOST_CHECK_THROW(parseTextAndResolveNames(sourceCode2), TypeError);
}
BOOST_AUTO_TEST_CASE(overwrite_memory_location_external) BOOST_AUTO_TEST_CASE(overwrite_memory_location_external)
{ {
char const* sourceCode = R"( char const* sourceCode = R"(
@ -2149,6 +2177,23 @@ BOOST_AUTO_TEST_CASE(memory_structs_with_mappings)
BOOST_CHECK_THROW(parseTextAndResolveNames(text), TypeError); BOOST_CHECK_THROW(parseTextAndResolveNames(text), TypeError);
} }
BOOST_AUTO_TEST_CASE(string_bytes_conversion)
{
char const* text = R"(
contract Test {
string s;
bytes b;
function h(string _s) external { bytes(_s).length; }
function i(string _s) internal { bytes(_s).length; }
function j() internal { bytes(s).length; }
function k(bytes _b) external { string(_b); }
function l(bytes _b) internal { string(_b); }
function m() internal { string(b); }
}
)";
BOOST_CHECK_NO_THROW(parseTextAndResolveNames(text));
}
BOOST_AUTO_TEST_SUITE_END() BOOST_AUTO_TEST_SUITE_END()
} }

73
libsolidity/solidityExecutionFramework.h
View File

@ -25,6 +25,7 @@
#include <string> #include <string>
#include <tuple> #include <tuple>
#include "../TestHelper.h" #include "../TestHelper.h"
#include <libethcore/ABI.h>
#include <libethereum/State.h> #include <libethereum/State.h>
#include <libethereum/Executive.h> #include <libethereum/Executive.h>
#include <libsolidity/CompilerStack.h> #include <libsolidity/CompilerStack.h>
@ -44,7 +45,6 @@ public:
ExecutionFramework() ExecutionFramework()
{ {
g_logVerbosity = 0; g_logVerbosity = 0;
m_state.resetCurrent();
} }
bytes const& compileAndRunWithoutCheck( bytes const& compileAndRunWithoutCheck(
@ -130,6 +130,7 @@ public:
static bytes encode(bool _value) { return encode(byte(_value)); } static bytes encode(bool _value) { return encode(byte(_value)); }
static bytes encode(int _value) { return encode(u256(_value)); } static bytes encode(int _value) { return encode(u256(_value)); }
static bytes encode(size_t _value) { return encode(u256(_value)); }
static bytes encode(char const* _value) { return encode(std::string(_value)); } static bytes encode(char const* _value) { return encode(std::string(_value)); }
static bytes encode(byte _value) { return bytes(31, 0) + bytes{_value}; } static bytes encode(byte _value) { return bytes(31, 0) + bytes{_value}; }
static bytes encode(u256 const& _value) { return toBigEndian(_value); } static bytes encode(u256 const& _value) { return toBigEndian(_value); }
@ -165,6 +166,73 @@ public:
return encodeArgs(u256(0x20), u256(_arg.size()), _arg); return encodeArgs(u256(0x20), u256(_arg.size()), _arg);
} }
class ContractInterface
{
public:
ContractInterface(ExecutionFramework& _framework): m_framework(_framework) {}
void setNextValue(u256 const& _value) { m_nextValue = _value; }
protected:
template <class... Args>
bytes const& call(std::string const& _sig, Args const&... _arguments)
{
auto const& ret = m_framework.callContractFunctionWithValue(_sig, m_nextValue, _arguments...);
m_nextValue = 0;
return ret;
}
void callString(std::string const& _name, std::string const& _arg)
{
BOOST_CHECK(call(_name + "(string)", u256(0x20), _arg.length(), _arg).empty());
}
void callStringAddress(std::string const& _name, std::string const& _arg1, u160 const& _arg2)
{
BOOST_CHECK(call(_name + "(string,address)", u256(0x40), _arg2, _arg1.length(), _arg1).empty());
}
void callStringAddressBool(std::string const& _name, std::string const& _arg1, u160 const& _arg2, bool _arg3)
{
BOOST_CHECK(call(_name + "(string,address,bool)", u256(0x60), _arg2, _arg3, _arg1.length(), _arg1).empty());
}
void callStringBytes32(std::string const& _name, std::string const& _arg1, h256 const& _arg2)
{
BOOST_CHECK(call(_name + "(string,bytes32)", u256(0x40), _arg2, _arg1.length(), _arg1).empty());
}
u160 callStringReturnsAddress(std::string const& _name, std::string const& _arg)
{
bytes const& ret = call(_name + "(string)", u256(0x20), _arg.length(), _arg);
BOOST_REQUIRE(ret.size() == 0x20);
BOOST_CHECK(std::count(ret.begin(), ret.begin() + 12, 0) == 12);
return eth::abiOut<u160>(ret);
}
std::string callAddressReturnsString(std::string const& _name, u160 const& _arg)
{
bytesConstRef ret = ref(call(_name + "(address)", _arg));
BOOST_REQUIRE(ret.size() >= 0x20);
u256 offset = eth::abiOut<u256>(ret);
BOOST_REQUIRE_EQUAL(offset, 0x20);
u256 len = eth::abiOut<u256>(ret);
BOOST_REQUIRE_EQUAL(ret.size(), ((len + 0x1f) / 0x20) * 0x20);
return ret.cropped(0, size_t(len)).toString();
}
h256 callStringReturnsBytes32(std::string const& _name, std::string const& _arg)
{
bytes const& ret = call(_name + "(string)", u256(0x20), _arg.length(), _arg);
BOOST_REQUIRE(ret.size() == 0x20);
return eth::abiOut<h256>(ret);
}
private:
u256 m_nextValue;
ExecutionFramework& m_framework;
};
private: private:
template <class CppFunction, class... Args> template <class CppFunction, class... Args>
auto callCppAndEncodeResult(CppFunction const& _cppFunction, Args const&... _arguments) auto callCppAndEncodeResult(CppFunction const& _cppFunction, Args const&... _arguments)
@ -184,7 +252,7 @@ protected:
void sendMessage(bytes const& _data, bool _isCreation, u256 const& _value = 0) void sendMessage(bytes const& _data, bool _isCreation, u256 const& _value = 0)
{ {
m_state.addBalance(m_sender, _value); // just in case m_state.addBalance(m_sender, _value); // just in case
eth::Executive executive(m_state, eth::LastHashes(), 0); eth::Executive executive(m_state, m_envInfo, 0);
eth::ExecutionResult res; eth::ExecutionResult res;
executive.setResultRecipient(res); executive.setResultRecipient(res);
eth::Transaction t = eth::Transaction t =
@ -225,6 +293,7 @@ protected:
dev::solidity::CompilerStack m_compiler; dev::solidity::CompilerStack m_compiler;
Address m_sender; Address m_sender;
Address m_contractAddress; Address m_contractAddress;
eth::EnvInfo m_envInfo;
eth::State m_state; eth::State m_state;
u256 const m_gasPrice = 100 * eth::szabo; u256 const m_gasPrice = 100 * eth::szabo;
u256 const m_gas = 100000000; u256 const m_gas = 100000000;