[Mel] - Create MEL validator

arbnode/mel/runner/mel.go

@@ -238,6 +238,10 @@ func (m *MessageExtractor) GetHeadState(ctx context.Context) (*mel.State, error)
 	return m.melDB.GetHeadMelState(ctx)
 }
 
+func (m *MessageExtractor) GetState(ctx context.Context, parentchainBlocknumber uint64) (*mel.State, error) {
+	return m.melDB.State(ctx, parentchainBlocknumber)
+}
+
 func (m *MessageExtractor) GetMsgCount(ctx context.Context) (arbutil.MessageIndex, error) {
 	headState, err := m.melDB.GetHeadMelState(ctx)
 	if err != nil {

arbnode/mel/state.go

@@ -4,10 +4,12 @@ import (
 	"context"
 
 	"github.com/ethereum/go-ethereum/common"
+	"github.com/ethereum/go-ethereum/crypto"
 	"github.com/ethereum/go-ethereum/log"
 
 	"github.com/offchainlabs/nitro/arbos/arbostypes"
 	"github.com/offchainlabs/nitro/arbos/merkleAccumulator"
+	"github.com/offchainlabs/nitro/util/arbmath"
 )
 
 // State defines the main struct describing the results of processing a single parent
@@ -77,7 +79,26 @@ type MessageConsumer interface {
 }
 
 func (s *State) Hash() common.Hash {
-	return common.Hash{}
+	var delayedMerklePartialsBytes []byte
+	for _, partial := range s.DelayedMessageMerklePartials {
+		delayedMerklePartialsBytes = append(delayedMerklePartialsBytes, partial.Bytes()...)
+	}
+	return crypto.Keccak256Hash(
+		arbmath.Uint16ToBytes(s.Version),
+		arbmath.UintToBytes(s.ParentChainId),
+		arbmath.UintToBytes(s.ParentChainBlockNumber),
+		s.BatchPostingTargetAddress.Bytes(),
+		s.DelayedMessagePostingTargetAddress.Bytes(),
+		s.ParentChainBlockHash.Bytes(),
+		s.ParentChainPreviousBlockHash.Bytes(),
+		s.MessageAccumulator.Bytes(),
+		s.DelayedMessagesSeenRoot.Bytes(),
+		arbmath.UintToBytes(s.MsgCount),
+		arbmath.UintToBytes(s.BatchCount),
+		arbmath.UintToBytes(s.DelayedMessagesRead),
+		arbmath.UintToBytes(s.DelayedMessagesSeen),
+		delayedMerklePartialsBytes,
+	)
 }
 
 // Performs a deep clone of the state struct to prevent any unintended

changelog/ganeshvanahalli-nit-4142.md

@@ -0,0 +1,2 @@
+### Added
+ - Introduces MEL validator

cmd/mel-replay/main.go

@@ -3,15 +3,5 @@
 
 package main
 
-import (
-	"github.com/ethereum/go-ethereum/common"
-
-	"github.com/offchainlabs/nitro/arbutil"
-)
-
-type preimageResolver interface {
-	ResolveTypedPreimage(preimageType arbutil.PreimageType, hash common.Hash) ([]byte, error)
-}
-
 func main() {
 }

cmd/nitro/init.go

@@ -47,7 +47,7 @@ import (
 	"github.com/offchainlabs/nitro/cmd/staterecovery"
 	"github.com/offchainlabs/nitro/execution/gethexec"
 	"github.com/offchainlabs/nitro/solgen/go/rollupgen"
-	"github.com/offchainlabs/nitro/staker/bold"
+	"github.com/offchainlabs/nitro/staker"
 	"github.com/offchainlabs/nitro/statetransfer"
 	"github.com/offchainlabs/nitro/util"
 	"github.com/offchainlabs/nitro/util/arbmath"
@@ -957,7 +957,7 @@ func validateGenesisAssertion(ctx context.Context, rollupAddress common.Address,
 	if err != nil {
 		return err
 	}
-	genesisAssertionCreationInfo, err := bold.ReadBoldAssertionCreationInfo(ctx, userLogic, l1Client, rollupAddress, genesisAssertionHash)
+	genesisAssertionCreationInfo, err := staker.ReadBoldAssertionCreationInfo(ctx, userLogic, l1Client, rollupAddress, genesisAssertionHash)
 	if err != nil {
 		// If we can't find the empty genesis assertion, try to compute the assertion for non-empty genesis
 		genesisGlobalState := protocol.GoGlobalState{
@@ -978,7 +978,7 @@ func validateGenesisAssertion(ctx context.Context, rollupAddress common.Address,
 		if err != nil {
 			return err
 		}
-		genesisAssertionCreationInfo, err = bold.ReadBoldAssertionCreationInfo(ctx, userLogic, l1Client, rollupAddress, genesisAssertionHash)
+		genesisAssertionCreationInfo, err = staker.ReadBoldAssertionCreationInfo(ctx, userLogic, l1Client, rollupAddress, genesisAssertionHash)
 		if err != nil {
 			return err
 		}

cmd/pruning/pruning.go

@@ -32,7 +32,6 @@ import (
 	"github.com/offchainlabs/nitro/solgen/go/bridgegen"
 	"github.com/offchainlabs/nitro/solgen/go/rollupgen"
 	"github.com/offchainlabs/nitro/staker"
-	"github.com/offchainlabs/nitro/staker/bold"
 	legacystaker "github.com/offchainlabs/nitro/staker/legacy"
 	multiprotocolstaker "github.com/offchainlabs/nitro/staker/multi_protocol"
 )
@@ -258,7 +257,7 @@ func getLatestConfirmedHash(ctx context.Context, rollupAddrs chaininfo.RollupAdd
 		if err != nil {
 			return common.Hash{}, err
 		}
-		assertion, err := bold.ReadBoldAssertionCreationInfo(
+		assertion, err := staker.ReadBoldAssertionCreationInfo(
 			ctx,
 			rollupUserLogic,
 			l1Client,

cmd/mel-replay/db.go → mel-replay/db.go

@@ -1,4 +1,4 @@
-package main
+package melreplay
 
 import (
 	"errors"
@@ -14,7 +14,7 @@ import (
 var _ ethdb.Database = (*DB)(nil)
 
 type DB struct {
-	resolver preimageResolver
+	resolver PreimageResolver
 }
 
 func (d *DB) Get(key []byte) ([]byte, error) {

cmd/mel-replay/delayed_message_db.go → mel-replay/delayed_message_db.go

@@ -1,4 +1,4 @@
-package main
+package melreplay
 
 import (
 	"bytes"
@@ -14,7 +14,11 @@ import (
 )
 
 type delayedMessageDatabase struct {
-	preimageResolver preimageResolver
+	preimageResolver PreimageResolver
+}
+
+func NewDelayedMessageDatabase(preimageResolver PreimageResolver) mel.DelayedMessageDatabase {
+	return &delayedMessageDatabase{preimageResolver}
 }
 
 func (d *delayedMessageDatabase) ReadDelayedMessage(
@@ -27,7 +31,7 @@ func (d *delayedMessageDatabase) ReadDelayedMessage(
 	if msgIndex >= totalMsgsSeen {
 		return nil, fmt.Errorf("index %d out of range, total delayed messages seen: %d", msgIndex, totalMsgsSeen)
 	}
-	treeSize := nextPowerOfTwo(totalMsgsSeen)
+	treeSize := NextPowerOfTwo(totalMsgsSeen)
 	merkleDepth := bits.TrailingZeros64(treeSize)
 
 	// Start traversal from root, which is the delayed messages seen root.
@@ -74,7 +78,7 @@ func (d *delayedMessageDatabase) ReadDelayedMessage(
 	return delayedMessage, nil
 }
 
-func nextPowerOfTwo(n uint64) uint64 {
+func NextPowerOfTwo(n uint64) uint64 {
 	if n == 0 {
 		return 1
 	}

cmd/mel-replay/delayed_message_db_test.go → mel-replay/delayed_message_db_test.go

@@ -1,4 +1,4 @@
-package main
+package melreplay_test
 
 import (
 	"context"
@@ -18,24 +18,10 @@ import (
 	"github.com/offchainlabs/nitro/arbos/arbostypes"
 	"github.com/offchainlabs/nitro/arbutil"
 	"github.com/offchainlabs/nitro/daprovider"
+	"github.com/offchainlabs/nitro/mel-replay"
 )
 
-var _ preimageResolver = (*mockPreimageResolver)(nil)
-var _ mel.DelayedMessageDatabase = (*delayedMessageDatabase)(nil)
-
-type testPreimageResolver struct {
-	preimages map[common.Hash][]byte
-}
-
-func (r *testPreimageResolver) ResolveTypedPreimage(preimageType arbutil.PreimageType, hash common.Hash) ([]byte, error) {
-	if preimageType != arbutil.Keccak256PreimageType {
-		return nil, fmt.Errorf("unsupported preimageType: %d", preimageType)
-	}
-	if preimage, ok := r.preimages[hash]; ok {
-		return preimage, nil
-	}
-	return nil, fmt.Errorf("preimage not found for hash: %v", hash)
-}
+var _ melreplay.PreimageResolver = (*mockPreimageResolver)(nil)
 
 func TestRecordingPreimagesForReadDelayedMessage(t *testing.T) {
 	ctx := context.Background()
@@ -89,11 +75,12 @@ func TestRecordingPreimagesForReadDelayedMessage(t *testing.T) {
 	}
 
 	// Test reading in wasm mode
-	delayedDB := &delayedMessageDatabase{
-		&testPreimageResolver{
-			preimages: preimages[arbutil.Keccak256PreimageType],
-		},
-	}
+	delayedDB := melreplay.NewDelayedMessageDatabase(
+		melreplay.NewTypeBasedPreimageResolver(
+			arbutil.Keccak256PreimageType,
+			preimages,
+		),
+	)
 	for i := startBlockNum; i < numMsgsToRead; i++ {
 		msg, err := delayedDB.ReadDelayedMessage(ctx, state, i)
 		require.NoError(t, err)
@@ -104,7 +91,7 @@ func TestRecordingPreimagesForReadDelayedMessage(t *testing.T) {
 func TestReadDelayedMessage(t *testing.T) {
 	ctx := context.Background()
 	t.Run("message index out of range", func(t *testing.T) {
-		db := &delayedMessageDatabase{}
+		db := melreplay.NewDelayedMessageDatabase(nil)
 		state := &mel.State{
 			DelayedMessagesSeen: 5,
 		}
@@ -122,7 +109,7 @@ func TestReadDelayedMessage(t *testing.T) {
 		preimages, root := buildMerkleTree(t, messages)
 
 		resolver := &mockPreimageResolver{preimages: preimages}
-		db := &delayedMessageDatabase{preimageResolver: resolver}
+		db := melreplay.NewDelayedMessageDatabase(resolver)
 		state := &mel.State{
 			DelayedMessagesSeen:     1,
 			DelayedMessagesSeenRoot: root,
@@ -151,7 +138,7 @@ func TestReadDelayedMessage(t *testing.T) {
 		preimages, root := buildMerkleTree(t, messages)
 
 		resolver := &mockPreimageResolver{preimages: preimages}
-		db := &delayedMessageDatabase{preimageResolver: resolver}
+		db := melreplay.NewDelayedMessageDatabase(resolver)
 		state := &mel.State{
 			DelayedMessagesSeen:     2,
 			DelayedMessagesSeenRoot: root,
@@ -184,7 +171,7 @@ func TestReadDelayedMessage(t *testing.T) {
 		preimages, root := buildMerkleTree(t, messages)
 
 		resolver := &mockPreimageResolver{preimages: preimages}
-		db := &delayedMessageDatabase{preimageResolver: resolver}
+		db := melreplay.NewDelayedMessageDatabase(resolver)
 		state := &mel.State{
 			DelayedMessagesSeen:     3,
 			DelayedMessagesSeenRoot: root,
@@ -218,7 +205,7 @@ func TestNextPowerOfTwo(t *testing.T) {
 	}
 
 	for _, tc := range testCases {
-		result := nextPowerOfTwo(tc.input)
+		result := melreplay.NextPowerOfTwo(tc.input)
 		if result != tc.expected {
 			t.Errorf("nextPowerOfTwo(%d) = %d, expected %d", tc.input, result, tc.expected)
 		}

mel-replay/mel-replay.go

@@ -4,8 +4,13 @@
 package melreplay
 
 import (
+	"fmt"
+
 	"github.com/ethereum/go-ethereum/common"
 	"github.com/ethereum/go-ethereum/crypto"
+
+	"github.com/offchainlabs/nitro/arbutil"
+	"github.com/offchainlabs/nitro/daprovider"
 )
 
 // RELEVANT_TX_INDEXES_PREFIX represents the prefix appended to a blockHash and the hash of the resulting string
@@ -15,3 +20,28 @@ const RELEVANT_TX_INDEXES_PREFIX string = "TX_INDEX_DATA"
 func RelevantTxIndexesKey(parentChainBlockHash common.Hash) common.Hash {
 	return crypto.Keccak256Hash([]byte(RELEVANT_TX_INDEXES_PREFIX), parentChainBlockHash.Bytes())
 }
+
+type PreimageResolver interface {
+	ResolveTypedPreimage(preimageType arbutil.PreimageType, hash common.Hash) ([]byte, error)
+}
+
+type typeBasedPreimageResolver struct {
+	ty           arbutil.PreimageType
+	preimagesMap daprovider.PreimagesMap
+}
+
+func NewTypeBasedPreimageResolver(ty arbutil.PreimageType, preimagesMap daprovider.PreimagesMap) PreimageResolver {
+	return &typeBasedPreimageResolver{ty, preimagesMap}
+}
+
+func (t *typeBasedPreimageResolver) ResolveTypedPreimage(preimageType arbutil.PreimageType, hash common.Hash) ([]byte, error) {
+	if preimageType != t.ty {
+		return nil, fmt.Errorf("unsupported preimageType: %d, want: %d", preimageType, t.ty)
+	}
+	if targetMap, ok := t.preimagesMap[preimageType]; ok {
+		if preimage, ok := targetMap[hash]; ok {
+			return preimage, nil
+		}
+	}
+	return nil, fmt.Errorf("preimage not found for hash: %v", hash)
+}

cmd/mel-replay/receipt_fetcher.go → mel-replay/receipt_fetcher.go

@@ -1,7 +1,7 @@
 // Copyright 2025-2026, Offchain Labs, Inc.
 // For license information, see https://github.com/OffchainLabs/nitro/blob/master/LICENSE.md
 
-package main
+package melreplay
 
 import (
 	"context"
@@ -15,13 +15,17 @@ import (
 	"github.com/ethereum/go-ethereum/trie"
 	"github.com/ethereum/go-ethereum/triedb"
 
+	"github.com/offchainlabs/nitro/arbnode/mel/extraction"
 	"github.com/offchainlabs/nitro/arbutil"
-	"github.com/offchainlabs/nitro/mel-replay"
 )
 
 type receiptFetcherForBlock struct {
 	header           *types.Header
-	preimageResolver preimageResolver
+	preimageResolver PreimageResolver
+}
+
+func NewLogsFetcher(header *types.Header, preimageResolver PreimageResolver) melextraction.LogsFetcher {
+	return &receiptFetcherForBlock{header, preimageResolver}
 }
 
 // LogsForTxIndex fetches logs for a specific transaction index by walking
@@ -50,7 +54,7 @@ func (rf *receiptFetcherForBlock) LogsForBlockHash(ctx context.Context, parentCh
 	if rf.header.Hash() != parentChainBlockHash {
 		return nil, errors.New("parentChainBlockHash mismatch")
 	}
-	relevantTxIndicesKey := melreplay.RelevantTxIndexesKey(rf.header.Hash())
+	relevantTxIndicesKey := RelevantTxIndexesKey(rf.header.Hash())
 	txIndexData, err := rf.preimageResolver.ResolveTypedPreimage(arbutil.Keccak256PreimageType, relevantTxIndicesKey)
 	if err != nil {
 		return nil, err

cmd/mel-replay/receipt_recorder_and_receipt_fetcher_test.go → mel-replay/receipt_recorder_and_receipt_fetcher_test.go

@@ -1,7 +1,7 @@
 // Copyright 2025-2026, Offchain Labs, Inc.
 // For license information, see https://github.com/OffchainLabs/nitro/blob/master/LICENSE.md
 
-package main
+package melreplay_test
 
 import (
 	"context"
@@ -19,6 +19,7 @@ import (
 	"github.com/offchainlabs/nitro/arbnode/mel/recording"
 	"github.com/offchainlabs/nitro/arbutil"
 	"github.com/offchainlabs/nitro/daprovider"
+	"github.com/offchainlabs/nitro/mel-replay"
 )
 
 type mockPreimageResolver struct {
@@ -104,12 +105,13 @@ func TestRecordingOfReceiptPreimagesAndFetchingLogsFromPreimages(t *testing.T) {
 	// Test reading of logs from the recorded preimages
 	require.NoError(t, recorder.CollectTxIndicesPreimage())
 	require.NoError(t, err)
-	receiptFetcher := &receiptFetcherForBlock{
-		header: block.Header(),
-		preimageResolver: &testPreimageResolver{
-			preimages: preimages[arbutil.Keccak256PreimageType],
-		},
-	}
+	receiptFetcher := melreplay.NewLogsFetcher(
+		block.Header(),
+		melreplay.NewTypeBasedPreimageResolver(
+			arbutil.Keccak256PreimageType,
+			preimages,
+		),
+	)
 	// Test LogsForBlockHash
 	logs, err := receiptFetcher.LogsForBlockHash(ctx, block.Hash())
 	require.NoError(t, err)

cmd/mel-replay/trie_fetcher.go → mel-replay/trie_fetcher.go

@@ -1,4 +1,4 @@
-package main
+package melreplay
 
 import (
 	"bytes"
@@ -14,7 +14,7 @@ import (
 // Fetches a specific object at index from a block's Receipt/Tx trie by navigating its
 // Merkle Patricia Trie structure. It uses the preimage resolver to fetch preimages
 // of trie nodes as needed, and determines how to navigate depending on the structure of the trie nodes.
-func fetchObjectFromTrie[T any](root common.Hash, index uint, preimageResolver preimageResolver) (*T, error) {
+func fetchObjectFromTrie[T any](root common.Hash, index uint, preimageResolver PreimageResolver) (*T, error) {
 	var empty *T
 	currentNodeHash := root
 	currentPath := []byte{} // Track nibbles consumed so far.