Add "starting block" option for precompiled contracts.

Author: chriseth

deps

@@ -56,6 +56,9 @@ R"E(
 		"0000000000000000000000000000000000000002": { "precompiled": { "name": "sha256", "linear": { "base": 60, "word": 12 } } },
 		"0000000000000000000000000000000000000003": { "precompiled": { "name": "ripemd160", "linear": { "base": 600, "word": 120 } } },
 		"0000000000000000000000000000000000000004": { "precompiled": { "name": "identity", "linear": { "base": 15, "word": 3 } } },
+		"0000000000000000000000000000000000000006": { "precompiled": { "name": "alt_bn128_G1_add", "startingBlock": "0xffffffffffffffffff", "linear": { "base": 15, "word": 3 } } },
+		"0000000000000000000000000000000000000007": { "precompiled": { "name": "alt_bn128_G1_mul", "startingBlock": "0xffffffffffffffffff", "linear": { "base": 15, "word": 3 } } },
+		"0000000000000000000000000000000000000008": { "precompiled": { "name": "alt_bn128_pairing_product", "startingBlock": "0xffffffffffffffffff", "linear": { "base": 15, "word": 3 } } },
 		"3282791d6fd713f1e94f4bfd565eaa78b3a0599d": {
 		"balance": "1337000000000000000000"
 		},

libethashseal/genesis/mainNetwork.cpp

@@ -54,7 +54,10 @@ R"E(
 		"0000000000000000000000000000000000000001": { "wei": "1", "precompiled": { "name": "ecrecover", "linear": { "base": 3000, "word": 0 } } },
 		"0000000000000000000000000000000000000002": { "wei": "1", "precompiled": { "name": "sha256", "linear": { "base": 60, "word": 12 } } },
 		"0000000000000000000000000000000000000003": { "wei": "1", "precompiled": { "name": "ripemd160", "linear": { "base": 600, "word": 120 } } },
-		"0000000000000000000000000000000000000004": { "wei": "1", "precompiled": { "name": "identity", "linear": { "base": 15, "word": 3 } } }
-	}
+		"0000000000000000000000000000000000000004": { "wei": "1", "precompiled": { "name": "identity", "linear": { "base": 15, "word": 3 } } },
+		"0000000000000000000000000000000000000006": { "wei": "1", "precompiled": { "name": "alt_bn128_G1_add", "linear": { "base": 15, "word": 3 } } },
+		"0000000000000000000000000000000000000007": { "wei": "1", "precompiled": { "name": "alt_bn128_G1_mul", "linear": { "base": 15, "word": 3 } } },
+		"0000000000000000000000000000000000000008": { "wei": "1", "precompiled": { "name": "alt_bn128_pairing_product", "linear": { "base": 15, "word": 3 } } },
+		}
 }
 )E";

libethashseal/genesis/metropolisTest.cpp

@@ -26,14 +26,19 @@ using namespace std;
 using namespace dev;
 using namespace eth;
 
-PrecompiledContract::PrecompiledContract(unsigned _base, unsigned _word, std::function<bytes(bytesConstRef)> const& _exec):
+PrecompiledContract::PrecompiledContract(
+	unsigned _base,
+	unsigned _word,
+	std::function<bytes(bytesConstRef)> const& _exec,
+	u256 const& _startingBlock
+):
 	PrecompiledContract([=](unsigned size) -> bigint
 	{
 		bigint s = size;
 		bigint b = _base;
 		bigint w = _word;
 		return b + (s + 31) / 32 * w;
-	}, _exec)
+	}, _exec, _startingBlock)
 {}
 
 ChainOperationParams::ChainOperationParams()

libethcore/ChainOperationParams.cpp

@@ -34,18 +34,31 @@ class PrecompiledContract
 {
 public:
 	PrecompiledContract() = default;
-	PrecompiledContract(std::function<bigint(size_t)> const& _cost, std::function<bytes(bytesConstRef)> const& _exec):
+	PrecompiledContract(
+		std::function<bigint(size_t)> const& _cost,
+		std::function<bytes(bytesConstRef)> const& _exec,
+		u256 const& _startingBlock
+	):
 		m_cost(_cost),
-		m_execute(_exec)
+		m_execute(_exec),
+		m_startingBlock(_startingBlock)
 	{}
-	PrecompiledContract(unsigned _base, unsigned _word, std::function<bytes(bytesConstRef)> const& _exec);
+	PrecompiledContract(
+		unsigned _base,
+		unsigned _word,
+		std::function<bytes(bytesConstRef)> const& _exec,
+		u256 const& _startingBlock
+	);
 
 	bigint cost(bytesConstRef _in) const { return m_cost(_in.size()); }
 	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;
+	u256 m_startingBlock = 0;
 };
 
 struct ChainOperationParams

libethcore/ChainOperationParams.h

@@ -77,9 +77,12 @@ class SealEngineFace
 	SealEngineFace* withChainParams(ChainOperationParams const& _params) { setChainParams(_params); return this; }
 	virtual EVMSchedule const& evmSchedule(EnvInfo const&) const = 0;
 
