interop: Check Access Lists in Builder (#541)

* Basic wiring: add CheckAccessList, stub CheckMessages

* Make AccessList Filter

* Implement Ingress Filter with Access Lists

* Use Full Execution Descriptior

* Early check expiry in filter

* Move TxToInteropAccessList to Interop Types package

* interop: Check Access Lists in Builder

* Remove Interop PostValidation Diff Code

* Only checkInterop if isInterop

---------

Co-authored-by: protolambda <[email protected]>

Author: axelKingsley

core/state_processor.go

@@ -225,21 +225,10 @@ func MakeReceipt(evm *vm.EVM, result *ExecutionResult, statedb *state.StateDB, b
 // for the transaction, gas used and an error if the transaction failed,
 // indicating the block was invalid.
 func ApplyTransaction(evm *vm.EVM, gp *GasPool, statedb *state.StateDB, header *types.Header, tx *types.Transaction, usedGas *uint64) (*types.Receipt, error) {
-	return ApplyTransactionExtended(evm, gp, statedb, header, tx, usedGas, nil)
-}
-
-type ApplyTransactionOpts struct {
-	PostValidation func(evm *vm.EVM, result *ExecutionResult) error
-}
-
-func ApplyTransactionExtended(evm *vm.EVM, gp *GasPool, statedb *state.StateDB, header *types.Header, tx *types.Transaction, usedGas *uint64, extraOpts *ApplyTransactionOpts) (*types.Receipt, error) {
 	msg, err := TransactionToMessage(tx, types.MakeSigner(evm.ChainConfig(), header.Number, header.Time), header.BaseFee)
 	if err != nil {
 		return nil, err
 	}
-	if extraOpts != nil {
-		msg.PostValidation = extraOpts.PostValidation
-	}
 	// Create a new context to be used in the EVM environment
 	return ApplyTransactionWithEVM(msg, gp, statedb, header.Number, header.Hash(), tx, usedGas, evm)
 }

core/state_transition.go

@@ -169,10 +169,6 @@ type Message struct {
 	IsDepositTx    bool                 // IsDepositTx indicates the message is force-included and can persist a mint.
 	Mint           *big.Int             // Mint is the amount to mint before EVM processing, or nil if there is no minting.
 	RollupCostData types.RollupCostData // RollupCostData caches data to compute the fee we charge for data availability
-
-	// PostValidation is an optional check of the resulting post-state, if and when the message is
-	// applied fully to the EVM. This function may return an error to deny inclusion of the message.
-	PostValidation func(evm *vm.EVM, result *ExecutionResult) error
 }
 
 // TransactionToMessage converts a transaction into a Message.
@@ -490,13 +486,6 @@ func (st *stateTransition) execute() (*ExecutionResult, error) {
 		}
 		err = nil
 	}
-
-	if err == nil && st.msg.PostValidation != nil {
-		if err := st.msg.PostValidation(st.evm, result); err != nil {
-			return nil, err
-		}
-	}
-
 	return result, err
 }
 

eth/interop.go

@@ -10,10 +10,6 @@ import (
 	"github.com/ethereum/go-ethereum/miner"
 )
 
