simplify client

Author: mask-pp

cmd/flags/common.go

@@ -19,25 +19,25 @@ var (
 var (
 	L1WSEndpoint = &cli.StringFlag{
 		Name:     "l1.ws",
-		Usage:    "Websocket RPC endpoint of a L1 ethereum node",
+		Usage:    "Websocket RPC endpoint of a L1Client ethereum node",
 		Required: true,
 		Category: commonCategory,
 	}
 	L2WSEndpoint = &cli.StringFlag{
 		Name:     "l2.ws",
-		Usage:    "Websocket RPC endpoint of a L2 taiko-geth execution engine",
+		Usage:    "Websocket RPC endpoint of a L2Client taiko-geth execution engine",
 		Required: true,
 		Category: commonCategory,
 	}
 	L1HTTPEndpoint = &cli.StringFlag{
 		Name:     "l1.http",
-		Usage:    "HTTP RPC endpoint of a L1 ethereum node",
+		Usage:    "HTTP RPC endpoint of a L1Client ethereum node",
 		Required: true,
 		Category: commonCategory,
 	}
 	L2HTTPEndpoint = &cli.StringFlag{
 		Name:     "l2.http",
-		Usage:    "HTTP RPC endpoint of a L2 taiko-geth execution engine",
+		Usage:    "HTTP RPC endpoint of a L2Client taiko-geth execution engine",
 		Required: true,
 		Category: commonCategory,
 	}

cmd/flags/driver.go

@@ -10,7 +10,7 @@ import (
 var (
 	L2AuthEndpoint = &cli.StringFlag{
 		Name:     "l2.auth",
-		Usage:    "Authenticated HTTP RPC endpoint of a L2 taiko-geth execution engine",
+		Usage:    "Authenticated HTTP RPC endpoint of a L2Client taiko-geth execution engine",
 		Required: true,
 		Category: driverCategory,
 	}
@@ -26,21 +26,21 @@ var (
 var (
 	P2PSyncVerifiedBlocks = &cli.BoolFlag{
 		Name: "p2p.syncVerifiedBlocks",
-		Usage: "Try P2P syncing verified blocks between L2 execution engines, " +
+		Usage: "Try P2P syncing verified blocks between L2Client execution engines, " +
 			"will be helpful to bring a new node online quickly",
 		Value:    false,
 		Category: driverCategory,
 	}
 	P2PSyncTimeout = &cli.DurationFlag{
 		Name: "p2p.syncTimeout",
 		Usage: "P2P syncing timeout, if no sync progress is made within this time span, " +
-			"driver will stop the P2P sync and insert all remaining L2 blocks one by one",
+			"driver will stop the P2P sync and insert all remaining L2Client blocks one by one",
 		Value:    1 * time.Hour,
 		Category: driverCategory,
 	}
 	CheckPointSyncURL = &cli.StringFlag{
 		Name:     "p2p.checkPointSyncUrl",
-		Usage:    "HTTP RPC endpoint of another synced L2 execution engine node",
+		Usage:    "HTTP RPC endpoint of another synced L2Client execution engine node",
 		Category: driverCategory,
 	}
 )

cmd/flags/proposer.go

@@ -10,7 +10,7 @@ import (
 var (
 	L1ProposerPrivKey = &cli.StringFlag{
 		Name:     "l1.proposerPrivKey",
-		Usage:    "Private key of the L1 proposer, who will send TaikoL1.proposeBlock transactions",
+		Usage:    "Private key of the L1Client proposer, who will send TaikoL1.proposeBlock transactions",
 		Required: true,
 		Category: proposerCategory,
 	}
@@ -66,7 +66,7 @@ var (
 	// Proposing epoch related.
 	ProposeInterval = &cli.DurationFlag{
 		Name:     "epoch.interval",
-		Usage:    "Time interval to propose L2 pending transactions",
+		Usage:    "Time interval to propose L2Client pending transactions",
 		Category: proposerCategory,
 	}
 	ProposeEmptyBlocksInterval = &cli.DurationFlag{

cmd/flags/prover.go

@@ -10,7 +10,7 @@ import (
 var (
 	L1ProverPrivKey = &cli.StringFlag{
 		Name:     "l1.proverPrivKey",
-		Usage:    "Private key of L1 prover, who will send TaikoL1.proveBlock transactions",
+		Usage:    "Private key of L1Client prover, who will send TaikoL1.proveBlock transactions",
 		Required: true,
 		Category: proverCategory,
 	}
@@ -153,10 +153,10 @@ var (
 		Value:    1024,
 		Category: proverCategory,
 	}
-	// Max amount of L1 blocks that can pass before block is invalid
+	// Max amount of L1Client blocks that can pass before block is invalid
 	MaxProposedIn = &cli.Uint64Flag{
 		Name:     "prover.maxProposedIn",
-		Usage:    "Maximum amount of L1 blocks that can pass before block can not be proposed. 0 means no limit.",
+		Usage:    "Maximum amount of L1Client blocks that can pass before block can not be proposed. 0 means no limit.",
 		Value:    0,
 		Category: proverCategory,
 	}

cmd/utils/sub_command.go

@@ -25,7 +25,7 @@ func SubcommandAction(app SubcommandApplication) cli.ActionFunc {
 		logger.InitLogger(c)
 
 		ctx, ctxClose := context.WithCancel(context.Background())
-		defer func() { ctxClose() }()
+		defer ctxClose()
 
 		if err := app.InitFromCli(ctx, c); err != nil {
 			return err

driver/anchor_tx_constructor/anchor_tx_constructor.go

@@ -19,7 +19,7 @@ import (
 const anchorGasLimit = 250_000
 
 // AnchorTxConstructor is responsible for assembling the anchor transaction (TaikoL2.anchor) in
-// each L2 block, which is always the first transaction.
+// each L2Client block, which is always the first transaction.
 type AnchorTxConstructor struct {
 	rpc                  *rpc.Client
 	goldenTouchAddress   common.Address
@@ -58,7 +58,7 @@ func (c *AnchorTxConstructor) AssembleAnchorTx(
 	// Parameters of the TaikoL2.anchor transaction.
 	l1Height *big.Int,
 	l1Hash common.Hash,
-	// Height of the L2 block which including the TaikoL2.anchor transaction.
+	// Height of the L2Client block which including the TaikoL2.anchor transaction.
 	l2Height *big.Int,
 	baseFee *big.Int,
 	parentGasUsed uint64,
@@ -68,7 +68,7 @@ func (c *AnchorTxConstructor) AssembleAnchorTx(
 		return nil, err
 	}
 
-	signalRoot, err := c.rpc.GetStorageRoot(ctx, c.rpc.L1GethClient, c.signalServiceAddress, l1Height)
+	signalRoot, err := c.rpc.GetStorageRoot(ctx, c.rpc.L1Client, c.signalServiceAddress, l1Height)
 	if err != nil {
 		return nil, err
 	}
@@ -84,7 +84,7 @@ func (c *AnchorTxConstructor) AssembleAnchorTx(
 	return c.rpc.TaikoL2.Anchor(opts, l1Hash, signalRoot, l1Height.Uint64(), uint32(parentGasUsed))
 }
 
-// transactOpts is a utility method to create some transact options of the anchor transaction in given L2 block with
+// transactOpts is a utility method to create some transact options of the anchor transaction in given L2Client block with
 // golden touch account's private key.
 func (c *AnchorTxConstructor) transactOpts(
 	ctx context.Context,
@@ -154,7 +154,7 @@ func (c *AnchorTxConstructor) GasLimit() uint64 {
 	return anchorGasLimit
 }
 
-// SignalServiceAddress returns protocol's L1 singalService constant address.
+// SignalServiceAddress returns protocol's L1Client singalService constant address.
 func (c *AnchorTxConstructor) SignalServiceAddress() common.Address {
 	return c.signalServiceAddress
 }

driver/anchor_tx_constructor/anchor_tx_constructor_test.go

@@ -28,7 +28,7 @@ func (s *AnchorTxConstructorTestSuite) SetupTest() {
 		common.HexToAddress(os.Getenv("L1_SIGNAL_SERVICE_CONTRACT_ADDRESS")),
 	)
 	s.Nil(err)
-	head, err := s.RPCClient.L1.BlockByNumber(context.Background(), nil)
+	head, err := s.RPCClient.L1Client.BlockByNumber(context.Background(), nil)
 	s.Nil(err)
 	s.l1Height = head.Number()
 	s.l1Hash = head.Hash()

driver/chain_syncer/beaconsync/progress_tracker.go

@@ -17,8 +17,8 @@ var (
 	syncProgressCheckInterval = 12 * time.Second
 )
 
-// SyncProgressTracker is responsible for tracking the L2 execution engine's sync progress, after
-// a beacon sync is triggered in it, and check whether the L2 execution is not able to sync through P2P (due to no
+// SyncProgressTracker is responsible for tracking the L2Client execution engine's sync progress, after
+// a beacon sync is triggered in it, and check whether the L2Client execution is not able to sync through P2P (due to no
 // connected peer or some other reasons).
 type SyncProgressTracker struct {
 	// RPC client
@@ -58,7 +58,7 @@ func (t *SyncProgressTracker) Track(ctx context.Context) {
 }
 
 // track is the internal implementation of MonitorSyncProgress, tries to
-// track the L2 execution engine's beacon sync progress.
+// track the L2Client execution engine's beacon sync progress.
 func (t *SyncProgressTracker) track(ctx context.Context) {
 	t.mutex.Lock()
 	defer t.mutex.Unlock()
@@ -74,13 +74,13 @@ func (t *SyncProgressTracker) track(ctx context.Context) {
 
 	progress, err := t.client.SyncProgress(ctx)
 	if err != nil {
-		log.Error("Get L2 execution engine sync progress error", "error", err)
+		log.Error("Get L2Client execution engine sync progress error", "error", err)
 		return
 	}
 
 	if progress != nil {
 		log.Info(
-			"L2 execution engine sync progress",
+			"L2Client execution engine sync progress",
 			"progress", progress,
 			"lastProgressedTime", t.lastProgressedTime,
 			"timeout", t.timeout,
@@ -90,13 +90,13 @@ func (t *SyncProgressTracker) track(ctx context.Context) {
 	if progress == nil {
 		headHeight, err := t.client.BlockNumber(ctx)
 		if err != nil {
-			log.Error("Get L2 execution engine head height error", "error", err)
+			log.Error("Get L2Client execution engine head height error", "error", err)
 			return
 		}
 
 		if new(big.Int).SetUint64(headHeight).Cmp(t.lastSyncedVerifiedBlockID) >= 0 {
 			t.lastProgressedTime = time.Now()
-			log.Info("L2 execution engine has finished the P2P sync work, all verified blocks synced, "+
+			log.Info("L2Client execution engine has finished the P2P sync work, all verified blocks synced, "+
 				"will switch to insert pending blocks one by one",
 				"lastSyncedVerifiedBlockID", t.lastSyncedVerifiedBlockID,
 				"lastSyncedVerifiedBlockHash", t.lastSyncedVerifiedBlockHash,
@@ -105,14 +105,14 @@ func (t *SyncProgressTracker) track(ctx context.Context) {
 		}
 
 		log.Debug(
-			"L2 execution engine has not started P2P syncing yet",
+			"L2Client execution engine has not started P2P syncing yet",
 			"timeout", t.timeout,
 		)
 	}
 
 	defer func() { t.lastSyncProgress = progress }()
 
-	// Check whether the L2 execution engine has synced any new block through P2P since last event loop.
+	// Check whether the L2Client execution engine has synced any new block through P2P since last event loop.
 	if syncProgressed(t.lastSyncProgress, progress) {
 		t.outOfSync = false
 		t.lastProgressedTime = time.Now()
@@ -121,11 +121,11 @@ func (t *SyncProgressTracker) track(ctx context.Context) {
 
 	// Has not synced any new block since last loop, check whether reaching the timeout.
 	if time.Since(t.lastProgressedTime) > t.timeout {
-		// Mark the L2 execution engine out of sync.
+		// Mark the L2Client execution engine out of sync.
 		t.outOfSync = true
 
 		log.Warn(
-			"L2 execution engine is not able to sync through P2P",
+			"L2Client execution engine is not able to sync through P2P",
 			"lastProgressedTime", t.lastProgressedTime,
 			"timeout", t.timeout,
 		)
@@ -173,7 +173,7 @@ func (t *SyncProgressTracker) HeadChanged(newID *big.Int) bool {
 	return t.lastSyncedVerifiedBlockID != nil && t.lastSyncedVerifiedBlockID != newID
 }
 
-// OutOfSync tells whether the L2 execution engine is marked as out of sync.
+// OutOfSync tells whether the L2Client execution engine is marked as out of sync.
 func (t *SyncProgressTracker) OutOfSync() bool {
 	t.mutex.RLock()
 	defer t.mutex.RUnlock()

driver/chain_syncer/beaconsync/progress_tracker_test.go

@@ -20,7 +20,7 @@ type BeaconSyncProgressTrackerTestSuite struct {
 func (s *BeaconSyncProgressTrackerTestSuite) SetupTest() {
 	s.ClientTestSuite.SetupTest()
 
-	s.t = NewSyncProgressTracker(s.RPCClient.L2, 30*time.Second)
+	s.t = NewSyncProgressTracker(s.RPCClient.L2Client, 30*time.Second)
 }
 
 func (s *BeaconSyncProgressTrackerTestSuite) TestSyncProgressed() {

driver/chain_syncer/beaconsync/syncer.go

@@ -13,7 +13,7 @@ import (
 	"github.com/taikoxyz/taiko-client/pkg/rpc"
 )
 
-// Syncer responsible for letting the L2 execution engine catching up with protocol's latest
+// Syncer responsible for letting the L2Client execution engine catching up with protocol's latest
 // verified block through P2P beacon sync.
 type Syncer struct {
 	ctx             context.Context
@@ -32,7 +32,7 @@ func NewSyncer(
 	return &Syncer{ctx, rpc, state, progressTracker}
 }
 
-// TriggerBeaconSync triggers the L2 execution engine to start performing a beacon sync.
+// TriggerBeaconSync triggers the L2Client execution engine to start performing a beacon sync.
 func (s *Syncer) TriggerBeaconSync() error {
 	blockID, latestVerifiedHeadPayload, err := s.getVerifiedBlockPayload(s.ctx)
 	if err != nil {
@@ -47,14 +47,14 @@ func (s *Syncer) TriggerBeaconSync() error {
 	if s.progressTracker.Triggered() {
 		if s.progressTracker.lastSyncProgress == nil {
 			log.Info(
-				"Syncing beacon headers, please check L2 execution engine logs for progress",
+				"Syncing beacon headers, please check L2Client execution engine logs for progress",
 				"currentSyncHead", s.progressTracker.LastSyncedVerifiedBlockID(),
 				"newBlockID", blockID,
 			)
 		}
 	}
 
-	status, err := s.rpc.L2Engine.NewPayload(
+	status, err := s.rpc.L2AuthClient.NewPayload(
 		s.ctx,
 		latestVerifiedHeadPayload,
 	)
@@ -66,7 +66,7 @@ func (s *Syncer) TriggerBeaconSync() error {
 		return fmt.Errorf("unexpected NewPayload response status: %s", status.Status)
 	}
 
-	fcRes, err := s.rpc.L2Engine.ForkchoiceUpdate(s.ctx, &engine.ForkchoiceStateV1{
+	fcRes, err := s.rpc.L2AuthClient.ForkchoiceUpdate(s.ctx, &engine.ForkchoiceStateV1{
 		HeadBlockHash:      latestVerifiedHeadPayload.BlockHash,
 		SafeBlockHash:      latestVerifiedHeadPayload.BlockHash,
 		FinalizedBlockHash: latestVerifiedHeadPayload.BlockHash,