merge upstream

Author: ganeshvanahalli

arbnode/mel/extraction/message_extraction_function.go

@@ -151,16 +151,6 @@ func extractMessagesImpl(
 		if delayed.Message.Header.Kind == arbostypes.L1MessageType_BatchPostingReport || delayed.Message.Header.Kind == arbostypes.L1MessageType_Initialize { // Let's consider the init message as a batch posting report, since it is seen as a batch as well, we can later ignore filling its batchGasCost anyway
 			batchPostingReports = append(batchPostingReports, delayed)
 		}
-		if err = state.AccumulateDelayedMessage(delayed); err != nil {
-			return nil, nil, nil, nil, err
-		}
-		state.DelayedMessagesSeen += 1
-	}
-	if len(delayedMessages) > 0 {
-		// Only need to calculate partials once, after all the delayed messages are `seen`
-		if err := state.GenerateDelayedMessagesSeenMerklePartialsAndRoot(); err != nil {
-			return nil, nil, nil, nil, err
-		}
 	}
 
 	// Batch posting reports are included in the same transaction as a batch, so there should
@@ -175,6 +165,7 @@ func extractMessagesImpl(
 
 	var batchMetas []*mel.BatchMetadata
 	var messages []*arbostypes.MessageWithMetadata
+	var serializedBatches [][]byte
 	for i, batch := range batches {
 		batchTx := batchTxs[i]
 		serialized, err := serialize(
@@ -209,7 +200,26 @@ func extractMessagesImpl(
 		} else if !(inputState.DelayedMessagesSeen == 0 && i == 0 && delayedMessages[i] == batchPostReport) {
 			return nil, nil, nil, nil, errors.New("encountered initialize message that is not the first delayed message and the first batch ")
 		}
+		serializedBatches = append(serializedBatches, serialized)
+	}
+
+	// Update the delayed message accumulator in the MEL state.
+	for _, delayed := range delayedMessages {
+		if err = state.AccumulateDelayedMessage(delayed); err != nil {
+			return nil, nil, nil, nil, err
+		}
+		state.DelayedMessagesSeen += 1
+	}
+	if len(delayedMessages) > 0 {
+		// Only need to calculate partials once, after all the delayed messages are `seen`
+		if err := state.GenerateDelayedMessagesSeenMerklePartialsAndRoot(); err != nil {
+			return nil, nil, nil, nil, err
+		}
+	}
 
+	// Extract L2 messages from batches
+	for i, batch := range batches {
+		serialized := serializedBatches[i]
 		rawSequencerMsg, err := parseSequencerMessage(
 			ctx,
 			batch.SequenceNumber,

arbnode/mel/messages.go

@@ -59,24 +59,13 @@ func (m *DelayedInboxMessage) AfterInboxAcc() common.Hash {
 }
 
 func (m *DelayedInboxMessage) Hash() common.Hash {
-	encoded, err := rlp.EncodeToBytes(m.WithMELRelevantFields())
+	encoded, err := rlp.EncodeToBytes(m)
 	if err != nil {
 		panic(err)
 	}
 	return crypto.Keccak256Hash(encoded)
 }
 
-func (m *DelayedInboxMessage) WithMELRelevantFields() *DelayedInboxMessage {
-	return &DelayedInboxMessage{
-		BlockHash: m.BlockHash,
-		Message: &arbostypes.L1IncomingMessage{
-			Header: m.Message.Header,
-			L2msg:  m.Message.L2msg,
-		},
-		ParentChainBlockNumber: m.ParentChainBlockNumber,
-	}
-}
-
 type BatchMetadata struct {
 	Accumulator         common.Hash
 	MessageCount        arbutil.MessageIndex

arbnode/mel/recording/delayed_msg_database.go

@@ -63,7 +63,7 @@ func (r *DelayedMsgDatabase) ReadDelayedMessage(ctx context.Context, state *mel.
 	if err != nil {
 		return nil, err
 	}
-	delayedMsgBytes, err := rlp.EncodeToBytes(delayed.WithMELRelevantFields())
+	delayedMsgBytes, err := rlp.EncodeToBytes(delayed)
 	if err != nil {
 		return nil, err
 	}

arbnode/mel/state.go

@@ -168,7 +168,7 @@ func (s *State) AccumulateMessage(msg *arbostypes.MessageWithMetadata) error {
 			}
 		}
 	}
-	msgBytes, err := rlp.EncodeToBytes(msg.WithMELRelevantFields())
+	msgBytes, err := rlp.EncodeToBytes(msg)
 	if err != nil {
 		return err
 	}

arbos/arbostypes/messagewithmeta.go

@@ -16,23 +16,13 @@ type MessageWithMetadata struct {
 }
 
 func (m *MessageWithMetadata) Hash() common.Hash {
-	encoded, err := rlp.EncodeToBytes(m.WithMELRelevantFields())
+	encoded, err := rlp.EncodeToBytes(m)
 	if err != nil {
 		panic(err)
 	}
 	return crypto.Keccak256Hash(encoded)
 }
 
-func (m *MessageWithMetadata) WithMELRelevantFields() *MessageWithMetadata {
-	return &MessageWithMetadata{
-		Message: &L1IncomingMessage{
-			Header: m.Message.Header,
-			L2msg:  m.Message.L2msg,
-		},
-		DelayedMessagesRead: m.DelayedMessagesRead,
-	}
-}
-
 // lint:require-exhaustive-initialization
 type MessageWithMetadataAndBlockInfo struct {
 	MessageWithMeta MessageWithMetadata

staker/block_validation_entry_creator.go

@@ -2,7 +2,6 @@ package staker
 
 import (
 	"context"
-	"fmt"
 
 	"github.com/ethereum/go-ethereum/common"
 	"github.com/ethereum/go-ethereum/log"
@@ -18,19 +17,16 @@ import (
 type MELEnabledValidationEntryCreator struct {
 	melValidator MELValidatorInterface
 	txStreamer   TransactionStreamerInterface
-	melRunner    MELRunnerInterface
 }
 
 // NewMELEnabledValidationEntryCreator creates a new instance of MELEnabledValidationEntryCreator.
 func NewMELEnabledValidationEntryCreator(
 	melValidator MELValidatorInterface,
 	txStreamer TransactionStreamerInterface,
-	melRunner MELRunnerInterface,
 ) *MELEnabledValidationEntryCreator {
 	return &MELEnabledValidationEntryCreator{
 		melValidator: melValidator,
 		txStreamer:   txStreamer,
-		melRunner:    melRunner,
 	}
 }
 
@@ -61,13 +57,6 @@ func (m *MELEnabledValidationEntryCreator) CreateBlockValidationEntry(
 	if err != nil {
 		return nil, created, err
 	}
-	melStateForMsg, err := m.melRunner.GetState(ctx, msg.Message.Header.BlockNumber)
-	if err != nil {
-		return nil, created, err
-	}
-	if melStateForMsg.MsgCount == 0 {
-		return nil, created, fmt.Errorf("MEL state for msg at position %d has 0 msg count", position)
-	}
 	prevResult, err := m.txStreamer.ResultAtMessageIndex(arbutil.MessageIndex(position) - 1)
 	if err != nil {
 		return nil, created, err
@@ -80,38 +69,48 @@ func (m *MELEnabledValidationEntryCreator) CreateBlockValidationEntry(
 	preimages := make(daprovider.PreimagesMap)
 	preimages[arbutil.Keccak256PreimageType] = make(map[common.Hash][]byte)
 
-	// Add MEL state to the preimages map.
-	encodedInitialState, err := rlp.EncodeToBytes(latestValidatedMELState)
+	// Fetch and add the msg releated preimages.
+	msgPreimagesAndRelevantState, err := m.melValidator.FetchMsgPreimagesAndRelevantState(ctx, position)
 	if err != nil {
 		return nil, created, err
 	}
-	preimages[arbutil.Keccak256PreimageType][latestValidatedMELState.Hash()] = encodedInitialState
+	validator.CopyPreimagesInto(preimages, msgPreimagesAndRelevantState.msgPreimages)
 
-	// Fetch and add the msg releated preimages.
-	msgPreimages, err := m.melValidator.FetchMsgPreimages(ctx, uint64(position), melStateForMsg.ParentChainBlockNumber)
+	// Add relevant MEL state to the preimages map.
+	relevantMELState := msgPreimagesAndRelevantState.relevantState
+	encodedInitialState, err := rlp.EncodeToBytes(relevantMELState)
 	if err != nil {
 		return nil, created, err
 	}
-	validator.CopyPreimagesInto(preimages, msgPreimages)
+	preimages[arbutil.Keccak256PreimageType][relevantMELState.Hash()] = encodedInitialState
+
 	startGs := validator.GoGlobalState{
 		BlockHash:    prevResult.BlockHash,
 		SendRoot:     prevResult.SendRoot,
-		MELStateHash: latestValidatedMELState.Hash(),
+		MELStateHash: relevantMELState.Hash(),
 		MELMsgHash:   msg.Hash(),
 		PosInBatch:   uint64(position),
 	}
+	endGsMELMsgHash := common.Hash{}
+	if relevantMELState.MsgCount > uint64(position)+1 {
+		nextMsg, err := m.txStreamer.GetMessage(position + 1)
+		if err != nil {
+			return nil, created, err
+		}
+		endGsMELMsgHash = nextMsg.Hash()
+	}
 	endGlobalState := validator.GoGlobalState{
 		BlockHash:    executionResult.BlockHash,
 		SendRoot:     executionResult.SendRoot,
-		MELStateHash: latestValidatedMELState.Hash(),
-		MELMsgHash:   msg.Hash(),
+		MELStateHash: relevantMELState.Hash(),
+		MELMsgHash:   endGsMELMsgHash,
 		PosInBatch:   uint64(position) + 1,
 	}
 	chainConfig := m.txStreamer.ChainConfig()
 	created = true
 	return &validationEntry{
 		Stage:       ReadyForRecord,
-		Pos:         arbutil.MessageIndex(position),
+		Pos:         position,
 		Start:       startGs,
 		End:         endGlobalState,
 		msg:         msg,

staker/block_validator.go

@@ -383,7 +383,6 @@ func NewBlockValidator(
 		validationEntryCreator := NewMELEnabledValidationEntryCreator(
 			melValidator,
 			streamer,
-			melRunner,
 		)
 		ret.melEnabledEntryCreator = validationEntryCreator
 	}
@@ -1124,12 +1123,7 @@ func (v *BlockValidator) iterativeValidationProgress(ctx context.Context, ignore
 		}
 	}
 	if v.config().EnableMEL {
-		msg, err := v.streamer.GetMessage(v.validated())
-		if err != nil {
-			log.Error("Couldn't clear msg preimages cache in MEL validator", "err", err)
-		} else {
-			v.melValidator.ClearValidatedMsgPreimages(msg.Message.Header.BlockNumber)
-		}
+		v.melValidator.ClearValidatedMsgPreimages(v.validated())
 	}
 	return v.config().ValidationPoll
 }