Merge pull request #3597 from ethereum/eip86

EIP86

Author: chriseth

libdevcrypto/Common.cpp

@@ -65,6 +65,8 @@ bool dev::SignatureStruct::isValid() const noexcept
 
 Address dev::ZeroAddress = Address();
 
+Address dev::MaxAddress = Address("0xffffffffffffffffffffffffffffffffffffffff");
+
 Public dev::toPublic(Secret const& _secret)
 {
 	auto* ctx = getCtx();

libdevcrypto/Common.h

@@ -64,6 +64,9 @@ using Address = h160;
 /// The zero address.
 extern Address ZeroAddress;
 
+/// The last address.
+extern Address MaxAddress;
+
 /// A vector of Ethereum addresses.
 using Addresses = h160s;
 

libethashseal/Ethash.cpp

@@ -146,10 +146,10 @@ void Ethash::verify(Strictness _s, BlockHeader const& _bi, BlockHeader const& _p
 
 void Ethash::verifyTransaction(ImportRequirements::value _ir, TransactionBase const& _t, BlockHeader const& _bi) const
 {
+	SealEngineFace::verifyTransaction(_ir, _t, _bi);
+
 	if (_ir & ImportRequirements::TransactionSignatures)
 	{
-		if (_bi.number() >= chainParams().u256Param("homsteadForkBlock"))
-			_t.checkLowS();
 		if (_bi.number() >= chainParams().u256Param("EIP158ForkBlock"))
 		{
 			int chainID(chainParams().u256Param("chainID"));

libethcore/Common.h

@@ -104,7 +104,8 @@ enum class ImportResult
 	AlreadyKnown,
 	Malformed,
 	OverbidGasPrice,
-	BadChain
+	BadChain,
+	ZeroSignature
 };
 
 struct ImportRequirements

libethcore/SealEngine.cpp

@@ -43,9 +43,11 @@ void SealEngineFace::populateFromParent(BlockHeader& _bi, BlockHeader const& _pa
 	_bi.populateFromParent(_parent);
 }
 
-void SealEngineFace::verifyTransaction(ImportRequirements::value _ir, TransactionBase const& _t, BlockHeader const&) const
+void SealEngineFace::verifyTransaction(ImportRequirements::value _ir, TransactionBase const& _t, BlockHeader const& _bi) const
 {
-	if (_ir & ImportRequirements::TransactionSignatures)
+	if ((_ir & ImportRequirements::TransactionSignatures) && _bi.number() < chainParams().u256Param("metropolisForkBlock") && _t.hasZeroSignature())
+		BOOST_THROW_EXCEPTION(InvalidSignature());
+	if (_bi.number() >= chainParams().u256Param("homsteadForkBlock") && (_ir & ImportRequirements::TransactionSignatures))
 		_t.checkLowS();
 }
 

libethcore/Transaction.cpp

@@ -70,23 +70,29 @@ TransactionBase::TransactionBase(bytesConstRef _rlpData, CheckTransaction _check
 		h256 r = rlp[field = 7].toInt<u256>();
 		h256 s = rlp[field = 8].toInt<u256>();
 
-		if (v > 36)
-			m_chainId = (v - 35) / 2;
-		else if (v == 27 || v == 28)
-			m_chainId = -4;
+		m_vrs = SignatureStruct{ r, s, v };
+
+		if (hasZeroSignature())
+			m_chainId = m_vrs.v;
 		else
-			BOOST_THROW_EXCEPTION(InvalidSignature());
+		{
+			if (v > 36)
+				m_chainId = (v - 35) / 2;
+			else if (v == 27 || v == 28)
+				m_chainId = -4;
+			else
+				BOOST_THROW_EXCEPTION(InvalidSignature());
+			m_vrs.v = v - (m_chainId * 2 + 35);
+
+			if (_checkSig >= CheckTransaction::Cheap && !m_vrs.isValid())
+				BOOST_THROW_EXCEPTION(InvalidSignature());
+		}
 
-		v = v - (m_chainId * 2 + 35);
+		if (_checkSig == CheckTransaction::Everything)
+			m_sender = sender();
 
 		if (rlp.itemCount() > 9)
 			BOOST_THROW_EXCEPTION(InvalidTransactionFormat() << errinfo_comment("to many fields in the transaction RLP"));
-
-		m_vrs = SignatureStruct{ r, s, v };
-		if (_checkSig >= CheckTransaction::Cheap && !m_vrs.isValid())
-			BOOST_THROW_EXCEPTION(InvalidSignature());
-		if (_checkSig == CheckTransaction::Everything)
-			m_sender = sender();
 	}
 	catch (Exception& _e)
 	{
@@ -111,10 +117,15 @@ Address const& TransactionBase::sender() const
 {
 	if (!m_sender)
 	{
-		auto p = recover(m_vrs, sha3(WithoutSignature));
-		if (!p)
-			BOOST_THROW_EXCEPTION(InvalidSignature());
-		m_sender = right160(dev::sha3(bytesConstRef(p.data(), sizeof(p))));
+		if (hasZeroSignature())
+			m_sender = MaxAddress;
+		else
+		{
+			auto p = recover(m_vrs, sha3(WithoutSignature));
+			if (!p)
+				BOOST_THROW_EXCEPTION(InvalidSignature());
+			m_sender = right160(dev::sha3(bytesConstRef(p.data(), sizeof(p))));
+		}
 	}
 	return m_sender;
 }

libethcore/Transaction.h

@@ -142,6 +142,8 @@ class TransactionBase
 	/// @returns the signature of the transaction. Encodes the sender.
 	SignatureStruct const& signature() const { return m_vrs; }
 
+	bool hasZeroSignature() const { return !m_vrs.s && !m_vrs.r; }
+
 	void sign(Secret const& _priv);			///< Sign the transaction.
 
 	/// @returns amount of gas required for the basic payment.

libethereum/Executive.cpp

@@ -198,23 +198,26 @@ void Executive::initialize(Transaction const& _transaction)
 		BOOST_THROW_EXCEPTION(OutOfGasBase() << RequirementError((bigint)m_baseGasRequired, (bigint)m_t.gas()));
 	}
 
-	// Avoid invalid transactions.
-	u256 nonceReq;
-	try
+	if (!m_t.hasZeroSignature())
 	{
-		nonceReq = m_s.getNonce(m_t.sender());
-	}
-	catch (...)
-	{
-		clog(ExecutiveWarnChannel) << "Invalid Signature";
-		m_excepted = TransactionException::InvalidSignature;
-		throw;
-	}
-	if (m_t.nonce() != nonceReq)
-	{
-		clog(ExecutiveWarnChannel) << "Invalid Nonce: Require" << nonceReq << " Got" << m_t.nonce();
-		m_excepted = TransactionException::InvalidNonce;
-		BOOST_THROW_EXCEPTION(InvalidNonce() << RequirementError((bigint)nonceReq, (bigint)m_t.nonce()));
+		// Avoid invalid transactions.
+		u256 nonceReq;
+		try
+		{
+			nonceReq = m_s.getNonce(m_t.sender());
+		}
+		catch (InvalidSignature const& e)
+		{
+			clog(ExecutiveWarnChannel) << "Invalid Signature";
+			m_excepted = TransactionException::InvalidSignature;
+			throw;
+		}
+		if (m_t.nonce() != nonceReq)
+		{
+			clog(ExecutiveWarnChannel) << "Invalid Nonce: Require" << nonceReq << " Got" << m_t.nonce();
+			m_excepted = TransactionException::InvalidNonce;
+			BOOST_THROW_EXCEPTION(InvalidNonce() << RequirementError((bigint)nonceReq, (bigint)m_t.nonce()));
+		}
 	}
 
 	// Avoid unaffordable transactions.

libethereum/TransactionQueue.cpp

@@ -57,34 +57,15 @@ TransactionQueue::~TransactionQueue()
 
 ImportResult TransactionQueue::import(bytesConstRef _transactionRLP, IfDropped _ik)
 {
-	// Check if we already know this transaction.
-	h256 h = sha3(_transactionRLP);
-
-	Transaction t;
-	ImportResult ir;
+	try
 	{
-		UpgradableGuard l(m_lock);
-
-		ir = check_WITH_LOCK(h, _ik);
-		if (ir != ImportResult::Success)
-			return ir;
-
-		try
-		{
-			// Check validity of _transactionRLP as a transaction. To do this we just deserialise and attempt to determine the sender.
-			// If it doesn't work, the signature is bad.
-			// The transaction's nonce may yet be invalid (or, it could be "valid" but we may be missing a marginally older transaction).
-			t = Transaction(_transactionRLP, CheckTransaction::Everything);
-			UpgradeGuard ul(l);
-//			cdebug << "Importing" << t;
-			ir = manageImport_WITH_LOCK(h, t);
-		}
-		catch (...)
-		{
-			return ImportResult::Malformed;
-		}
+		Transaction t = Transaction(_transactionRLP, CheckTransaction::Everything);
+		return import(t, _ik);
+	}
+	catch (Exception const&)
+	{
+		return ImportResult::Malformed;
 	}
-	return ir;
 }
 
 ImportResult TransactionQueue::check_WITH_LOCK(h256 const& _h, IfDropped _ik)
@@ -100,6 +81,8 @@ ImportResult TransactionQueue::check_WITH_LOCK(h256 const& _h, IfDropped _ik)
 
 ImportResult TransactionQueue::import(Transaction const& _transaction, IfDropped _ik)
 {
+	if (_transaction.hasZeroSignature())
+		return ImportResult::ZeroSignature;
 	// Check if we already know this transaction.
 	h256 h = _transaction.sha3(WithSignature);
 

test/libethereum/TransactionQueue.cpp

@@ -31,6 +31,20 @@ using namespace dev::test;
 
 BOOST_FIXTURE_TEST_SUITE(TransactionQueueSuite, TestOutputHelper)
 
+BOOST_AUTO_TEST_CASE(TransactionEIP86)
+{
+	dev::eth::TransactionQueue txq;
+	Address to = Address("0xa94f5374fce5edbc8e2a8697c15331677e6ebf0b");
+	RLPStream streamRLP;
+	streamRLP.appendList(9);
+	streamRLP << 0 << 10 * szabo << 25000;
+	streamRLP << to << 0 << bytes() << 0 << 0 << 0;
+	Transaction tx0(streamRLP.out(), CheckTransaction::Everything);
+	ImportResult result = txq.import(tx0);
+	BOOST_CHECK(result == ImportResult::ZeroSignature);
+	BOOST_CHECK(txq.knownTransactions().size() == 0);
+}
+
 BOOST_AUTO_TEST_CASE(tqMaxNonce)
 {
 	dev::eth::TransactionQueue txq;
@@ -59,7 +73,6 @@ BOOST_AUTO_TEST_CASE(tqMaxNonce)
 	BOOST_CHECK(10 == txq.maxNonce(to));
 	txq.import(tx2);
 	BOOST_CHECK(10 == txq.maxNonce(to));
-
 }
 
 BOOST_AUTO_TEST_CASE(tqPriority)