[Mel] - Create MEL validator

arbnode/mel/runner/mel.go

@@ -240,6 +240,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 {

changelog/ganeshvanahalli-nit-4142.md

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

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

@@ -34,7 +34,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"
 )
@@ -260,7 +259,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,

staker/block_validator.go

@@ -88,6 +88,7 @@ func NewThrottledValidationSpawner(spawner validator.ValidationSpawner) *Throttl
 type BlockValidator struct {
 	stopwaiter.StopWaiter
 	*StatelessBlockValidator
+	melValidator MELValidatorInterface
 
 	reorgMutex sync.RWMutex
 
@@ -636,14 +637,24 @@ func (v *BlockValidator) createNextValidationEntry(ctx context.Context) (bool, e
 		log.Trace("create validation entry: nothing to do", "pos", pos, "validated", v.validated())
 		return false, nil
 	}
-	streamerMsgCount, err := v.streamer.GetProcessedMessageCount()
+	streamerMsgCount, err := v.streamer.GetProcessedMessageCount() // Ask MEL validator LatestValidatedMELState().MsgCount
 	if err != nil {
 		return false, err
 	}
 	if pos >= streamerMsgCount {
 		log.Trace("create validation entry: nothing to do", "pos", pos, "streamerMsgCount", streamerMsgCount)
 		return false, nil
 	}
+	if v.melValidator != nil {
+		latestValidatedState, err := v.melValidator.LatestValidatedMELState(ctx)
+		if err != nil {
+			return false, err
+		}
+		if pos >= arbutil.MessageIndex(latestValidatedState.MsgCount) {
+			log.Trace("create validation entry: nothing to do", "pos", pos, "latestMELValidatedMsgCount", latestValidatedState.MsgCount)
+			return false, nil
+		}
+	}
 	msg, err := v.streamer.GetMessage(pos)
 	if err != nil {
 		return false, err

staker/bold/bold_staker.go

@@ -6,13 +6,11 @@ import (
 	"context"
 	"errors"
 	"fmt"
-	"math/big"
 	"strings"
 	"time"
 
 	"github.com/spf13/pflag"
 
-	"github.com/ethereum/go-ethereum"
 	"github.com/ethereum/go-ethereum/accounts/abi/bind"
 	"github.com/ethereum/go-ethereum/common"
 	"github.com/ethereum/go-ethereum/log"
@@ -45,20 +43,6 @@ var (
 	boldStakerAmountStakedGauge = metrics.GetOrRegisterGauge("arb/staker/amount_staked", nil)
 )
 
-var assertionCreatedId common.Hash
-
-func init() {
-	rollupAbi, err := rollupgen.RollupCoreMetaData.GetAbi()
-	if err != nil {
-		panic(err)
-	}
-	assertionCreatedEvent, ok := rollupAbi.Events["AssertionCreated"]
-	if !ok {
-		panic("RollupCore ABI missing AssertionCreated event")
-	}
-	assertionCreatedId = assertionCreatedEvent.ID
-}
-
 type BoldConfig struct {
 	// How often to post assertions onchain.
 	AssertionPostingInterval time.Duration `koanf:"assertion-posting-interval"`
@@ -290,7 +274,7 @@ func (b *BOLDStaker) Initialize(ctx context.Context) error {
 			}
 			latestStaked = latestConfirmed
 		}
-		assertion, err := ReadBoldAssertionCreationInfo(
+		assertion, err := staker.ReadBoldAssertionCreationInfo(
 			ctx,
 			rollupUserLogic,
 			b.client,
@@ -629,79 +613,3 @@ func newBOLDChallengeManager(
 	}
 	return manager, nil
 }
-
-// Read the creation info for an assertion by looking up its creation
-// event from the rollup contracts.
-func ReadBoldAssertionCreationInfo(
-	ctx context.Context,
-	rollup *rollupgen.RollupUserLogic,
-	client bind.ContractBackend,
-	rollupAddress common.Address,
-	assertionHash common.Hash,
-) (*protocol.AssertionCreatedInfo, error) {
-	var creationBlock uint64
-	var topics [][]common.Hash
-	if assertionHash == (common.Hash{}) {
-		rollupDeploymentBlock, err := rollup.RollupDeploymentBlock(&bind.CallOpts{Context: ctx})
-		if err != nil {
-			return nil, err
-		}
-		if !rollupDeploymentBlock.IsUint64() {
-			return nil, errors.New("rollup deployment block was not a uint64")
-		}
-		creationBlock = rollupDeploymentBlock.Uint64()
-	} else {
-		var b [32]byte
-		copy(b[:], assertionHash[:])
-		assertionCreationBlock, err := rollup.GetAssertionCreationBlockForLogLookup(&bind.CallOpts{Context: ctx}, b)
-		if err != nil {
-			return nil, err
-		}
-		if !assertionCreationBlock.IsUint64() {
-			return nil, errors.New("assertion creation block was not a uint64")
-		}
-		creationBlock = assertionCreationBlock.Uint64()
-	}
-	topics = [][]common.Hash{{assertionCreatedId}, {assertionHash}}
-	var query = ethereum.FilterQuery{
-		FromBlock: new(big.Int).SetUint64(creationBlock),
-		ToBlock:   new(big.Int).SetUint64(creationBlock),
-		Addresses: []common.Address{rollupAddress},
-		Topics:    topics,
-	}
-	logs, err := client.FilterLogs(ctx, query)
-	if err != nil {
-		return nil, err
-	}
-	if len(logs) == 0 {
-		return nil, errors.New("no assertion creation logs found")
-	}
-	if len(logs) > 1 {
-		return nil, errors.New("found multiple instances of requested node")
-	}
-	ethLog := logs[0]
-	parsedLog, err := rollup.ParseAssertionCreated(ethLog)
-	if err != nil {
-		return nil, err
-	}
-	afterState := parsedLog.Assertion.AfterState
-	creationL1Block, err := arbutil.CorrespondingL1BlockNumber(ctx, client, ethLog.BlockNumber)
-	if err != nil {
-		return nil, err
-	}
-	return &protocol.AssertionCreatedInfo{
-		ConfirmPeriodBlocks: parsedLog.ConfirmPeriodBlocks,
-		RequiredStake:       parsedLog.RequiredStake,
-		ParentAssertionHash: protocol.AssertionHash{Hash: parsedLog.ParentAssertionHash},
-		BeforeState:         parsedLog.Assertion.BeforeState,
-		AfterState:          afterState,
-		InboxMaxCount:       parsedLog.InboxMaxCount,
-		AfterInboxBatchAcc:  parsedLog.AfterInboxBatchAcc,
-		AssertionHash:       protocol.AssertionHash{Hash: parsedLog.AssertionHash},
-		WasmModuleRoot:      parsedLog.WasmModuleRoot,
-		ChallengeManager:    parsedLog.ChallengeManager,
-		TransactionHash:     ethLog.TxHash,
-		CreationParentBlock: ethLog.BlockNumber,
-		CreationL1Block:     creationL1Block,
-	}, nil
-}

staker/bold_assertioncreation.go

@@ -0,0 +1,105 @@
+package staker
+
+import (
+	"context"
+	"errors"
+	"math/big"
+
+	"github.com/ethereum/go-ethereum"
+	"github.com/ethereum/go-ethereum/accounts/abi/bind/v2"
+	"github.com/ethereum/go-ethereum/common"
+
+	"github.com/offchainlabs/nitro/arbutil"
+	"github.com/offchainlabs/nitro/bold/protocol"
+	"github.com/offchainlabs/nitro/solgen/go/rollupgen"
+)
+
+var assertionCreatedId common.Hash
+
+func init() {
+	rollupAbi, err := rollupgen.RollupCoreMetaData.GetAbi()
+	if err != nil {
+		panic(err)
+	}
+	assertionCreatedEvent, ok := rollupAbi.Events["AssertionCreated"]
+	if !ok {
+		panic("RollupCore ABI missing AssertionCreated event")
+	}
+	assertionCreatedId = assertionCreatedEvent.ID
+}
+
+// Read the creation info for an assertion by looking up its creation
+// event from the rollup contracts.
+func ReadBoldAssertionCreationInfo(
+	ctx context.Context,
+	rollup *rollupgen.RollupUserLogic,
+	client bind.ContractBackend,
+	rollupAddress common.Address,
+	assertionHash common.Hash,
+) (*protocol.AssertionCreatedInfo, error) {
+	var creationBlock uint64
+	var topics [][]common.Hash
+	if assertionHash == (common.Hash{}) {
+		rollupDeploymentBlock, err := rollup.RollupDeploymentBlock(&bind.CallOpts{Context: ctx})
+		if err != nil {
+			return nil, err
+		}
+		if !rollupDeploymentBlock.IsUint64() {
+			return nil, errors.New("rollup deployment block was not a uint64")
+		}
+		creationBlock = rollupDeploymentBlock.Uint64()
+	} else {
+		var b [32]byte
+		copy(b[:], assertionHash[:])
+		assertionCreationBlock, err := rollup.GetAssertionCreationBlockForLogLookup(&bind.CallOpts{Context: ctx}, b)
+		if err != nil {
+			return nil, err
+		}
+		if !assertionCreationBlock.IsUint64() {
+			return nil, errors.New("assertion creation block was not a uint64")
+		}
+		creationBlock = assertionCreationBlock.Uint64()
+	}
+	topics = [][]common.Hash{{assertionCreatedId}, {assertionHash}}
+	var query = ethereum.FilterQuery{
+		FromBlock: new(big.Int).SetUint64(creationBlock),
+		ToBlock:   new(big.Int).SetUint64(creationBlock),
+		Addresses: []common.Address{rollupAddress},
+		Topics:    topics,
+	}
+	logs, err := client.FilterLogs(ctx, query)
+	if err != nil {
+		return nil, err
+	}
+	if len(logs) == 0 {
+		return nil, errors.New("no assertion creation logs found")
+	}
+	if len(logs) > 1 {
+		return nil, errors.New("found multiple instances of requested node")
+	}
+	ethLog := logs[0]
+	parsedLog, err := rollup.ParseAssertionCreated(ethLog)
+	if err != nil {
+		return nil, err
+	}
+	afterState := parsedLog.Assertion.AfterState
+	creationL1Block, err := arbutil.CorrespondingL1BlockNumber(ctx, client, ethLog.BlockNumber)
+	if err != nil {
+		return nil, err
+	}
+	return &protocol.AssertionCreatedInfo{
+		ConfirmPeriodBlocks: parsedLog.ConfirmPeriodBlocks,
+		RequiredStake:       parsedLog.RequiredStake,
+		ParentAssertionHash: protocol.AssertionHash{Hash: parsedLog.ParentAssertionHash},
+		BeforeState:         parsedLog.Assertion.BeforeState,
+		AfterState:          afterState,
+		InboxMaxCount:       parsedLog.InboxMaxCount,
+		AfterInboxBatchAcc:  parsedLog.AfterInboxBatchAcc,
+		AssertionHash:       protocol.AssertionHash{Hash: parsedLog.AssertionHash},
+		WasmModuleRoot:      parsedLog.WasmModuleRoot,
+		ChallengeManager:    parsedLog.ChallengeManager,
+		TransactionHash:     ethLog.TxHash,
+		CreationParentBlock: ethLog.BlockNumber,
+		CreationL1Block:     creationL1Block,
+	}, nil
+}