-func (s *Ethereum) CheckMessages(ctx context.Context, messages []interoptypes.Message, minSafety interoptypes.SafetyLevel, executingTimestamp uint64) error {
-	return errors.New("deprecated. use CheckAccessList")
-}
-
 func (s *Ethereum) CheckAccessList(ctx context.Context, inboxEntries []common.Hash, minSafety interoptypes.SafetyLevel, execDesc interoptypes.ExecutingDescriptor) error {
 	if s.interopRPC == nil {
 		return errors.New("cannot check interop access list, no RPC available")

eth/interop/interop.go

@@ -48,11 +48,6 @@ func NewInteropClient(rpcEndpoint string) *InteropClient {
 	return &InteropClient{endpoint: rpcEndpoint}
 }
 
-// CheckMessages checks if the given messages meet the given minimum safety level.
-func (cl *InteropClient) CheckMessages(ctx context.Context, messages []interoptypes.Message, minSafety interoptypes.SafetyLevel, executingDescriptor interoptypes.ExecutingDescriptor) error {
-	return errors.New("deprecated. use CheckAccessList")
-}
-
 func (cl *InteropClient) CheckAccessList(ctx context.Context, inboxEntries []common.Hash, minSafety interoptypes.SafetyLevel, executingDescriptor interoptypes.ExecutingDescriptor) error {
 	if err := cl.maybeDial(ctx); err != nil {
 		return err

miner/miner.go

@@ -47,7 +47,6 @@ type BackendWithHistoricalState interface {
 }
 
 type BackendWithInterop interface {
-	CheckMessages(ctx context.Context, messages []interoptypes.Message, minSafety interoptypes.SafetyLevel, executingTimestamp uint64) error
 	CheckAccessList(ctx context.Context, inboxEntries []common.Hash, minSafety interoptypes.SafetyLevel, executingDescriptor interoptypes.ExecutingDescriptor) error
 }
 

miner/worker.go

@@ -421,51 +421,30 @@ func (miner *Miner) commitBlobTransaction(env *environment, tx *types.Transactio
 	return nil
 }
 
-type LogInspector interface {
-	GetLogs(hash common.Hash, blockNumber uint64, blockHash common.Hash) []*types.Log
-}
-
 // applyTransaction runs the transaction. If execution fails, state and gas pool are reverted.
 func (miner *Miner) applyTransaction(env *environment, tx *types.Transaction) (*types.Receipt, error) {
 	var (
 		snap = env.state.Snapshot()
 		gp   = env.gasPool.Gas()
 	)
-	var extraOpts *core.ApplyTransactionOpts
-	// If not just reproducing the block, check the interop executing messages.
 	if !env.noTxs && miner.chain.Config().IsInterop(env.header.Time) {
-		// Whenever there are `noTxs` it means we are building a block from pre-determined txs. There are two cases:
-		//	(1) it's derived from L1, and will be verified asynchronously by the op-node.
-		//	(2) it is a deposits-only empty-block by the sequencer, in which case there are no interop-txs to verify (as deposits do not emit any).
-
-		// We have to insert as call-back, since we cannot revert the snapshot
-		// after the tx is deemed successful and the journal has been cleared already.
-		extraOpts = &core.ApplyTransactionOpts{
-			PostValidation: func(evm *vm.EVM, result *core.ExecutionResult) error {
-				logInspector, ok := evm.StateDB.(LogInspector)
-				if !ok {
-					return fmt.Errorf("cannot get logs from StateDB type %T", evm.StateDB)
-				}
-				logs := logInspector.GetLogs(tx.Hash(), env.header.Number.Uint64(), common.Hash{})
-				return miner.checkInterop(env.rpcCtx, tx, result.Failed(), logs, env.header.Time)
-			},
+		// avoid execution if the interop check fails
+		if err := miner.checkInterop(env.rpcCtx, tx, env.header.Time); err != nil {
+			return nil, err
 		}
 	}
-	receipt, err := core.ApplyTransactionExtended(env.evm, env.gasPool, env.state, env.header, tx, &env.header.GasUsed, extraOpts)
+	receipt, err := core.ApplyTransaction(env.evm, env.gasPool, env.state, env.header, tx, &env.header.GasUsed)
 	if err != nil {
 		env.state.RevertToSnapshot(snap)
 		env.gasPool.SetGas(gp)
 	}
 	return receipt, err
 }
 
-func (miner *Miner) checkInterop(ctx context.Context, tx *types.Transaction, failed bool, logs []*types.Log, logTimestamp uint64) error {
+func (miner *Miner) checkInterop(ctx context.Context, tx *types.Transaction, logTimestamp uint64) error {
 	if tx.Type() == types.DepositTxType {
 		return nil // deposit-txs are always safe
 	}
-	if failed {
-		return nil // failed txs don't persist any logs
-	}
 	if tx.Rejected() {
 		return errors.New("transaction was previously rejected")
 	}
@@ -476,14 +455,11 @@ func (miner *Miner) checkInterop(ctx context.Context, tx *types.Transaction, fai
 	if ctx == nil { // check if the miner was set up correctly to interact with an RPC
 		return errors.New("need RPC context to check executing messages")
 	}
-	executingMessages, err := interoptypes.ExecutingMessagesFromLogs(logs)
-	if err != nil {
-		return fmt.Errorf("cannot parse interop messages from receipt of %s: %w", tx.Hash(), err)
-	}
-	if len(executingMessages) == 0 {
+	accessList := interoptypes.TxToInteropAccessList(tx)
+	if len(accessList) == 0 {
 		return nil // avoid an RPC check if there are no executing messages to verify.
 	}
-	if err := b.CheckMessages(ctx, executingMessages, interoptypes.CrossUnsafe, logTimestamp); err != nil {
+	if err := b.CheckAccessList(ctx, accessList, interoptypes.CrossUnsafe, interoptypes.ExecutingDescriptor{Timestamp: logTimestamp, Timeout: 0}); err != nil {
 		if ctx.Err() != nil { // don't reject transactions permanently on RPC timeouts etc.
 			log.Debug("CheckMessages timed out", "err", ctx.Err())
 			return err