EIP198: Custom cost function for modexp contract

Author: gumb0

libethcore/ChainOperationParams.cpp

@@ -32,9 +32,9 @@ PrecompiledContract::PrecompiledContract(
 	PrecompiledExecutor const& _exec,
 	u256 const& _startingBlock
 ):
-	PrecompiledContract([=](unsigned size) -> bigint
+	PrecompiledContract([=](bytesConstRef _in) -> bigint
 	{
-		bigint s = size;
+		bigint s = _in.size();
 		bigint b = _base;
 		bigint w = _word;
 		return b + (s + 31) / 32 * w;

libethcore/ChainOperationParams.h

@@ -37,7 +37,7 @@ class PrecompiledContract
 public:
 	PrecompiledContract() = default;
 	PrecompiledContract(
-		std::function<bigint(size_t)> const& _cost,
+		PrecompiledPricer const& _cost,
 		PrecompiledExecutor const& _exec,
 		u256 const& _startingBlock = 0
 	):
@@ -52,13 +52,13 @@ class PrecompiledContract
 		u256 const& _startingBlock = 0
 	);
 
-	bigint cost(bytesConstRef _in) const { return m_cost(_in.size()); }
+	bigint cost(bytesConstRef _in) const { return m_cost(_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;
+	PrecompiledPricer m_cost;
 	PrecompiledExecutor m_execute;
 	u256 m_startingBlock = 0;
 };

libethcore/Precompiled.cpp

@@ -38,6 +38,13 @@ PrecompiledExecutor const& PrecompiledRegistrar::executor(std::string const& _na
 	return get()->m_execs[_name];
 }
 
+PrecompiledPricer const& PrecompiledRegistrar::pricer(std::string const& _name)
+{
+	if (!get()->m_pricers.count(_name))
+		BOOST_THROW_EXCEPTION(PricerNotFound());
+	return get()->m_pricers[_name];
+}
+
 namespace
 {
 
@@ -122,4 +129,15 @@ ETH_REGISTER_PRECOMPILED(modexp)(bytesConstRef _in)
 	return {true, ret};
 }
 
+ETH_REGISTER_PRECOMPILED_PRICER(modexp)(bytesConstRef _in)
+{
+	u256 const baseLength(parseBigEndianRightPadded<u256>(_in, 0, 32));
+	u256 const expLength(parseBigEndianRightPadded<u256>(_in, 32, 32));
+	u256 const modLength(parseBigEndianRightPadded<u256>(_in, 64, 32));
+
+	bigint const maxLength = max(modLength, baseLength);
+
+	return maxLength * maxLength * max<bigint>(expLength, 1) / 20;
+}
+
 }

libethcore/Precompiled.h

@@ -32,29 +32,40 @@ namespace eth
 {
 
 using PrecompiledExecutor = std::function<std::pair<bool, bytes>(bytesConstRef _in)>;
+using PrecompiledPricer = std::function<bigint(bytesConstRef _in)>;
 
 DEV_SIMPLE_EXCEPTION(ExecutorNotFound);
+DEV_SIMPLE_EXCEPTION(PricerNotFound);
 
 class PrecompiledRegistrar
 {
 public:
 	/// Get the executor object for @a _name function or @throw ExecutorNotFound if not found.
 	static PrecompiledExecutor const& executor(std::string const& _name);
 
+	/// Get the price calculator object for @a _name function or @throw PricerNotFound if not found.
+	static PrecompiledPricer const& pricer(std::string const& _name);
+
 	/// Register an executor. In general just use ETH_REGISTER_PRECOMPILED.
-	static PrecompiledExecutor registerPrecompiled(std::string const& _name, PrecompiledExecutor const& _exec) { return (get()->m_execs[_name] = _exec); }
+	static PrecompiledExecutor registerExecutor(std::string const& _name, PrecompiledExecutor const& _exec) { return (get()->m_execs[_name] = _exec); }
+	/// Unregister an executor. Shouldn't generally be necessary.
+	static void unregisterExecutor(std::string const& _name) { get()->m_execs.erase(_name); }
+
+	/// Register a pricer. In general just use ETH_REGISTER_PRECOMPILED_PRICER.
+	static PrecompiledPricer registerPricer(std::string const& _name, PrecompiledPricer const& _exec) { return (get()->m_pricers[_name] = _exec); }
 	/// Unregister an executor. Shouldn't generally be necessary.
-	static void unregisterPrecompiled(std::string const& _name) { get()->m_execs.erase(_name); }
+	static void unregisterPricer(std::string const& _name) { get()->m_pricers.erase(_name); }
 
 private:
 	static PrecompiledRegistrar* get() { if (!s_this) s_this = new PrecompiledRegistrar; return s_this; }
 
 	std::unordered_map<std::string, PrecompiledExecutor> m_execs;
+	std::unordered_map<std::string, PrecompiledPricer> m_pricers;
 	static PrecompiledRegistrar* s_this;
 };
 
 // TODO: unregister on unload with a static object.
-#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
-
+#define ETH_REGISTER_PRECOMPILED(Name) static std::pair<bool, bytes> __eth_registerPrecompiledFunction ## Name(bytesConstRef _in); static PrecompiledExecutor __eth_registerPrecompiledFactory ## Name = ::dev::eth::PrecompiledRegistrar::registerExecutor(#Name, &__eth_registerPrecompiledFunction ## Name); static std::pair<bool, bytes> __eth_registerPrecompiledFunction ## Name
+#define ETH_REGISTER_PRECOMPILED_PRICER(Name) static bigint __eth_registerPricerFunction ## Name(bytesConstRef _in); static PrecompiledPricer __eth_registerPricerFactory ## Name = ::dev::eth::PrecompiledRegistrar::registerPricer(#Name, &__eth_registerPricerFunction ## Name); static bigint __eth_registerPricerFunction ## Name
 }
 }

libethereum/Account.cpp

@@ -37,6 +37,9 @@ void Account::setNewCode(bytes&& _code)
 
 namespace js = json_spirit;
 
+namespace
+{
+
 uint64_t toUnsigned(js::mValue const& _v)
 {
 	switch (_v.type())
@@ -47,6 +50,37 @@ uint64_t toUnsigned(js::mValue const& _v)
 	}
 }
 
+PrecompiledContract createPrecompiledContract(js::mObject& _precompiled)
+{
+	auto n = _precompiled["name"].get_str();
+	try
+	{
+		u256 startingBlock = 0;
+		if (_precompiled.count("startingBlock"))
+			startingBlock = u256(_precompiled["startingBlock"].get_str());
+
+		if (!_precompiled.count("linear"))
+			return PrecompiledContract(PrecompiledRegistrar::pricer(n), PrecompiledRegistrar::executor(n), startingBlock);
+
+		auto l = _precompiled["linear"].get_obj();
+		unsigned base = toUnsigned(l["base"]);
+		unsigned word = toUnsigned(l["word"]);
+		return PrecompiledContract(base, word, PrecompiledRegistrar::executor(n), startingBlock);
+	}
+	catch (PricerNotFound const&)
+	{
+		cwarn << "Couldn't create a precompiled contract account. Missing a pricer called:" << n;
+		throw;
+	}
+	catch (ExecutorNotFound const&)
+	{
+		// Oh dear - missing a plugin?
+		cwarn << "Couldn't create a precompiled contract account. Missing an executor called:" << n;
+		throw;
+	}
+}
+
+}
 AccountMap dev::eth::jsonToAccountMap(std::string const& _json, u256 const& _defaultNonce, AccountMaskMap* o_mask, PrecompiledContractMap* o_precompiled)
 {
 	auto u256Safe = [](std::string const& s) -> u256 {
@@ -115,28 +149,7 @@ AccountMap dev::eth::jsonToAccountMap(std::string const& _json, u256 const& _def
 		if (o_precompiled && o.count("precompiled"))
 		{
 			js::mObject p = o["precompiled"].get_obj();
-			auto n = p["name"].get_str();
-			if (!p.count("linear"))
-			{
-				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"].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)));
-			}
-			catch (ExecutorNotFound)
-			{
-				// Oh dear - missing a plugin?
-				cwarn << "Couldn't create a precompiled contract account. Missing an executor called:" << n;
-				throw;
-			}
+			o_precompiled->insert(make_pair(a, createPrecompiledContract(p)));
 		}
 	}