Floria: Add nonce and eoa check

go/processor/floria/processor.go

@@ -26,6 +26,7 @@ const (
 
 	createGasCostPerByte = 200
 	maxCodeSize          = 24576
+	maxInitCodeSize      = 2 * maxCodeSize
 
 	MaxRecursiveDepth = 1024 // Maximum depth of call/create stack.
 )
@@ -55,6 +56,14 @@ func (p *processor) Run(
 	}
 	gas := transaction.GasLimit
 
+	if nonceCheck(transaction.Nonce, context.GetNonce(transaction.Sender)) != nil {
+		return tosca.Receipt{}, nil
+	}
+
+	if eoaCheck(transaction.Sender, context) != nil {
+		return tosca.Receipt{}, nil
+	}
+
 	if err := buyGas(transaction, context); err != nil {
 		return tosca.Receipt{}, nil
 	}
@@ -65,8 +74,9 @@ func (p *processor) Run(
 	}
 	gas -= intrinsicGas
 
-	if err := handleNonce(transaction, context); err != nil {
-		return errorReceipt, nil
+	if blockParameters.Revision >= tosca.R12_Shanghai && transaction.Recipient == nil &&
+		len(transaction.Input) > maxInitCodeSize {
+		return tosca.Receipt{}, nil
 	}
 
 	transactionParameters := tosca.TransactionParameters{
@@ -91,6 +101,10 @@ func (p *processor) Run(
 	callParameters := callParameters(transaction, gas)
 	kind := callKind(transaction)
 
+	if kind == tosca.Call {
+		context.SetNonce(transaction.Sender, context.GetNonce(transaction.Sender)+1)
+	}
+
 	result, err := runContext.Call(kind, callParameters)
 	if err != nil {
 		return errorReceipt, err
@@ -123,6 +137,25 @@ func (p *processor) Run(
 	}, nil
 }
 
+func nonceCheck(transactionNonce uint64, stateNonce uint64) error {
+	if transactionNonce != stateNonce {
+		return fmt.Errorf("nonce mismatch: %v != %v", transactionNonce, stateNonce)
+	}
+	if stateNonce+1 < stateNonce {
+		return fmt.Errorf("nonce overflow")
+	}
+	return nil
+}
+
+// Only accept transactions from externally owned accounts (EOAs) and not from contracts
+func eoaCheck(sender tosca.Address, context tosca.TransactionContext) error {
+	codehash := context.GetCodeHash(sender)
+	if codehash != (tosca.Hash{}) && codehash != emptyCodeHash {
+		return fmt.Errorf("sender is not an EOA")
+	}
+	return nil
+}
+
 func setUpAccessList(transaction tosca.Transaction, context tosca.TransactionContext, revision tosca.Revision) {
 	if transaction.AccessList == nil {
 		return
@@ -237,18 +270,6 @@ func setupGasBilling(transaction tosca.Transaction) tosca.Gas {
 	return tosca.Gas(gas)
 }
 
-func handleNonce(transaction tosca.Transaction, context tosca.TransactionContext) error {
-	stateNonce := context.GetNonce(transaction.Sender)
-	messageNonce := transaction.Nonce
-	if messageNonce != stateNonce {
-		return fmt.Errorf("nonce mismatch: %v != %v", messageNonce, stateNonce)
-	}
-	if transaction.Recipient != nil {
-		context.SetNonce(transaction.Sender, stateNonce+1)
-	}
-	return nil
-}
-
 func buyGas(transaction tosca.Transaction, context tosca.TransactionContext) error {
 	gas := transaction.GasPrice.Scale(uint64(transaction.GasLimit))
 

go/processor/floria/processor_test.go

@@ -11,6 +11,7 @@
 package floria
 
 import (
+	"math"
 	"reflect"
 	"testing"
 
@@ -35,38 +36,63 @@ func TestProcessor_HandleNonce(t *testing.T) {
 	context := tosca.NewMockTransactionContext(ctrl)
 
 	context.EXPECT().GetNonce(tosca.Address{1}).Return(uint64(9))
-	context.EXPECT().SetNonce(tosca.Address{1}, uint64(10))
-	context.EXPECT().GetNonce(tosca.Address{1}).Return(uint64(10))
 
 	transaction := tosca.Transaction{
-		Sender:    tosca.Address{1},
-		Recipient: &tosca.Address{2},
-		Nonce:     9,
+		Sender: tosca.Address{1},
+		Nonce:  9,
 	}
 
-	err := handleNonce(transaction, context)
+	err := nonceCheck(transaction.Nonce, context.GetNonce(transaction.Sender))
 	if err != nil {
-		t.Errorf("handleNonce returned an error: %v", err)
-	}
-	if context.GetNonce(transaction.Sender) != 10 {
-		t.Errorf("Nonce was not incremented")
+		t.Errorf("nonceCheck returned an error: %v", err)
 	}
 }
 
-func TestProcessor_NonceMissmatch(t *testing.T) {
-	ctrl := gomock.NewController(t)
-	context := tosca.NewMockTransactionContext(ctrl)
+func TestProcessor_NonceOverflowIsDetected(t *testing.T) {
+	err := nonceCheck(math.MaxUint64, math.MaxUint64)
+	if err == nil {
+		t.Errorf("nonceCheck did not spot nonce overflow")
+	}
+}
 
-	context.EXPECT().GetNonce(tosca.Address{1}).Return(uint64(5))
+func TestProcessor_NonceMissMatch(t *testing.T) {
+	err := nonceCheck(uint64(10), uint64(42))
+	if err == nil {
+		t.Errorf("nonceCheck did not spot nonce miss match")
+	}
+}
 
-	transaction := tosca.Transaction{
-		Sender:    tosca.Address{1},
-		Recipient: &tosca.Address{2},
-		Nonce:     10,
+func TestProcessor_EoaCheck(t *testing.T) {
+	tests := map[string]struct {
+		codeHash tosca.Hash
+		isEOA    bool
+	}{
+		"empty": {
+			tosca.Hash{},
+			false,
+		},
+		"emptyHash": {
+			emptyCodeHash,
+			false,
+		},
+		"nonEmpty": {
+			tosca.Hash{1, 2, 3},
+			true,
+		},
 	}
-	err := handleNonce(transaction, context)
-	if err == nil {
-		t.Errorf("handleNonce did not spot nonce miss match")
+
+	for testName, test := range tests {
+		t.Run(testName, func(t *testing.T) {
+			ctrl := gomock.NewController(t)
+			context := tosca.NewMockTransactionContext(ctrl)
+
+			context.EXPECT().GetCodeHash(tosca.Address{1}).Return(test.codeHash)
+
+			err := eoaCheck(tosca.Address{1}, context)
+			if test.isEOA && err == nil {
+				t.Errorf("eoaCheck returned wrong result: %v", err)
+			}
+		})
 	}
 }