-	virtual bool isPrecompiled(Address const& _a) const { return m_params.precompiled.count(_a) != 0; }
-	virtual bigint costOfPrecompiled(Address const& _a, bytesConstRef _in) const { return m_params.precompiled.at(_a).cost(_in); }
-	virtual bytes executePrecompiled(Address const& _a, bytesConstRef _in) const { return m_params.precompiled.at(_a).execute(_in); }
+	virtual bool isPrecompiled(Address const& _a, u256 const& _blockNumber) const
+	{
+		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); }
 
 protected:
 	virtual bool onOptionChanging(std::string const&, bytes const&) { return true; }

libethcore/SealEngine.h

@@ -116,15 +116,20 @@ 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"))
+			{
+				cwarn << "No gas cost given for precompiled contract " << n << endl;
+				throw;
+			}
 			try
 			{
-				if (p.count("linear"))
-				{
-					auto l = p["linear"].get_obj();
-					unsigned base = toUnsigned(l["base"]);
-					unsigned word = toUnsigned(l["word"]);
-					o_precompiled->insert(make_pair(a, PrecompiledContract(base, word, PrecompiledRegistrar::executor(n))));
-				}
+				auto l = p["linear"].get_obj();
+				u256 startingBlock = 0;
+				if (p.count("startingBlock"))
+					startingBlock = u256(p["startingBlock"]);
+				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)
 			{

libethereum/Account.cpp

@@ -262,9 +262,9 @@ bool Executive::call(CallParameters const& _p, u256 const& _gasPrice, Address co
 
 	m_savepoint = m_s.savepoint();
 
-	if (m_sealEngine.isPrecompiled(_p.codeAddress))
+	if (m_sealEngine.isPrecompiled(_p.codeAddress, m_envInfo.number()))
 	{
-		bigint g = m_sealEngine.costOfPrecompiled(_p.codeAddress, _p.data);
+		bigint g = m_sealEngine.costOfPrecompiled(_p.codeAddress, _p.data, m_envInfo.number());
 		if (_p.gas < g)
 		{
 			m_excepted = TransactionException::OutOfGasBase;
@@ -274,7 +274,7 @@ 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);
+			bytes output = m_sealEngine.executePrecompiled(_p.codeAddress, _p.data, m_envInfo.number());
 			size_t outputSize = output.size();
 			m_output = owning_bytes_ref{std::move(output), 0, outputSize};
 		}
@@ -473,4 +473,4 @@ void Executive::revert()
 	// Set result address to the null one.
 	m_newAddress = {};
 	m_s.rollback(m_savepoint);
-}
+}

libethereum/Executive.cpp

@@ -16,7 +16,7 @@ namespace dev {
                 {
                     this->bindAndAddMethod(jsonrpc::Procedure("debug_traceTransaction", jsonrpc::PARAMS_BY_POSITION, jsonrpc::JSON_OBJECT, "param1",jsonrpc::JSON_STRING,"param2",jsonrpc::JSON_OBJECT, NULL), &dev::rpc::DebugFace::debug_traceTransactionI);
                     this->bindAndAddMethod(jsonrpc::Procedure("debug_storageRangeAt", jsonrpc::PARAMS_BY_POSITION, jsonrpc::JSON_OBJECT, "param1",jsonrpc::JSON_STRING,"param2",jsonrpc::JSON_INTEGER,"param3",jsonrpc::JSON_STRING,"param4",jsonrpc::JSON_STRING,"param5",jsonrpc::JSON_INTEGER, NULL), &dev::rpc::DebugFace::debug_storageRangeAtI);
-                    this->bindAndAddMethod(jsonrpc::Procedure("debug_preimage", jsonrpc::PARAMS_BY_POSITION, jsonrpc::JSON_OBJECT, "param1",jsonrpc::JSON_STRING, NULL), &dev::rpc::DebugFace::debug_preimageI);
+                    this->bindAndAddMethod(jsonrpc::Procedure("debug_preimage", jsonrpc::PARAMS_BY_POSITION, jsonrpc::JSON_STRING, "param1",jsonrpc::JSON_STRING, NULL), &dev::rpc::DebugFace::debug_preimageI);
                     this->bindAndAddMethod(jsonrpc::Procedure("debug_traceBlockByNumber", jsonrpc::PARAMS_BY_POSITION, jsonrpc::JSON_OBJECT, "param1",jsonrpc::JSON_INTEGER,"param2",jsonrpc::JSON_OBJECT, NULL), &dev::rpc::DebugFace::debug_traceBlockByNumberI);
                     this->bindAndAddMethod(jsonrpc::Procedure("debug_traceBlockByHash", jsonrpc::PARAMS_BY_POSITION, jsonrpc::JSON_OBJECT, "param1",jsonrpc::JSON_STRING,"param2",jsonrpc::JSON_OBJECT, NULL), &dev::rpc::DebugFace::debug_traceBlockByHashI);
                     this->bindAndAddMethod(jsonrpc::Procedure("debug_traceCall", jsonrpc::PARAMS_BY_POSITION, jsonrpc::JSON_OBJECT, "param1",jsonrpc::JSON_OBJECT,"param2",jsonrpc::JSON_STRING,"param3",jsonrpc::JSON_OBJECT, NULL), &dev::rpc::DebugFace::debug_traceCallI);