Merge pull request #4822 from ethereum/int64

chfast · web-flow · commit e6901855b722 · 2018-01-31T14:47:37.000+01:00
Change type for block number to int64
diff --git a/ethvm/main.cpp b/ethvm/main.cpp
@@ -158,9 +158,10 @@ int main(int argc, char** argv)
 		("help,h", "Show this help message and exit.")
 		("author", po::value<Address>(), "<a> Set author")
 		("difficulty", po::value<u256>(), "<n> Set difficulty")
-		("number", po::value<u256>(), "<n> Set number")
+		("number", po::value<int64_t>()->default_value(0)->value_name("<number>")
+			->notifier([&](int64_t _n) { blockHeader.setNumber(_n); }), "Set the block number")
 		("timestamp", po::value<int64_t>()->default_value(0)->value_name("<timestamp>")
-			->notifier([&](int64_t _t){ blockHeader.setTimestamp(_t); }), "Set timestamp");
+			->notifier([&](int64_t _t){ blockHeader.setTimestamp(_t); }), "Set the block timestamp");
 
     po::options_description allowedOptions(
         "Usage ethvm <options> [trace|stats|output|test] (<file>|-)");
@@ -220,8 +221,6 @@ int main(int argc, char** argv)
 		gasPrice = vm["gas-price"].as<u256>();
 	if (vm.count("author"))
 		blockHeader.setAuthor(vm["author"].as<Address>());
-	if (vm.count("number"))
-		blockHeader.setNumber(vm["number"].as<u256>());
 	if (vm.count("difficulty"))
 		blockHeader.setDifficulty(vm["difficulty"].as<u256>());
 	if (vm.count("gas-limit"))
diff --git a/libethcore/BlockHeader.cpp b/libethcore/BlockHeader.cpp
@@ -181,7 +181,7 @@ void BlockHeader::populate(RLP const& _header)
 		m_receiptsRoot = _header[field = 5].toHash<h256>(RLP::VeryStrict);
 		m_logBloom = _header[field = 6].toHash<LogBloom>(RLP::VeryStrict);
 		m_difficulty = _header[field = 7].toInt<u256>();
-		m_number = _header[field = 8].toInt<u256>();
+		m_number = _header[field = 8].toPositiveInt64();
 		m_gasLimit = _header[field = 9].toInt<u256>();
 		m_gasUsed = _header[field = 10].toInt<u256>();
 		m_timestamp = _header[field = 11].toPositiveInt64();
diff --git a/libethcore/BlockHeader.h b/libethcore/BlockHeader.h
@@ -146,7 +146,7 @@ class BlockHeader
 	void setAuthor(Address const& _v) { m_author = _v; noteDirty(); }
 	void setRoots(h256 const& _t, h256 const& _r, h256 const& _u, h256 const& _s) { m_transactionsRoot = _t; m_receiptsRoot = _r; m_stateRoot = _s; m_sha3Uncles = _u; noteDirty(); }
 	void setGasUsed(u256 const& _v) { m_gasUsed = _v; noteDirty(); }
-	void setNumber(u256 const& _v) { m_number = _v; noteDirty(); }
+	void setNumber(int64_t _v) { m_number = _v; noteDirty(); }
 	void setGasLimit(u256 const& _v) { m_gasLimit = _v; noteDirty(); }
 	void setExtraData(bytes const& _v) { m_extraData = _v; noteDirty(); }
 	void setLogBloom(LogBloom const& _v) { m_logBloom = _v; noteDirty(); }
@@ -163,7 +163,7 @@ class BlockHeader
 	h256 const& transactionsRoot() const { return m_transactionsRoot; }
 	h256 const& receiptsRoot() const { return m_receiptsRoot; }
 	u256 const& gasUsed() const { return m_gasUsed; }
-	u256 const& number() const { return m_number; }
+	int64_t number() const { return m_number; }
 	u256 const& gasLimit() const { return m_gasLimit; }
 	bytes const& extraData() const { return m_extraData; }
 	LogBloom const& logBloom() const { return m_logBloom; }
@@ -195,7 +195,7 @@ class BlockHeader
 	h256 m_transactionsRoot;
 	h256 m_receiptsRoot;
 	LogBloom m_logBloom;
-	u256 m_number;
+	int64_t m_number = 0;
 	u256 m_gasLimit;
 	u256 m_gasUsed;
 	bytes m_extraData;
