From 0e758af143b64973b24b24a98a965fbce072ffe7 Mon Sep 17 00:00:00 2001 From: winsvega Date: Thu, 23 Apr 2015 02:43:35 +0300 Subject: [PATCH] BlockWeight: toCompactHex refactoring --- libdevcore/CommonData.h | 19 +++++++-- test/TestHelper.cpp | 50 +++++++++--------------- test/TestHelper.h | 7 ---- test/fuzzTesting/createRandomVMTest.cpp | 4 +- test/libethereum/blockchain.cpp | 38 +++++++++--------- test/libethereum/transaction.cpp | 2 +- test/libevm/vm.cpp | 51 ++++++++++++------------- 7 files changed, 82 insertions(+), 89 deletions(-) diff --git a/libdevcore/CommonData.h b/libdevcore/CommonData.h index 93bad71a3..caf09d8c6 100644 --- a/libdevcore/CommonData.h +++ b/libdevcore/CommonData.h @@ -41,6 +41,11 @@ enum class WhenError Throw = 1, }; +enum class HexPrefix +{ + DontAdd = 0, + Add = 1, +}; /// Convert a series of bytes to the corresponding string of hex duplets. /// @param _w specifies the width of the first of the elements. Defaults to two - enough to represent a byte. /// @example toHex("A\x69") == "4169" @@ -128,9 +133,6 @@ inline std::string toBigEndianString(u160 _val) { std::string ret(20, '\0'); toB inline bytes toBigEndian(u256 _val) { bytes ret(32); toBigEndian(_val, ret); return ret; } inline bytes toBigEndian(u160 _val) { bytes ret(20); toBigEndian(_val, ret); return ret; } -/// Convenience function for conversion of a u256 to hex -inline std::string toHex(u256 val) { return toHex(toBigEndian(val)); } - /// Convenience function for toBigEndian. /// @returns a byte array just big enough to represent @a _val. template @@ -159,6 +161,17 @@ inline std::string toCompactBigEndianString(_T _val) return ret; } +/// Convenience function for conversion of a u256 to hex +inline std::string toHex(u256 val, HexPrefix prefix = HexPrefix::DontAdd) +{ + std::string str = toHex(toBigEndian(val)); + return (prefix == HexPrefix::Add) ? "0x" + str : str; +} +inline std::string toCompactHex(u256 val, HexPrefix prefix = HexPrefix::DontAdd) +{ + std::string str = toHex(toCompactBigEndian(val, 1)); //1 means val=0 would be '0x00' instead of '0x' + return (prefix == HexPrefix::Add) ? "0x" + str : str; +} // Algorithms for string and string-like collections. diff --git a/test/TestHelper.cpp b/test/TestHelper.cpp index 8ea70ed1c..0aa508c23 100644 --- a/test/TestHelper.cpp +++ b/test/TestHelper.cpp @@ -137,7 +137,7 @@ json_spirit::mObject& ImportTest::makeAllFieldsHex(json_spirit::mObject& _o) str = value.get_str(); else continue; - _o[key] = (str.substr(0, 2) == "0x") ? str : jsonHex(toInt(str)); + _o[key] = (str.substr(0, 2) == "0x") ? str : toHex(toInt(str), HexPrefix::Add); } return _o; } @@ -327,7 +327,7 @@ void ImportTest::checkExpectedState(State const& _stateExpect, State const& _sta void ImportTest::exportTest(bytes const& _output, State const& _statePost) { // export output - m_TestObject["out"] = jsonHex(_output); + m_TestObject["out"] = "0x" + toString(_output); // export logs m_TestObject["logs"] = exportLog(_statePost.pending().size() ? _statePost.log(0) : LogEntries()); @@ -344,7 +344,7 @@ void ImportTest::exportTest(bytes const& _output, State const& _statePost) // export post state m_TestObject["post"] = fillJsonWithState(_statePost); - m_TestObject["postStateRoot"] = jsonHex(_statePost.rootHash().asBytes()); + m_TestObject["postStateRoot"] = toString(_statePost.rootHash().asBytes()); // export pre state m_TestObject["pre"] = fillJsonWithState(m_statePre); @@ -352,29 +352,18 @@ void ImportTest::exportTest(bytes const& _output, State const& _statePost) m_TestObject["transaction"] = makeAllFieldsHex(m_TestObject["transaction"].get_obj()); } -std::string jsonHash(h256 const& _value) { return toString(_value); } -std::string jsonHash(Nonce const& _value) { return toString(_value); } -std::string jsonHash(LogBloom const& _value) { return toString(_value); } -std::string jsonHash(Address const& _value) { return toString(_value); } -std::string jsonHex(bytesConstRef _code) { return "0x" + toHex(_code); } -std::string jsonHex(bytes const& _code) { return "0x" + toHex(_code); } -std::string jsonHex(u256 const& _value, bool _nonempty) -{ - return "0x" + toHex(toCompactBigEndian(_value, _nonempty ? 1 : 0)); -} - json_spirit::mObject fillJsonWithTransaction(Transaction _txn) { json_spirit::mObject txObject; - txObject["nonce"] = jsonHex(_txn.nonce()); - txObject["data"] = jsonHex(_txn.data()); - txObject["gasLimit"] = jsonHex(_txn.gas()); - txObject["gasPrice"] = jsonHex(_txn.gasPrice()); - txObject["r"] = jsonHex(_txn.signature().r); - txObject["s"] = jsonHex(_txn.signature().s); - txObject["v"] = jsonHex(_txn.signature().v + 27); - txObject["to"] = _txn.isCreation() ? "" : jsonHash(_txn.receiveAddress()); - txObject["value"] = jsonHex(_txn.value()); + txObject["nonce"] = toCompactHex(_txn.nonce(), HexPrefix::Add); + txObject["data"] = "0x"+toString(_txn.data()); + txObject["gasLimit"] = toCompactHex(_txn.gas(), HexPrefix::Add); + txObject["gasPrice"] = toCompactHex(_txn.gasPrice(), HexPrefix::Add); + txObject["r"] = toCompactHex(_txn.signature().r, HexPrefix::Add); + txObject["s"] = toCompactHex(_txn.signature().s, HexPrefix::Add); + txObject["v"] = toCompactHex(_txn.signature().v + 27, HexPrefix::Add); + txObject["to"] = _txn.isCreation() ? "" : toString(_txn.receiveAddress()); + txObject["value"] = toCompactHex(_txn.value(), HexPrefix::Add); return txObject; } @@ -384,16 +373,15 @@ json_spirit::mObject fillJsonWithState(State _state) for (auto const& a: _state.addresses()) { json_spirit::mObject o; - o["balance"] = jsonHex(_state.balance(a.first)); - o["nonce"] = jsonHex(_state.transactionsFrom(a.first)); + o["balance"] = toCompactHex(_state.balance(a.first), HexPrefix::Add); + o["nonce"] = toCompactHex(_state.transactionsFrom(a.first), HexPrefix::Add); { json_spirit::mObject store; for (auto const& s: _state.storage(a.first)) - store[jsonHex(s.first)] = jsonHex(s.second); + store[toCompactHex(s.first, HexPrefix::Add)] = toCompactHex(s.second, HexPrefix::Add); o["storage"] = store; } - o["code"] = jsonHex(_state.code(a.first)); - + o["code"] = "0x" + toString(_state.code(a.first)); oState[toString(a.first)] = o; } return oState; @@ -406,13 +394,13 @@ json_spirit::mArray exportLog(eth::LogEntries _logs) for (LogEntry const& l: _logs) { json_spirit::mObject o; - o["address"] = jsonHash(l.address); + o["address"] = toString(l.address); json_spirit::mArray topics; for (auto const& t: l.topics) topics.push_back(toString(t)); o["topics"] = topics; - o["data"] = jsonHex(l.data); - o["bloom"] = jsonHash(l.bloom()); + o["data"] = "0x" + toString(l.data); + o["bloom"] = toString(l.bloom()); ret.push_back(o); } return ret; diff --git a/test/TestHelper.h b/test/TestHelper.h index 1e09cf69d..10e76aa96 100644 --- a/test/TestHelper.h +++ b/test/TestHelper.h @@ -162,13 +162,6 @@ RLPStream createRLPStreamFromTransactionFields(json_spirit::mObject& _tObj); eth::LastHashes lastHashes(u256 _currentBlockNumber); json_spirit::mObject fillJsonWithState(eth::State _state); json_spirit::mObject fillJsonWithTransaction(eth::Transaction _txn); -std::string jsonHash(dev::eth::LogBloom const& _value); -std::string jsonHash(Address const& _value); -std::string jsonHash(dev::eth::Nonce const& _value); -std::string jsonHash(h256 const& _value); -std::string jsonHex(u256 const& _value, bool _nonempty = true); -std::string jsonHex(bytesConstRef _code); -std::string jsonHex(bytes const& _code); template void checkAddresses(mapType& _expectedAddrs, mapType& _resultAddrs) diff --git a/test/fuzzTesting/createRandomVMTest.cpp b/test/fuzzTesting/createRandomVMTest.cpp index 1df24167e..c401854bc 100644 --- a/test/fuzzTesting/createRandomVMTest.cpp +++ b/test/fuzzTesting/createRandomVMTest.cpp @@ -200,8 +200,8 @@ void doMyTests(json_spirit::mValue& _v) { o["post"] = mValue(fev.exportState()); o["callcreates"] = fev.exportCallCreates(); - o["out"] = dev::test::jsonHex(output); - o["gas"] = dev::test::jsonHex(gas); + o["out"] = "0x" + toString(output); + o["gas"] = toCompactHex(gas, HexPrefix::Add); o["logs"] = test::exportLog(fev.sub.logs); } } diff --git a/test/libethereum/blockchain.cpp b/test/libethereum/blockchain.cpp index a70b714fd..9c04d352a 100644 --- a/test/libethereum/blockchain.cpp +++ b/test/libethereum/blockchain.cpp @@ -81,7 +81,7 @@ void doBlockchainTests(json_spirit::mValue& _v, bool _fillin) // create new "genesis" block RLPStream rlpGenesisBlock = createFullBlockFromHeader(biGenesisBlock); biGenesisBlock.verifyInternals(&rlpGenesisBlock.out()); - o["genesisRLP"] = jsonHex(rlpGenesisBlock.out()); + o["genesisRLP"] = "0x" + toString(rlpGenesisBlock.out()); // construct blockchain TransientDirectory td; @@ -149,7 +149,7 @@ void doBlockchainTests(json_spirit::mValue& _v, bool _fillin) return; } - blObj["rlp"] = jsonHex(state.blockData()); + blObj["rlp"] = "0x"+toString(state.blockData()); //get valid transactions Transactions txList; @@ -188,7 +188,7 @@ void doBlockchainTests(json_spirit::mValue& _v, bool _fillin) RLPStream block2 = createFullBlockFromHeader(current_BlockHeader, txStream.out(), uncleStream.out()); - blObj["rlp"] = jsonHex(block2.out()); + blObj["rlp"] = "0x" + toString(block2.out()); if (sha3(RLP(state.blockData())[0].data()) != sha3(RLP(block2.out())[0].data())) cnote << "block header mismatch\n"; @@ -628,22 +628,22 @@ mArray writeTransactionsToJson(Transactions const& txs) mObject writeBlockHeaderToJson(mObject& _o, BlockInfo const& _bi) { - _o["parentHash"] = jsonHash(_bi.parentHash); - _o["uncleHash"] = jsonHash(_bi.sha3Uncles); - _o["coinbase"] = jsonHash(_bi.coinbaseAddress); - _o["stateRoot"] = jsonHash(_bi.stateRoot); - _o["transactionsTrie"] = jsonHash(_bi.transactionsRoot); - _o["receiptTrie"] = jsonHash(_bi.receiptsRoot); - _o["bloom"] = jsonHash(_bi.logBloom); - _o["difficulty"] = jsonHex(_bi.difficulty); - _o["number"] = jsonHex(_bi.number); - _o["gasLimit"] = jsonHex(_bi.gasLimit); - _o["gasUsed"] = jsonHex(_bi.gasUsed); - _o["timestamp"] = jsonHex(_bi.timestamp); - _o["extraData"] = jsonHex(_bi.extraData); - _o["mixHash"] = jsonHash(_bi.mixHash); - _o["nonce"] = jsonHash(_bi.nonce); - _o["hash"] = jsonHash(_bi.hash()); + _o["parentHash"] = toString(_bi.parentHash); + _o["uncleHash"] = toString(_bi.sha3Uncles); + _o["coinbase"] = toString(_bi.coinbaseAddress); + _o["stateRoot"] = toString(_bi.stateRoot); + _o["transactionsTrie"] = toString(_bi.transactionsRoot); + _o["receiptTrie"] = toString(_bi.receiptsRoot); + _o["bloom"] = toString(_bi.logBloom); + _o["difficulty"] = toCompactHex(_bi.difficulty, HexPrefix::Add); + _o["number"] = toCompactHex(_bi.number, HexPrefix::Add); + _o["gasLimit"] = toCompactHex(_bi.gasLimit, HexPrefix::Add); + _o["gasUsed"] = toCompactHex(_bi.gasUsed, HexPrefix::Add); + _o["timestamp"] = toCompactHex(_bi.timestamp, HexPrefix::Add); + _o["extraData"] = "0x" + toString(_bi.extraData); + _o["mixHash"] = toString(_bi.mixHash); + _o["nonce"] = toString(_bi.nonce); + _o["hash"] = toString(_bi.hash()); return _o; } diff --git a/test/libethereum/transaction.cpp b/test/libethereum/transaction.cpp index 539f7e066..46fafc5f5 100644 --- a/test/libethereum/transaction.cpp +++ b/test/libethereum/transaction.cpp @@ -43,7 +43,7 @@ void doTransactionTests(json_spirit::mValue& _v, bool _fillin) //Construct Rlp of the given transaction RLPStream rlpStream = createRLPStreamFromTransactionFields(tObj); - o["rlp"] = jsonHex(rlpStream.out()); + o["rlp"] = "0x"+toString(rlpStream.out()); try { diff --git a/test/libevm/vm.cpp b/test/libevm/vm.cpp index 05dfb6d51..bc75080c1 100644 --- a/test/libevm/vm.cpp +++ b/test/libevm/vm.cpp @@ -86,12 +86,12 @@ void FakeExtVM::reset(u256 _myBalance, u256 _myNonce, map const& _st mObject FakeExtVM::exportEnv() { mObject ret; - ret["previousHash"] = jsonHash(currentBlock.parentHash); - ret["currentDifficulty"] = jsonHex(currentBlock.difficulty); - ret["currentTimestamp"] = jsonHex(currentBlock.timestamp); - ret["currentCoinbase"] = jsonHash(currentBlock.coinbaseAddress); - ret["currentNumber"] = jsonHex(currentBlock.number); - ret["currentGasLimit"] = jsonHex(currentBlock.gasLimit); + ret["previousHash"] = toString(currentBlock.parentHash); + ret["currentDifficulty"] = toCompactHex(currentBlock.difficulty, HexPrefix::Add); + ret["currentTimestamp"] = toCompactHex(currentBlock.timestamp, HexPrefix::Add); + ret["currentCoinbase"] = toString(currentBlock.coinbaseAddress); + ret["currentNumber"] = toCompactHex(currentBlock.number, HexPrefix::Add); + ret["currentGasLimit"] = toCompactHex(currentBlock.gasLimit, HexPrefix::Add); return ret; } @@ -120,16 +120,15 @@ mObject FakeExtVM::exportState() for (auto const& a: addresses) { mObject o; - o["balance"] = jsonHex(get<0>(a.second)); - o["nonce"] = jsonHex(get<1>(a.second)); + o["balance"] = toCompactHex(get<0>(a.second), HexPrefix::Add); + o["nonce"] = toCompactHex(get<1>(a.second), HexPrefix::Add); { mObject store; for (auto const& s: get<2>(a.second)) - store[jsonHex(s.first)] = jsonHex(s.second); + store[toCompactHex(s.first, HexPrefix::Add)] = toCompactHex(s.second, HexPrefix::Add); o["storage"] = store; } - o["code"] = jsonHex(get<3>(a.second)); - + o["code"] = "0x"+toString(get<3>(a.second)); ret[toString(a.first)] = o; } return ret; @@ -159,14 +158,14 @@ void FakeExtVM::importState(mObject& _object) mObject FakeExtVM::exportExec() { mObject ret; - ret["address"] = jsonHash(myAddress); - ret["caller"] = jsonHash(caller); - ret["origin"] = jsonHash(origin); - ret["value"] = jsonHex(value); - ret["gasPrice"] = jsonHex(gasPrice); - ret["gas"] = jsonHex(gas); - ret["data"] = jsonHex(data); - ret["code"] = jsonHex(code); + ret["address"] = toString(myAddress); + ret["caller"] = toString(caller); + ret["origin"] = toString(origin); + ret["value"] = toCompactHex(value, HexPrefix::Add); + ret["gasPrice"] = toCompactHex(gasPrice, HexPrefix::Add); + ret["gas"] = toCompactHex(gas, HexPrefix::Add); + ret["data"] = "0x" + toString(data); + ret["code"] = "0x" + toString(code); return ret; } @@ -207,10 +206,10 @@ mArray FakeExtVM::exportCallCreates() for (Transaction const& tx: callcreates) { mObject o; - o["destination"] = tx.isCreation() ? "" : jsonHash(tx.receiveAddress()); - o["gasLimit"] = jsonHex(tx.gas()); - o["value"] = jsonHex(tx.value()); - o["data"] = jsonHex(tx.data()); + o["destination"] = tx.isCreation() ? "" : toString(tx.receiveAddress()); + o["gasLimit"] = toCompactHex(tx.gas(), HexPrefix::Add); + o["value"] = toCompactHex(tx.value(), HexPrefix::Add); + o["data"] = "0x" + toString(tx.data()); ret.push_back(o); } return ret; @@ -281,7 +280,7 @@ eth::OnOpFunc FakeExtVM::simpleTrace() o_step.push_back(Pair("storage", storage)); o_step.push_back(Pair("depth", to_string(ext.depth))); o_step.push_back(Pair("gas", (string)vm.gas())); - o_step.push_back(Pair("address", jsonHash(ext.myAddress ))); + o_step.push_back(Pair("address", toString(ext.myAddress ))); o_step.push_back(Pair("step", steps )); o_step.push_back(Pair("pc", (int)vm.curPC())); o_step.push_back(Pair("opcode", instructionInfo(inst).name )); @@ -389,8 +388,8 @@ void doVMTests(json_spirit::mValue& v, bool _fillin) } o["callcreates"] = fev.exportCallCreates(); - o["out"] = jsonHex(output); - o["gas"] = jsonHex(gas); + o["out"] = "0x" + toString(output); + o["gas"] = toCompactHex(gas, HexPrefix::Add); o["logs"] = exportLog(fev.sub.logs); } }