[op-conductor] improve start sequencer logic (#9145)

* op-conductor: improve start sequencer logic

* update

* update

* updated based on suggestion

op-conductor/conductor/service.go

@@ -4,6 +4,7 @@ import (
 	"context"
 	"fmt"
 	"math/rand"
+	"strings"
 	"sync"
 	"sync/atomic"
 	"time"
@@ -19,6 +20,7 @@ import (
 	"github.com/ethereum-optimism/optimism/op-conductor/health"
 	conductorrpc "github.com/ethereum-optimism/optimism/op-conductor/rpc"
 	opp2p "github.com/ethereum-optimism/optimism/op-node/p2p"
+	"github.com/ethereum-optimism/optimism/op-node/rollup/driver"
 	"github.com/ethereum-optimism/optimism/op-service/cliapp"
 	opclient "github.com/ethereum-optimism/optimism/op-service/client"
 	"github.com/ethereum-optimism/optimism/op-service/dial"
@@ -567,6 +569,7 @@ func (oc *OpConductor) stopSequencer() error {
 
 func (oc *OpConductor) startSequencer() error {
 	oc.log.Info("starting sequencer", "server", oc.cons.ServerID(), "leader", oc.leader.Load(), "healthy", oc.healthy.Load(), "active", oc.seqActive.Load())
+	ctx := context.Background()
 
 	// When starting sequencer, we need to make sure that the current node has the latest unsafe head from the consensus protocol
 	// If not, then we wait for the unsafe head to catch up or gossip it to op-node manually from op-conductor.
@@ -574,7 +577,7 @@ func (oc *OpConductor) startSequencer() error {
 	if unsafeInCons == nil {
 		return errors.New("failed to get latest unsafe block from consensus")
 	}
-	unsafeInNode, err := oc.ctrl.LatestUnsafeBlock(context.Background())
+	unsafeInNode, err := oc.ctrl.LatestUnsafeBlock(ctx)
 	if err != nil {
 		return errors.Wrap(err, "failed to get latest unsafe block from EL during startSequencer phase")
 	}
@@ -590,15 +593,20 @@ func (oc *OpConductor) startSequencer() error {
 
 		if uint64(unsafeInCons.ExecutionPayload.BlockNumber)-unsafeInNode.NumberU64() == 1 {
 			// tries to post the unsafe head to op-node when head is only 1 block behind (most likely due to gossip delay)
-			if err = oc.ctrl.PostUnsafePayload(context.Background(), unsafeInCons); err != nil {
+			if err = oc.ctrl.PostUnsafePayload(ctx, unsafeInCons); err != nil {
 				oc.log.Error("failed to post unsafe head payload envelope to op-node", "err", err)
 			}
 		}
 		return ErrUnsafeHeadMismarch // return error to allow retry
 	}
 
-	if err := oc.ctrl.StartSequencer(context.Background(), unsafeInCons.ExecutionPayload.BlockHash); err != nil {
-		return errors.Wrap(err, "failed to start sequencer")
+	if err = oc.ctrl.StartSequencer(ctx, unsafeInCons.ExecutionPayload.BlockHash); err != nil {
+		// cannot directly compare using Errors.Is because the error is returned from an JSON RPC server which lost its type.
+		if !strings.Contains(err.Error(), driver.ErrSequencerAlreadyStarted.Error()) {
+			return fmt.Errorf("failed to start sequencer: %w", err)
+		} else {
+			oc.log.Warn("sequencer already started.", "err", err)
+		}
 	}
 
 	oc.seqActive.Store(true)

op-node/rollup/driver/state.go

@@ -22,6 +22,8 @@ import (
 	"github.com/ethereum-optimism/optimism/op-service/retry"
 )
 
+var ErrSequencerAlreadyStarted = errors.New("sequencer already running")
+
 // Deprecated: use eth.SyncStatus instead.
 type SyncStatus = eth.SyncStatus
 
@@ -412,7 +414,7 @@ func (s *Driver) eventLoop() {
 		case resp := <-s.startSequencer:
 			unsafeHead := s.engineController.UnsafeL2Head().Hash
 			if !s.driverConfig.SequencerStopped {
-				resp.err <- errors.New("sequencer already running")
+				resp.err <- ErrSequencerAlreadyStarted
 			} else if !bytes.Equal(unsafeHead[:], resp.hash[:]) {
 				resp.err <- fmt.Errorf("block hash does not match: head %s, received %s", unsafeHead.String(), resp.hash.String())
 			} else {