sync: coreth PR #1166: refactor predication verification logic (#1749)

Signed-off-by: Jonathan Oppenheimer <[email protected]>
Co-authored-by: Stephen Buttolph <[email protected]>

Author: JonathanOppenheimer

core/predicate_check.go

@@ -18,50 +18,90 @@ import (
 
 var ErrMissingPredicateContext = errors.New("missing predicate context")
 
-// CheckPredicates verifies the predicates of [tx] and returns the result. Returning an error invalidates the block.
-func CheckPredicates(rules params.Rules, predicateContext *precompileconfig.PredicateContext, tx *types.Transaction) (predicate.PrecompileResults, error) {
-	// Check that the transaction can cover its IntrinsicGas (including the gas required by the predicate) before
-	// verifying the predicate.
-	intrinsicGas, err := IntrinsicGas(tx.Data(), tx.AccessList(), tx.To() == nil, rules)
+// CheckBlockPredicates verifies the predicates of a block of transactions and
+// returns the results.
+//
+// Returning an error invalidates the block.
+func CheckBlockPredicates(
+	rules params.Rules,
+	predicateContext *precompileconfig.PredicateContext,
+	txs []*types.Transaction,
+) (predicate.BlockResults, error) {
+	var results predicate.BlockResults
+	// TODO: Calculate tx predicates concurrently.
+	for _, tx := range txs {
+		txResults, err := CheckTxPredicates(rules, predicateContext, tx)
+		if err != nil {
+			return nil, err
+		}
+		results.Set(tx.Hash(), txResults)
+	}
+	return results, nil
+}
+
+// CheckTxPredicates verifies the predicates of a transaction and returns the
+// results.
+//
+// Returning an error invalidates the transaction.
+func CheckTxPredicates(
+	rules params.Rules,
+	predicateContext *precompileconfig.PredicateContext,
+	tx *types.Transaction,
+) (predicate.PrecompileResults, error) {
+	// Check that the transaction can cover its IntrinsicGas, including the gas
+	// required by the predicate, before verifying the predicate.
+	accessList := tx.AccessList()
+	intrinsicGas, err := IntrinsicGas(tx.Data(), accessList, tx.To() == nil, rules)
 	if err != nil {
 		return nil, err
 	}
-	if tx.Gas() < intrinsicGas {
-		return nil, fmt.Errorf("%w for predicate verification (%d) < intrinsic gas (%d)", ErrIntrinsicGas, tx.Gas(), intrinsicGas)
+	if gas := tx.Gas(); gas < intrinsicGas {
+		return nil, fmt.Errorf("%w for predicate verification (%d) < intrinsic gas (%d)",
+			ErrIntrinsicGas,
+			gas,
+			intrinsicGas,
+		)
 	}
 
 	rulesExtra := params.GetRulesExtra(rules)
-	predicateResults := make(predicate.PrecompileResults)
 	// Short circuit early if there are no precompile predicates to verify
 	if !rulesExtra.PredicatersExist() {
-		return predicateResults, nil
+		return nil, nil
 	}
 
 	// Prepare the predicate storage slots from the transaction's access list
-	predicateArguments := predicate.FromAccessList(rulesExtra, tx.AccessList())
+	predicateArguments := predicate.FromAccessList(rulesExtra, accessList)
 
-	// If there are no predicates to verify, return early and skip requiring the proposervm block
-	// context to be populated.
+	// If there are no predicates to verify, return early and skip requiring the
+	// proposervm block context to be populated.
 	if len(predicateArguments) == 0 {
-		return predicateResults, nil
+		return nil, nil
 	}
 
 	if predicateContext == nil || predicateContext.ProposerVMBlockCtx == nil {
 		return nil, ErrMissingPredicateContext
 	}
 
+	var (
+		txHash           = tx.Hash()
+		predicateResults = make(predicate.PrecompileResults, len(predicateArguments))
+	)
 	for address, predicates := range predicateArguments {
-		// Since [address] is only added to [predicateArguments] when there's a valid predicate in the ruleset
-		// there's no need to check if the predicate exists here.
-		rules := params.GetRulesExtra(rules)
-		predicaterContract := rules.Predicaters[address]
+		// Since address is only added to predicateArguments when there's a
+		// valid predicate in the ruleset there's no need to check if the
+		// predicate exists here.
+		predicaterContract := rulesExtra.Predicaters[address]
 		bitset := set.NewBits()
 		for i, predicate := range predicates {
 			if err := predicaterContract.VerifyPredicate(predicateContext, predicate); err != nil {
 				bitset.Add(i)
 			}
 		}
-		log.Debug("predicate verify", "tx", tx.Hash(), "address", address, "res", bitset.Bytes())
+		log.Debug("predicate verify",
+			"tx", txHash,
+			"address", address,
+			"res", bitset.String(),
+		)
 		predicateResults[address] = bitset
 	}
 	return predicateResults, nil