diff --git a/libethereum/SnapshotImporter.cpp b/libethereum/SnapshotImporter.cpp
@@ -175,7 +175,7 @@ void SnapshotImporter::importBlockChunks(SnapshotStorageFace const& _snapshotSto
 		if (blockChunk.itemCount() < 3)
 			BOOST_THROW_EXCEPTION(InvalidBlockChunkData());
 
-		u256 const firstBlockNumber = blockChunk[0].toInt<u256>(RLP::VeryStrict);
+		int64_t const firstBlockNumber = blockChunk[0].toPositiveInt64(RLP::VeryStrict);
 		h256 const firstBlockHash = blockChunk[1].toHash<h256>(RLP::VeryStrict);
 		u256 const firstBlockDifficulty = blockChunk[2].toInt<u256>(RLP::VeryStrict);
 		if (!firstBlockNumber || !firstBlockHash || !firstBlockDifficulty)
@@ -185,7 +185,7 @@ void SnapshotImporter::importBlockChunks(SnapshotStorageFace const& _snapshotSto
 
 		size_t const itemCount = blockChunk.itemCount();
 		h256 parentHash = firstBlockHash;
-		u256 number = firstBlockNumber + 1;
+		int64_t number = firstBlockNumber + 1;
 		u256 totalDifficulty = firstBlockDifficulty;
 		for (size_t i = 3; i < itemCount; ++i, ++number)
 		{
diff --git a/libevm/EVMC.cpp b/libevm/EVMC.cpp
@@ -23,14 +23,15 @@ EVM::EVM(evm_instance* _instance) noexcept : m_instance(_instance)
 
 owning_bytes_ref EVMC::exec(u256& io_gas, ExtVMFace& _ext, const OnOpFunc& _onOp)
 {
+    assert(_ext.envInfo().number() >= 0);
+    assert(_ext.envInfo().timestamp() >= 0);
+
     constexpr int64_t int64max = std::numeric_limits<int64_t>::max();
 
     // TODO: The following checks should be removed by changing the types
     //       used for gas, block number and timestamp.
     (void)int64max;
     assert(io_gas <= int64max);
-    assert(_ext.envInfo().number() <= int64max);
-    assert(_ext.envInfo().timestamp() <= int64max);
     assert(_ext.envInfo().gasLimit() <= int64max);
     assert(_ext.depth <= std::numeric_limits<int32_t>::max());
 
diff --git a/libevm/ExtVMFace.h b/libevm/ExtVMFace.h
@@ -154,7 +154,7 @@ class EnvInfo
 
 	BlockHeader const& header() const { return m_headerInfo;  }
 
-	u256 const& number() const { return m_headerInfo.number(); }
+	int64_t number() const { return m_headerInfo.number(); }
 	Address const& author() const { return m_headerInfo.author(); }
 	int64_t timestamp() const { return m_headerInfo.timestamp(); }
 	u256 const& difficulty() const { return m_headerInfo.difficulty(); }
diff --git a/test/tools/jsontests/BlockChainTests.cpp b/test/tools/jsontests/BlockChainTests.cpp
@@ -641,7 +641,7 @@ void overwriteBlockHeaderForTest(mObject const& _blObj, TestBlock& _block, Chain
 		if (ho.count("RelTimestamp"))
 		{
 			BlockHeader parentHeader = importedBlocks.at(importedBlocks.size() - 1).blockHeader();
-			tmp.setTimestamp(toInt64(ho["RelTimestamp"]) + parentHeader.timestamp());
+			tmp.setTimestamp(toPositiveInt64(ho["RelTimestamp"]) + parentHeader.timestamp());
 			tmp.setDifficulty(((const Ethash*)sealEngine)->calculateDifficulty(tmp, parentHeader));
 		}
 
@@ -755,7 +755,8 @@ void overwriteUncleHeaderForTest(mObject& uncleHeaderObj, TestBlock& uncle, std:
 			if (uncleHeaderObj.count("RelTimestamp"))
 			{
 				BlockHeader parentHeader = importedBlocks.at(number).blockHeader();
-				uncleHeader.setTimestamp(toInt64(uncleHeaderObj["RelTimestamp"]) + parentHeader.timestamp());
+				uncleHeader.setTimestamp(
+                    toPositiveInt64(uncleHeaderObj["RelTimestamp"]) + parentHeader.timestamp());
 				uncleHeader.setDifficulty(((const Ethash*)sealEngine)->calculateDifficulty(uncleHeader, parentHeader));
 				uncleHeaderObj.erase("RelTimestamp");
 			}
diff --git a/test/tools/jsontests/vm.cpp b/test/tools/jsontests/vm.cpp
@@ -104,9 +104,9 @@ EnvInfo FakeExtVM::importEnv(mObject const& _o, LastBlockHashesFace const& _last
 	BlockHeader blockHeader;
 	blockHeader.setGasLimit(gasLimit.convert_to<int64_t>());
 	blockHeader.setDifficulty(toInt(_o.at("currentDifficulty")));
-	blockHeader.setTimestamp(toInt64(_o.at("currentTimestamp")));
+	blockHeader.setTimestamp(toPositiveInt64(_o.at("currentTimestamp")));
 	blockHeader.setAuthor(Address(_o.at("currentCoinbase").get_str()));
-	blockHeader.setNumber(toInt(_o.at("currentNumber")));
+	blockHeader.setNumber(toPositiveInt64(_o.at("currentNumber")));
 	return EnvInfo(blockHeader, _lastBlockHashes, 0);
 }
 
diff --git a/test/tools/libtesteth/ImportTest.cpp b/test/tools/libtesteth/ImportTest.cpp
@@ -347,8 +347,8 @@ void ImportTest::importEnv(json_spirit::mObject const& _o)
 	BlockHeader header;
 	header.setGasLimit(gasLimit.convert_to<int64_t>());
 	header.setDifficulty(toInt(_o.at("currentDifficulty")));
-	header.setNumber(toInt(_o.at("currentNumber")));
-	header.setTimestamp(toInt64(_o.at("currentTimestamp")));
+	header.setNumber(toPositiveInt64(_o.at("currentNumber")));
+	header.setTimestamp(toPositiveInt64(_o.at("currentTimestamp")));
 	header.setAuthor(Address(_o.at("currentCoinbase").get_str()));
 
 	m_lastBlockHashes.reset(new TestLastBlockHashes(lastHashes(header.number())));
diff --git a/test/tools/libtesteth/TestHelper.cpp b/test/tools/libtesteth/TestHelper.cpp
@@ -277,18 +277,25 @@ u256 toInt(json_spirit::mValue const& _v)
     return 0;
 }
 
-int64_t toInt64(const json_spirit::mValue& _v)
+int64_t toPositiveInt64(const json_spirit::mValue& _v)
 {
+    int64_t n = 0;
     switch (_v.type())
     {
     case json_spirit::str_type:
-        return std::stoll(_v.get_str(), nullptr, 0);
+        n = std::stoll(_v.get_str(), nullptr, 0);
+        break;
     case json_spirit::int_type:
-        return _v.get_int64();
+        n = _v.get_int64();
+        break;
     default:
         cwarn << "Bad type for scalar: " << _v.type();
     }
-    return 0;
+
+    if (n < 0)
+        throw std::out_of_range{"unexpected negative value: " + std::to_string(n)};
+
+    return n;
 }
 
 byte toByte(json_spirit::mValue const& _v)
diff --git a/test/tools/libtesteth/TestHelper.h b/test/tools/libtesteth/TestHelper.h
@@ -83,7 +83,11 @@ std::set<eth::Network> const& getNetworks();
 /// <=Homestead to Frontier, Homestead
 std::set<std::string> translateNetworks(std::set<std::string> const& _networks);
 u256 toInt(json_spirit::mValue const& _v);
-int64_t toInt64(const json_spirit::mValue& _v);
+
+/// Parses a JSON value as an 64-bit signed integer.
+/// Throws std::out_of_range exception in case the value is too big or negative.
+int64_t toPositiveInt64(const json_spirit::mValue& _v);
+
 byte toByte(json_spirit::mValue const& _v);
 bytes processDataOrCode(json_spirit::mObject const& _o, std::string const& nodeName);
 std::string replaceCode(std::string const& _code);
diff --git a/test/unittests/libethcore/difficulty.cpp b/test/unittests/libethcore/difficulty.cpp
@@ -127,14 +127,14 @@ void testDifficulty(fs::path const& _testFileFullName, Ethash& _sealEngine)
 		BOOST_REQUIRE_MESSAGE(o.count("currentDifficulty") > 0, testname + " missing currentDifficulty field");
 
 		BlockHeader parent;
-		parent.setTimestamp(test::toInt64(o["parentTimestamp"]));
+		parent.setTimestamp(test::toPositiveInt64(o["parentTimestamp"]));
 		parent.setDifficulty(test::toInt(o["parentDifficulty"]));
-		parent.setNumber(test::toInt(o["currentBlockNumber"]) - 1);
+		parent.setNumber(test::toPositiveInt64(o["currentBlockNumber"]) - 1);
 		parent.setSha3Uncles(h256(o["parentUncles"].get_str()));
 
 		BlockHeader current;
-		current.setTimestamp(test::toInt64(o["currentTimestamp"]));
-		current.setNumber(test::toInt(o["currentBlockNumber"]));
+		current.setTimestamp(test::toPositiveInt64(o["currentTimestamp"]));
+		current.setNumber(test::toPositiveInt64(o["currentBlockNumber"]));
 
 		u256 difficulty = _sealEngine.calculateDifficulty(current, parent);
 		BOOST_CHECK_EQUAL(difficulty, test::toInt(o["currentDifficulty"]));
@@ -217,8 +217,8 @@ BOOST_AUTO_TEST_CASE(difficultyTestsCustomMainNetwork)
 
 	if (dev::test::Options::get().filltests)
 	{
-		u256 byzantiumBlockNumber = 4370000;
-		std::vector<u256> blockNumberVector = {byzantiumBlockNumber - 100000, byzantiumBlockNumber, byzantiumBlockNumber + 100000};
+		int64_t byzantiumBlockNumber = 4370000;
+		std::vector<int64_t> blockNumberVector = {byzantiumBlockNumber - 100000, byzantiumBlockNumber, byzantiumBlockNumber + 100000};
 		std::vector<u256> parentDifficultyVector = {1000, 2048, 4000, 1000000};
 		std::vector<int> timestampDeltaVector = {0, 1, 8, 10, 13, 20, 100, 800, 1000, 1500};
 
@@ -233,12 +233,12 @@ BOOST_AUTO_TEST_CASE(difficultyTestsCustomMainNetwork)
 					{
 						testN++;
 						int stampDelta = timestampDeltaVector.at(tsN);
-						u256 blockNumber = blockNumberVector.at(bN);
+						int64_t blockNumber = blockNumberVector.at(bN);
 						u256 pDiff = parentDifficultyVector.at(pdN);
 
 						auto cStamp = static_cast<int64_t>(test::RandomCode::get().randomUniInt(timestampDeltaVector.back()));
 						int64_t pStamp = cStamp - stampDelta;
-						u256 cNum = blockNumber;
+                        int64_t cNum = blockNumber;
 
 						BlockHeader parent;
 						parent.setTimestamp(pStamp);

Original file line number	Diff line number	Diff line change
`@@ -641,7 +641,7 @@ void overwriteBlockHeaderForTest(mObject const& _blObj, TestBlock& _block, Chain`
`641`	`641`	`if (ho.count("RelTimestamp"))`
`642`	`642`	`{`
`643`	`643`	`BlockHeader parentHeader = importedBlocks.at(importedBlocks.size() - 1).blockHeader();`
`644`		`- tmp.setTimestamp(toInt64(ho["RelTimestamp"]) + parentHeader.timestamp());`
	`644`	`+ tmp.setTimestamp(toPositiveInt64(ho["RelTimestamp"]) + parentHeader.timestamp());`
`645`	`645`	`tmp.setDifficulty(((const Ethash*)sealEngine)->calculateDifficulty(tmp, parentHeader));`
`646`	`646`	`}`
`647`	`647`
`@@ -755,7 +755,8 @@ void overwriteUncleHeaderForTest(mObject& uncleHeaderObj, TestBlock& uncle, std:`
`755`	`755`	`if (uncleHeaderObj.count("RelTimestamp"))`
`756`	`756`	`{`
`757`	`757`	`BlockHeader parentHeader = importedBlocks.at(number).blockHeader();`
`758`		`- uncleHeader.setTimestamp(toInt64(uncleHeaderObj["RelTimestamp"]) + parentHeader.timestamp());`
	`758`	`+ uncleHeader.setTimestamp(`
	`759`	`+ toPositiveInt64(uncleHeaderObj["RelTimestamp"]) + parentHeader.timestamp());`
`759`	`760`	`uncleHeader.setDifficulty(((const Ethash*)sealEngine)->calculateDifficulty(uncleHeader, parentHeader));`
`760`	`761`	`uncleHeaderObj.erase("RelTimestamp");`
`761`	`762`	`}`
Original file line number	Diff line number	Diff line change
`@@ -277,18 +277,25 @@ u256 toInt(json_spirit::mValue const& _v)`
`277`	`277`	`return 0;`
`278`	`278`	`}`
`279`	`279`
`280`		`-int64_t toInt64(const json_spirit::mValue& _v)`
	`280`	`+int64_t toPositiveInt64(const json_spirit::mValue& _v)`
`281`	`281`	`{`
	`282`	`+ int64_t n = 0;`
`282`	`283`	`switch (_v.type())`
`283`	`284`	`{`
`284`	`285`	`case json_spirit::str_type:`
`285`		`- return std::stoll(_v.get_str(), nullptr, 0);`
	`286`	`+ n = std::stoll(_v.get_str(), nullptr, 0);`
	`287`	`+ break;`
`286`	`288`	`case json_spirit::int_type:`
`287`		`- return _v.get_int64();`
	`289`	`+ n = _v.get_int64();`
	`290`	`+ break;`
`288`	`291`	`default:`
`289`	`292`	`cwarn << "Bad type for scalar: " << _v.type();`
`290`	`293`	`}`
`291`		`- return 0;`
	`294`	`+`
	`295`	`+ if (n < 0)`
	`296`	`+ throw std::out_of_range{"unexpected negative value: " + std::to_string(n)};`
	`297`	`+`
	`298`	`+ return n;`
`292`	`299`	`}`
`293`	`300`
`294`	`301`	`byte toByte(json_spirit::mValue const& _v)`