Make precompiles return success condition.

Author: chriseth

libethcore/ChainOperationParams.cpp

@@ -29,7 +29,7 @@ using namespace eth;
 PrecompiledContract::PrecompiledContract(
 	unsigned _base,
 	unsigned _word,
-	std::function<bytes(bytesConstRef)> const& _exec,
+	PrecompiledExecutor const& _exec,
 	u256 const& _startingBlock
 ):
 	PrecompiledContract([=](unsigned size) -> bigint

libethcore/ChainOperationParams.h

@@ -23,6 +23,8 @@
 
 #include <libdevcore/Common.h>
 #include "Common.h"
+#include <libethcore/Precompiled.h>
+
 #include <libevmcore/EVMSchedule.h>
 
 namespace dev
@@ -36,8 +38,8 @@ class PrecompiledContract
 	PrecompiledContract() = default;
 	PrecompiledContract(
 		std::function<bigint(size_t)> const& _cost,
-		std::function<bytes(bytesConstRef)> const& _exec,
-		u256 const& _startingBlock
+		PrecompiledExecutor const& _exec,
+		u256 const& _startingBlock = 0
 	):
 		m_cost(_cost),
 		m_execute(_exec),
@@ -46,18 +48,18 @@ class PrecompiledContract
 	PrecompiledContract(
 		unsigned _base,
 		unsigned _word,
-		std::function<bytes(bytesConstRef)> const& _exec,
-		u256 const& _startingBlock
+		PrecompiledExecutor const& _exec,
+		u256 const& _startingBlock = 0
 	);
 
 	bigint cost(bytesConstRef _in) const { return m_cost(_in.size()); }
-	bytes execute(bytesConstRef _in) const { return m_execute(_in); }
+	std::pair<bool, bytes> execute(bytesConstRef _in) const { return m_execute(_in); }
 
 	u256 const& startingBlock() const { return m_startingBlock; }
 
 private:
 	std::function<bigint(size_t)> m_cost;
-	std::function<bytes(bytesConstRef)> m_execute;
+	PrecompiledExecutor m_execute;
 	u256 m_startingBlock = 0;
 };
 

libethcore/Precompiled.cpp

@@ -66,28 +66,28 @@ ETH_REGISTER_PRECOMPILED(ecrecover)(bytesConstRef _in)
 				{
 					ret = dev::sha3(rec);
 					memset(ret.data(), 0, 12);
-					return ret.asBytes();
+					return {true, ret.asBytes()};
 				}
 			}
 			catch (...) {}
 		}
 	}
-	return {};
+	return {true, {}};
 }
 
 ETH_REGISTER_PRECOMPILED(sha256)(bytesConstRef _in)
 {
-	return dev::sha256(_in).asBytes();
+	return {true, dev::sha256(_in).asBytes()};
 }
 
 ETH_REGISTER_PRECOMPILED(ripemd160)(bytesConstRef _in)
 {
-	return h256(dev::ripemd160(_in), h256::AlignRight).asBytes();
+	return {true, h256(dev::ripemd160(_in), h256::AlignRight).asBytes()};
 }
 
 ETH_REGISTER_PRECOMPILED(identity)(bytesConstRef _in)
 {
-	return _in.toBytes();
+	return {true, _in.toBytes()};
 }
 
 }

libethcore/Precompiled.h

@@ -31,7 +31,7 @@ namespace dev
 namespace eth
 {
 
-using PrecompiledExecutor = std::function<bytes(bytesConstRef _in)>;
+using PrecompiledExecutor = std::function<std::pair<bool, bytes>(bytesConstRef _in)>;
 
 DEV_SIMPLE_EXCEPTION(ExecutorNotFound);
 
@@ -54,7 +54,7 @@ class PrecompiledRegistrar
 };
 
 // TODO: unregister on unload with a static object.
-#define ETH_REGISTER_PRECOMPILED(Name) static bytes __eth_registerPrecompiledFunction ## Name(bytesConstRef _in); static PrecompiledExecutor __eth_registerPrecompiledFactory ## Name = ::dev::eth::PrecompiledRegistrar::registerPrecompiled(#Name, &__eth_registerPrecompiledFunction ## Name); static bytes __eth_registerPrecompiledFunction ## Name
+#define ETH_REGISTER_PRECOMPILED(Name) static std::pair<bool, bytes> __eth_registerPrecompiledFunction ## Name(bytesConstRef _in); static PrecompiledExecutor __eth_registerPrecompiledFactory ## Name = ::dev::eth::PrecompiledRegistrar::registerPrecompiled(#Name, &__eth_registerPrecompiledFunction ## Name); static std::pair<bool, bytes> __eth_registerPrecompiledFunction ## Name
 
 }
 }

libethcore/SealEngine.h

@@ -82,7 +82,7 @@ class SealEngineFace
 		return m_params.precompiled.count(_a) != 0 && _blockNumber >= m_params.precompiled.at(_a).startingBlock();
 	}
 	virtual bigint costOfPrecompiled(Address const& _a, bytesConstRef _in, u256 const&) const { return m_params.precompiled.at(_a).cost(_in); }
-	virtual bytes executePrecompiled(Address const& _a, bytesConstRef _in, u256 const&) const { return m_params.precompiled.at(_a).execute(_in); }
+	virtual std::pair<bool, bytes> executePrecompiled(Address const& _a, bytesConstRef _in, u256 const&) const { return m_params.precompiled.at(_a).execute(_in); }
 
 protected:
 	virtual bool onOptionChanging(std::string const&, bytes const&) { return true; }

libethereum/Account.cpp

@@ -116,17 +116,17 @@ AccountMap dev::eth::jsonToAccountMap(std::string const& _json, u256 const& _def
 		{
 			js::mObject p = o["precompiled"].get_obj();
 			auto n = p["name"].get_str();
-			if (!o.count("linear"))
+			if (!p.count("linear"))
 			{
-				cwarn << "No gas cost given for precompiled contract " << n << endl;
+				cwarn << "No gas cost given for precompiled contract " << n;
 				throw;
 			}
 			try
 			{
 				auto l = p["linear"].get_obj();
 				u256 startingBlock = 0;
 				if (p.count("startingBlock"))
-					startingBlock = u256(p["startingBlock"]);
+					startingBlock = u256(p["startingBlock"].get_str());
 				unsigned base = toUnsigned(l["base"]);
 				unsigned word = toUnsigned(l["word"]);
 				o_precompiled->insert(make_pair(a, PrecompiledContract(base, word, PrecompiledRegistrar::executor(n), startingBlock)));

libethereum/Executive.cpp

@@ -274,7 +274,14 @@ bool Executive::call(CallParameters const& _p, u256 const& _gasPrice, Address co
 		else
 		{
 			m_gas = (u256)(_p.gas - g);
-			bytes output = m_sealEngine.executePrecompiled(_p.codeAddress, _p.data, m_envInfo.number());
+			bytes output;
+			bool success;
+			tie(success, output) = m_sealEngine.executePrecompiled(_p.codeAddress, _p.data, m_envInfo.number());
+			if (!success)
+			{
+				m_gas = 0;
+				m_excepted = TransactionException::OutOfGas;
+			}
 			size_t outputSize = output.size();
 			m_output = owning_bytes_ref{std::move(output), 0, outputSize};
 		}
@@ -473,4 +480,4 @@ void Executive::revert()
 	// Set result address to the null one.
 	m_newAddress = {};
 	m_s.rollback(m_savepoint);
-}
+}