Support remote validator

arbnode/api.go

@@ -19,7 +19,7 @@ type BlockValidatorAPI struct {
 }
 
 func (a *BlockValidatorAPI) LatestValidated(ctx context.Context) (*staker.GlobalStateValidatedInfo, error) {
-	return a.val.ReadLastValidatedInfo()
+	return a.val.ReadLastValidatedInfo(ctx)
 }
 
 type BlockValidatorDebugAPI struct {

arbnode/node.go

@@ -620,11 +620,13 @@ func createNodeImpl(
 	var blockValidator *staker.BlockValidator
 	if config.ValidatorRequired() {
 		blockValidator, err = staker.NewBlockValidator(
+			ctx,
 			statelessBlockValidator,
 			inboxTracker,
 			txStreamer,
 			func() *staker.BlockValidatorConfig { return &configFetcher.Get().BlockValidator },
 			fatalErrChan,
+			stack,
 		)
 		if err != nil {
 			return nil, err

staker/block_validator.go

@@ -21,6 +21,7 @@ import (
 	"github.com/ethereum/go-ethereum/ethdb"
 	"github.com/ethereum/go-ethereum/log"
 	"github.com/ethereum/go-ethereum/metrics"
+	"github.com/ethereum/go-ethereum/node"
 	"github.com/ethereum/go-ethereum/rlp"
 	"github.com/offchainlabs/nitro/arbnode/resourcemanager"
 	"github.com/offchainlabs/nitro/arbutil"
@@ -102,12 +103,15 @@ type BlockValidator struct {
 	fatalErr chan<- error
 
 	MemoryFreeLimitChecker resourcemanager.LimitChecker
+
+	remoteBlockValidatorClient *rpcclient.RpcClient
 }
 
 type BlockValidatorConfig struct {
 	Enable                      bool                          `koanf:"enable"`
 	RedisValidationClientConfig redis.ValidationClientConfig  `koanf:"redis-validation-client-config"`
 	ValidationServer            rpcclient.ClientConfig        `koanf:"validation-server" reload:"hot"`
+	RemoteBlockValidatorServer  rpcclient.ClientConfig        `koanf:"remote-block-validator-server" reload:"hot"`
 	ValidationServerConfigs     []rpcclient.ClientConfig      `koanf:"validation-server-configs"`
 	ValidationPoll              time.Duration                 `koanf:"validation-poll" reload:"hot"`
 	PrerecordedBlocks           uint64                        `koanf:"prerecorded-blocks" reload:"hot"`
@@ -178,6 +182,7 @@ type BlockValidatorConfigFetcher func() *BlockValidatorConfig
 func BlockValidatorConfigAddOptions(prefix string, f *pflag.FlagSet) {
 	f.Bool(prefix+".enable", DefaultBlockValidatorConfig.Enable, "enable block-by-block validation")
 	rpcclient.RPCClientAddOptions(prefix+".validation-server", f, &DefaultBlockValidatorConfig.ValidationServer)
+	rpcclient.RPCClientAddOptions(prefix+".remote-block-validator-server", f, &DefaultBlockValidatorConfig.RemoteBlockValidatorServer)
 	redis.ValidationClientConfigAddOptions(prefix+".redis-validation-client-config", f)
 	f.String(prefix+".validation-server-configs-list", DefaultBlockValidatorConfig.ValidationServerConfigsList, "array of execution rpc configs given as a json string. time duration should be supplied in number indicating nanoseconds")
 	f.Duration(prefix+".validation-poll", DefaultBlockValidatorConfig.ValidationPoll, "poll time to check validations")
@@ -201,6 +206,7 @@ var DefaultBlockValidatorConfig = BlockValidatorConfig{
 	Enable:                      false,
 	ValidationServerConfigsList: "default",
 	ValidationServer:            rpcclient.DefaultClientConfig,
+	RemoteBlockValidatorServer:  rpcclient.DefaultClientConfig,
 	RedisValidationClientConfig: redis.DefaultValidationClientConfig,
 	ValidationPoll:              time.Second,
 	ForwardBlocks:               128,
@@ -273,20 +279,29 @@ func (s *validationStatus) profileStep() int64 {
 }
 
 func NewBlockValidator(
+	ctx context.Context,
 	statelessBlockValidator *StatelessBlockValidator,
 	inbox InboxTrackerInterface,
 	streamer TransactionStreamerInterface,
 	config BlockValidatorConfigFetcher,
 	fatalErr chan<- error,
+	stack *node.Node,
 ) (*BlockValidator, error) {
+	remoteBlockValidatorServerUrl := config().RemoteBlockValidatorServer.URL
+	var remoteBlockValidatorClient *rpcclient.RpcClient
+	if len(remoteBlockValidatorServerUrl) > 0 && remoteBlockValidatorServerUrl != "self" && remoteBlockValidatorServerUrl != "self-auth" {
+		confFetcher := func() *rpcclient.ClientConfig { return &config().RemoteBlockValidatorServer }
+		remoteBlockValidatorClient = rpcclient.NewRpcClient(confFetcher, stack)
+	}
 	ret := &BlockValidator{
-		StatelessBlockValidator: statelessBlockValidator,
-		createNodesChan:         make(chan struct{}, 1),
-		sendRecordChan:          make(chan struct{}, 1),
-		progressValidationsChan: make(chan struct{}, 1),
-		config:                  config,
-		fatalErr:                fatalErr,
-		prevBatchCache:          make(map[uint64][]byte),
+		StatelessBlockValidator:    statelessBlockValidator,
+		createNodesChan:            make(chan struct{}, 1),
+		sendRecordChan:             make(chan struct{}, 1),
+		progressValidationsChan:    make(chan struct{}, 1),
+		config:                     config,
+		fatalErr:                   fatalErr,
+		prevBatchCache:             make(map[uint64][]byte),
+		remoteBlockValidatorClient: remoteBlockValidatorClient,
 	}
 	valInputsWriter, err := inputs.NewWriter(
 		inputs.WithBaseDir(ret.stack.InstanceDir()),
@@ -296,7 +311,7 @@ func NewBlockValidator(
 	}
 	ret.validationInputsWriter = valInputsWriter
 	if !config().Dangerous.ResetBlockValidation {
-		validated, err := ret.ReadLastValidatedInfo()
+		validated, err := ret.ReadLastValidatedInfo(ctx)
 		if err != nil {
 			return nil, err
 		}
@@ -421,8 +436,15 @@ func ReadLastValidatedInfo(db ethdb.Database) (*GlobalStateValidatedInfo, error)
 	return &validated, nil
 }
 
-func (v *BlockValidator) ReadLastValidatedInfo() (*GlobalStateValidatedInfo, error) {
-	return ReadLastValidatedInfo(v.db)
+func (v *BlockValidator) ReadLastValidatedInfo(ctx context.Context) (*GlobalStateValidatedInfo, error) {
+	if v.remoteBlockValidatorClient == nil {
+		return ReadLastValidatedInfo(v.db)
+	}
+	var res GlobalStateValidatedInfo
+	if err := v.remoteBlockValidatorClient.CallContext(ctx, &res, "arb_latestValidated"); err != nil {
+		return nil, err
+	}
+	return &res, nil
 }
 
 func (v *BlockValidator) legacyReadLastValidatedInfo() (*legacyLastBlockValidatedDbInfo, error) {
@@ -763,7 +785,7 @@ func (v *BlockValidator) iterativeValidationEntryRecorder(ctx context.Context, i
 }
 
 func (v *BlockValidator) iterativeValidationPrint(ctx context.Context) time.Duration {
-	validated, err := v.ReadLastValidatedInfo()
+	validated, err := v.ReadLastValidatedInfo(ctx)
 	if err != nil {
 		log.Error("cannot read last validated data from database", "err", err)
 		return time.Second * 30
@@ -1360,6 +1382,12 @@ func (v *BlockValidator) LaunchWorkthreadsWhenCaughtUp(ctx context.Context) {
 
 func (v *BlockValidator) Start(ctxIn context.Context) error {
 	v.StopWaiter.Start(ctxIn, v)
+	if v.remoteBlockValidatorClient != nil {
+		err := v.remoteBlockValidatorClient.Start(ctxIn)
+		if err != nil {
+			return err
+		}
+	}
 	v.LaunchThread(v.LaunchWorkthreadsWhenCaughtUp)
 	v.CallIteratively(v.iterativeValidationPrint)
 	return nil

staker/l1_validator.go

@@ -290,7 +290,7 @@ func (v *L1Validator) generateNodeAction(
 	var validatedCount arbutil.MessageIndex
 	var validatedGlobalState validator.GoGlobalState
 	if v.blockValidator != nil {
-		valInfo, err := v.blockValidator.ReadLastValidatedInfo()
+		valInfo, err := v.blockValidator.ReadLastValidatedInfo(ctx)
 		if err != nil || valInfo == nil {
 			return nil, false, err
 		}