interop: New sequencer executing message check API (#521)

* interop: New sequencer executing message check API

* interop: Use struct for rpc timestamp input

Author: Inphi

core/txpool/ingress_filters.go

@@ -17,13 +17,13 @@ type IngressFilter interface {
 }
 
 type interopFilter struct {
-	logsFn  func(tx *types.Transaction) ([]*types.Log, error)
-	checkFn func(ctx context.Context, ems []interoptypes.Message, safety interoptypes.SafetyLevel) error
+	logsFn  func(tx *types.Transaction) (logs []*types.Log, logTimestamp uint64, err error)
+	checkFn func(ctx context.Context, ems []interoptypes.Message, safety interoptypes.SafetyLevel, emsTimestamp uint64) error
 }
 
 func NewInteropFilter(
-	logsFn func(tx *types.Transaction) ([]*types.Log, error),
-	checkFn func(ctx context.Context, ems []interoptypes.Message, safety interoptypes.SafetyLevel) error) IngressFilter {
+	logsFn func(tx *types.Transaction) ([]*types.Log, uint64, error),
+	checkFn func(ctx context.Context, ems []interoptypes.Message, safety interoptypes.SafetyLevel, emsTimestamp uint64) error) IngressFilter {
 	return &interopFilter{
 		logsFn:  logsFn,
 		checkFn: checkFn,
@@ -33,7 +33,7 @@ func NewInteropFilter(
 // FilterTx implements IngressFilter.FilterTx
 // it gets logs checks for message safety based on the function provided
 func (f *interopFilter) FilterTx(ctx context.Context, tx *types.Transaction) bool {
-	logs, err := f.logsFn(tx)
+	logs, logTimestamp, err := f.logsFn(tx)
 	if err != nil {
 		log.Debug("Failed to retrieve logs of tx", "txHash", tx.Hash(), "err", err)
 		return false // default to deny if logs cannot be retrieved
@@ -55,5 +55,5 @@ func (f *interopFilter) FilterTx(ctx context.Context, tx *types.Transaction) boo
 	// check with the supervisor if the transaction should be allowed given the executing messages
 	// the message can be unsafe (discovered only via P2P unsafe blocks), but it must be cross-valid
 	// so CrossUnsafe is used here
-	return f.checkFn(ctx, ems, interoptypes.CrossUnsafe) == nil
+	return f.checkFn(ctx, ems, interoptypes.CrossUnsafe, logTimestamp) == nil
 }

core/txpool/ingress_filters_test.go

@@ -24,10 +24,10 @@ func TestInteropFilter(t *testing.T) {
 		Data:    []byte{},
 	})
 	t.Run("Tx has no logs", func(t *testing.T) {
-		logFn := func(tx *types.Transaction) ([]*types.Log, error) {
-			return []*types.Log{}, nil
+		logFn := func(tx *types.Transaction) ([]*types.Log, uint64, error) {
+			return []*types.Log{}, 0, nil
 		}
-		checkFn := func(ctx context.Context, ems []interoptypes.Message, safety interoptypes.SafetyLevel) error {
+		checkFn := func(ctx context.Context, ems []interoptypes.Message, safety interoptypes.SafetyLevel, emsTimestamp uint64) error {
 			// make this return error, but it won't be called because logs are empty
 			return errors.New("error")
 		}
@@ -36,10 +36,10 @@ func TestInteropFilter(t *testing.T) {
 		require.True(t, filter.FilterTx(context.Background(), tx))
 	})
 	t.Run("Tx errored when getting logs", func(t *testing.T) {
-		logFn := func(tx *types.Transaction) ([]*types.Log, error) {
-			return []*types.Log{}, errors.New("error")
+		logFn := func(tx *types.Transaction) ([]*types.Log, uint64, error) {
+			return []*types.Log{}, 0, errors.New("error")
 		}
-		checkFn := func(ctx context.Context, ems []interoptypes.Message, safety interoptypes.SafetyLevel) error {
+		checkFn := func(ctx context.Context, ems []interoptypes.Message, safety interoptypes.SafetyLevel, emsTimestamp uint64) error {
 			// make this return error, but it won't be called because logs retrieval errored
 			return errors.New("error")
 		}
@@ -48,13 +48,13 @@ func TestInteropFilter(t *testing.T) {
 		require.False(t, filter.FilterTx(context.Background(), tx))
 	})
 	t.Run("Tx has no executing messages", func(t *testing.T) {
-		logFn := func(tx *types.Transaction) ([]*types.Log, error) {
+		logFn := func(tx *types.Transaction) ([]*types.Log, uint64, error) {
 			l1 := &types.Log{
 				Topics: []common.Hash{common.BytesToHash([]byte("topic1"))},
 			}
-			return []*types.Log{l1}, nil
+			return []*types.Log{l1}, 0, nil
 		}
-		checkFn := func(ctx context.Context, ems []interoptypes.Message, safety interoptypes.SafetyLevel) error {
+		checkFn := func(ctx context.Context, ems []interoptypes.Message, safety interoptypes.SafetyLevel, emsTimestamp uint64) error {
 			// make this return error, but it won't be called because logs retrieval doesn't have executing messages
 			return errors.New("error")
 		}
@@ -78,11 +78,11 @@ func TestInteropFilter(t *testing.T) {
 		for i := 0; i < 32*5; i++ {
 			l1.Data = append(l1.Data, 0)
 		}
-		logFn := func(tx *types.Transaction) ([]*types.Log, error) {
-			return []*types.Log{l1}, nil
+		logFn := func(tx *types.Transaction) ([]*types.Log, uint64, error) {
+			return []*types.Log{l1}, 0, nil
 		}
 		var spyEMs []interoptypes.Message
-		checkFn := func(ctx context.Context, ems []interoptypes.Message, safety interoptypes.SafetyLevel) error {
+		checkFn := func(ctx context.Context, ems []interoptypes.Message, safety interoptypes.SafetyLevel, emsTimestamp uint64) error {
 			spyEMs = ems
 			return nil
 		}
@@ -109,11 +109,11 @@ func TestInteropFilter(t *testing.T) {
 		for i := 0; i < 32*5; i++ {
 			l1.Data = append(l1.Data, 0)
 		}
-		logFn := func(tx *types.Transaction) ([]*types.Log, error) {
-			return []*types.Log{l1}, nil
+		logFn := func(tx *types.Transaction) ([]*types.Log, uint64, error) {
+			return []*types.Log{l1}, 0, nil
 		}
 		var spyEMs []interoptypes.Message
-		checkFn := func(ctx context.Context, ems []interoptypes.Message, safety interoptypes.SafetyLevel) error {
+		checkFn := func(ctx context.Context, ems []interoptypes.Message, safety interoptypes.SafetyLevel, emsTimestamp uint64) error {
 			spyEMs = ems
 			return errors.New("error")
 		}
@@ -150,7 +150,7 @@ func TestInteropFilterRPCFailures(t *testing.T) {
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
 			// Create mock log function that always returns our test log
-			logFn := func(tx *types.Transaction) ([]*types.Log, error) {
+			logFn := func(tx *types.Transaction) ([]*types.Log, uint64, error) {
 				log := &types.Log{
 					Address: params.InteropCrossL2InboxAddress,
 					Topics: []common.Hash{
@@ -159,11 +159,11 @@ func TestInteropFilterRPCFailures(t *testing.T) {
 					},
 					Data: make([]byte, 32*5),
 				}
-				return []*types.Log{log}, nil
+				return []*types.Log{log}, 0, nil
 			}
 
 			// Create mock check function that simulates RPC failures
-			checkFn := func(ctx context.Context, ems []interoptypes.Message, safety interoptypes.SafetyLevel) error {
+			checkFn := func(ctx context.Context, ems []interoptypes.Message, safety interoptypes.SafetyLevel, emsTimestamp uint64) error {
 				if tt.networkErr {
 					return &net.OpError{Op: "dial", Err: errors.New("connection refused")}
 				}

core/types/interoptypes/interop.go

@@ -167,3 +167,26 @@ const (
 	Unsafe      SafetyLevel = "unsafe"
 	Invalid     SafetyLevel = "invalid"
 )
+
+type ExecutingDescriptor struct {
+	Timestamp uint64
+}
+
+type executingDescriptorMarshaling struct {
+	Timestamp hexutil.Uint64 `json:"timestamp"`
+}
+
+func (ed ExecutingDescriptor) MarshalJSON() ([]byte, error) {
+	var enc executingDescriptorMarshaling
+	enc.Timestamp = hexutil.Uint64(ed.Timestamp)
+	return json.Marshal(&enc)
+}
+
+func (ed *ExecutingDescriptor) UnmarshalJSON(input []byte) error {
+	var dec executingDescriptorMarshaling
+	if err := json.Unmarshal(input, &dec); err != nil {
+		return err
+	}
+	ed.Timestamp = uint64(dec.Timestamp)
+	return nil
+}

eth/interop.go

@@ -12,45 +12,45 @@ import (
 	"github.com/ethereum/go-ethereum/internal/ethapi"
 )
 
-func (s *Ethereum) CheckMessages(ctx context.Context, messages []interoptypes.Message, minSafety interoptypes.SafetyLevel) error {
+func (s *Ethereum) CheckMessages(ctx context.Context, messages []interoptypes.Message, minSafety interoptypes.SafetyLevel, executingTimestamp uint64) error {
 	if s.interopRPC == nil {
 		return errors.New("cannot check interop messages, no RPC available")
 	}
-	return s.interopRPC.CheckMessages(ctx, messages, minSafety)
+	return s.interopRPC.CheckMessages(ctx, messages, minSafety, interoptypes.ExecutingDescriptor{Timestamp: executingTimestamp})
 }
 
 // SimLogs simulates the logs that would be generated by a transaction if it were executed on the current state.
 // This is used by the interop filter to determine if a transaction should be allowed.
 // if errors are encountered, no logs are returned.
-func (s *Ethereum) SimLogs(tx *types.Transaction) ([]*types.Log, error) {
+func (s *Ethereum) SimLogs(tx *types.Transaction) ([]*types.Log, uint64, error) {
 	chainConfig := s.APIBackend.ChainConfig()
 	if !chainConfig.IsOptimism() {
-		return nil, errors.New("expected OP-Stack chain config, SimLogs is an OP-Stack feature")
+		return nil, 0, errors.New("expected OP-Stack chain config, SimLogs is an OP-Stack feature")
 	}
 	header := s.BlockChain().CurrentBlock()
 	if chainConfig.InteropTime == nil {
-		return nil, errors.New("expected Interop fork to be configured, SimLogs is unavailable pre-interop")
+		return nil, 0, errors.New("expected Interop fork to be configured, SimLogs is unavailable pre-interop")
 	}
 	state, err := s.BlockChain().StateAt(header.Root)
 	if err != nil {
-		return nil, fmt.Errorf("state %s (block %d) is unavailable for log simulation: %w", header.Root, header.Number.Uint64(), err)
+		return nil, 0, fmt.Errorf("state %s (block %d) is unavailable for log simulation: %w", header.Root, header.Number.Uint64(), err)
 	}
 	var vmConf vm.Config
 	signer := types.MakeSigner(chainConfig, header.Number, header.Time)
 	message, err := core.TransactionToMessage(tx, signer, header.BaseFee)
 	if err != nil {
-		return nil, fmt.Errorf("cannot convert tx to message for log simulation: %w", err)
+		return nil, 0, fmt.Errorf("cannot convert tx to message for log simulation: %w", err)
 	}
 	chainCtx := ethapi.NewChainContext(context.Background(), s.APIBackend)
 	blockCtx := core.NewEVMBlockContext(header, chainCtx, &header.Coinbase, chainConfig, state)
 	vmenv := vm.NewEVM(blockCtx, state, chainConfig, vmConf)
 	state.SetTxContext(tx.Hash(), 0)
 	result, err := core.ApplyMessage(vmenv, message, new(core.GasPool).AddGas(header.GasLimit))
 	if err != nil {
-		return nil, fmt.Errorf("failed to execute tx: %w", err)
+		return nil, 0, fmt.Errorf("failed to execute tx: %w", err)
 	}
 	if result.Failed() { // failed txs do not have log events
-		return nil, nil
+		return nil, 0, nil
 	}
-	return state.GetLogs(tx.Hash(), header.Number.Uint64(), header.Hash()), nil
+	return state.GetLogs(tx.Hash(), header.Number.Uint64(), header.Hash()), header.Time, nil
 }

eth/interop/interop.go

@@ -48,10 +48,10 @@ func NewInteropClient(rpcEndpoint string) *InteropClient {
 }
 
 // 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) error {
+func (cl *InteropClient) CheckMessages(ctx context.Context, messages []interoptypes.Message, minSafety interoptypes.SafetyLevel, executingDescriptor interoptypes.ExecutingDescriptor) error {
 	// we lazy-dial the endpoint, so we can start geth, and build blocks, without supervisor endpoint availability.
 	if err := cl.maybeDial(ctx); err != nil { // a single dial attempt is made, the next call may retry.
 		return err
 	}
-	return cl.client.CallContext(ctx, nil, "supervisor_checkMessages", messages, minSafety)
+	return cl.client.CallContext(ctx, nil, "supervisor_checkMessages", messages, minSafety, executingDescriptor)
 }

miner/miner.go

@@ -48,7 +48,7 @@ type BackendWithHistoricalState interface {
 }
 
 type BackendWithInterop interface {
-	CheckMessages(ctx context.Context, messages []interoptypes.Message, minSafety interoptypes.SafetyLevel) error
+	CheckMessages(ctx context.Context, messages []interoptypes.Message, minSafety interoptypes.SafetyLevel, executingTimestamp uint64) error
 }
 
 // Config is the configuration parameters of mining.

miner/worker.go

@@ -447,7 +447,7 @@ func (miner *Miner) applyTransaction(env *environment, tx *types.Transaction) (*
 					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)
+				return miner.checkInterop(env.rpcCtx, tx, result.Failed(), logs, env.header.Time)
 			},
 		}
 	}
@@ -459,7 +459,7 @@ func (miner *Miner) applyTransaction(env *environment, tx *types.Transaction) (*
 	return receipt, err
 }
 
-func (miner *Miner) checkInterop(ctx context.Context, tx *types.Transaction, failed bool, logs []*types.Log) error {
+func (miner *Miner) checkInterop(ctx context.Context, tx *types.Transaction, failed bool, logs []*types.Log, logTimestamp uint64) error {
 	if tx.Type() == types.DepositTxType {
 		return nil // deposit-txs are always safe
 	}
@@ -483,7 +483,7 @@ func (miner *Miner) checkInterop(ctx context.Context, tx *types.Transaction, fai
 	if len(executingMessages) == 0 {
 		return nil // avoid an RPC check if there are no executing messages to verify.
 	}
-	if err := b.CheckMessages(ctx, executingMessages, interoptypes.CrossUnsafe); err != nil {
+	if err := b.CheckMessages(ctx, executingMessages, interoptypes.CrossUnsafe, logTimestamp); 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