refactor(rollup-relayer): remove outdated logic

common/version/version.go

@@ -5,7 +5,7 @@ import (
 	"runtime/debug"
 )
 
-var tag = "v4.4.72"
+var tag = "v4.4.73"
 
 var commit = func() string {
 	if info, ok := debug.ReadBuildInfo(); ok {

coordinator/internal/logic/provertask/batch_prover_task.go

@@ -243,8 +243,8 @@ func (bp *BatchProverTask) getBatchTaskDetail(dbBatch *orm.Batch, chunkInfos []*
 		ChunkProofs: chunkProofs,
 	}
 
-	if encoding.CodecVersion(dbBatch.CodecVersion) != encoding.CodecV3 && encoding.CodecVersion(dbBatch.CodecVersion) != encoding.CodecV4 {
-		return taskDetail, nil
+	if encoding.CodecVersion(dbBatch.CodecVersion) != encoding.CodecV4 {
+		return nil, fmt.Errorf("unsupported codec version: %v, expected at least %v", dbBatch.CodecVersion, encoding.CodecV4)
 	}
 
 	codec, err := encoding.CodecFromVersion(encoding.CodecVersion(dbBatch.CodecVersion))

rollup/cmd/rollup_relayer/app/app.go

@@ -108,8 +108,6 @@ func action(ctx *cli.Context) error {
 
 	go utils.Loop(subCtx, 2*time.Second, l2relayer.ProcessPendingBatches)
 
-	go utils.Loop(subCtx, 15*time.Second, l2relayer.ProcessCommittedBatches)
-
 	go utils.Loop(subCtx, 15*time.Second, l2relayer.ProcessPendingBundles)
 
 	// Finish start all rollup relayer functions.

rollup/internal/controller/relayer/l2_relayer.go

@@ -419,14 +419,8 @@ func (r *Layer2Relayer) ProcessPendingBatches() {
 		var blob *kzg4844.Blob
 		codecVersion := encoding.CodecVersion(dbBatch.CodecVersion)
 		switch codecVersion {
-		case encoding.CodecV0, encoding.CodecV1, encoding.CodecV2:
-			calldata, blob, err = r.constructCommitBatchPayloadCodecV0AndV1AndV2(dbBatch, dbParentBatch, dbChunks, chunks)
-			if err != nil {
-				log.Error("failed to construct commitBatch payload for V0/V1/V2", "codecVersion", codecVersion, "index", dbBatch.Index, "err", err)
-				return
-			}
-		case encoding.CodecV3, encoding.CodecV4:
-			calldata, blob, err = r.constructCommitBatchPayloadCodecV3AndV4(dbBatch, dbParentBatch, dbChunks, chunks)
+		case encoding.CodecV4:
+			calldata, blob, err = r.constructCommitBatchPayloadCodecV4(dbBatch, dbParentBatch, dbChunks, chunks)
 			if err != nil {
 				log.Error("failed to construct commitBatchWithBlobProof payload for V3/V4", "codecVersion", codecVersion, "index", dbBatch.Index, "err", err)
 				return
@@ -488,69 +482,6 @@ func (r *Layer2Relayer) ProcessPendingBatches() {
 	}
 }
 
-// ProcessCommittedBatches submit proof to layer 1 rollup contract
-func (r *Layer2Relayer) ProcessCommittedBatches() {
-	// retrieves the earliest batch whose rollup status is 'committed'
-	fields := map[string]interface{}{
-		"rollup_status": types.RollupCommitted,
-	}
-	orderByList := []string{"index ASC"}
-	limit := 1
-	batches, err := r.batchOrm.GetBatches(r.ctx, fields, orderByList, limit)
-	if err != nil {
-		log.Error("Failed to fetch committed L2 batches", "err", err)
-		return
-	}
-	if len(batches) != 1 {
-		log.Warn("Unexpected result for GetBlockBatches", "number of batches", len(batches))
-		return
-	}
-
-	r.metrics.rollupL2RelayerProcessCommittedBatchesTotal.Inc()
-
-	batch := batches[0]
-	status := types.ProvingStatus(batch.ProvingStatus)
-	switch status {
-	case types.ProvingTaskUnassigned, types.ProvingTaskAssigned:
-		if batch.CommittedAt == nil {
-			log.Error("batch.CommittedAt is nil", "index", batch.Index, "hash", batch.Hash)
-			return
-		}
-
-		if r.cfg.EnableTestEnvBypassFeatures && utils.NowUTC().Sub(*batch.CommittedAt) > time.Duration(r.cfg.FinalizeBatchWithoutProofTimeoutSec)*time.Second {
-			if err := r.finalizeBatch(batch, false); err != nil {
-				log.Error("Failed to finalize timeout batch without proof", "index", batch.Index, "hash", batch.Hash, "err", err)
-			}
-		}
-
-	case types.ProvingTaskVerified:
-		r.metrics.rollupL2RelayerProcessCommittedBatchesFinalizedTotal.Inc()
-		if err := r.finalizeBatch(batch, true); err != nil {
-			log.Error("Failed to finalize batch with proof", "index", batch.Index, "hash", batch.Hash, "err", err)
-		}
-
-	case types.ProvingTaskFailed:
-		// We were unable to prove this batch. There are two possibilities:
-		// (a) Prover bug. In this case, we should fix and redeploy the prover.
-		//     In the meantime, we continue to commit batches to L1 as well as
-		//     proposing and proving chunks and batches.
-		// (b) Unprovable batch, e.g. proof overflow. In this case we need to
-		//     stop the ledger, fix the limit, revert all the violating blocks,
-		//     chunks and batches and all subsequent ones, and resume, i.e. this
-		//     case requires manual resolution.
-		log.Error(
-			"batch proving failed",
-			"Index", batch.Index,
-			"Hash", batch.Hash,
-			"ProvedAt", batch.ProvedAt,
-			"ProofTimeSec", batch.ProofTimeSec,
-		)
-
-	default:
-		log.Error("encounter unreachable case in ProcessCommittedBatches", "proving status", status)
-	}
-}
-
 // ProcessPendingBundles submits proof to layer 1 rollup contract
 func (r *Layer2Relayer) ProcessPendingBundles() {
 	r.metrics.rollupL2RelayerProcessPendingBundlesTotal.Inc()
@@ -596,126 +527,6 @@ func (r *Layer2Relayer) ProcessPendingBundles() {
 	}
 }
 
-func (r *Layer2Relayer) finalizeBatch(dbBatch *orm.Batch, withProof bool) error {
-	// Check batch status before sending `finalizeBatch` tx.
-	if r.cfg.ChainMonitor.Enabled {
-		var batchStatus bool
-		batchStatus, err := r.getBatchStatusByIndex(dbBatch)
-		if err != nil {
-			r.metrics.rollupL2ChainMonitorLatestFailedCall.Inc()
-			log.Warn("failed to get batch status, please check chain_monitor api server", "batch_index", dbBatch.Index, "err", err)
-			return err
-		}
-		if !batchStatus {
-			r.metrics.rollupL2ChainMonitorLatestFailedBatchStatus.Inc()
-			log.Error("the batch status is false, stop finalize batch and check the reason", "batch_index", dbBatch.Index)
-			return errors.New("the batch status is false")
-		}
-	}
-
-	if dbBatch.Index == 0 {
-		return errors.New("invalid args: batch index is 0, should only happen in finalizing genesis batch")
-	}
-
-	dbParentBatch, getErr := r.batchOrm.GetBatchByIndex(r.ctx, dbBatch.Index-1)
-	if getErr != nil {
-		return fmt.Errorf("failed to get batch, index: %d, err: %w", dbBatch.Index-1, getErr)
-	}
-
-	dbChunks, err := r.chunkOrm.GetChunksInRange(r.ctx, dbBatch.StartChunkIndex, dbBatch.EndChunkIndex)
-	if err != nil {
-		return fmt.Errorf("failed to fetch chunks: %w", err)
-	}
-
-	var aggProof *message.BatchProof
-	if withProof {
-		aggProof, getErr = r.batchOrm.GetVerifiedProofByHash(r.ctx, dbBatch.Hash)
-		if getErr != nil {
-			return fmt.Errorf("failed to get verified proof by hash, index: %d, err: %w", dbBatch.Index, getErr)
-		}
-
-		if err = aggProof.SanityCheck(); err != nil {
-			return fmt.Errorf("failed to check agg_proof sanity, index: %d, err: %w", dbBatch.Index, err)
-		}
-	}
-
-	var calldata []byte
-	codecVersion := encoding.GetCodecVersion(r.chainCfg, dbChunks[0].StartBlockNumber, dbChunks[0].StartBlockTime)
-
-	switch codecVersion {
-	case encoding.CodecV0:
-		log.Info("Start to roll up zk proof", "batch hash", dbBatch.Hash)
-		calldata, err = r.constructFinalizeBatchPayloadCodecV0(dbBatch, dbParentBatch, aggProof)
-		if err != nil {
-			return fmt.Errorf("failed to construct finalizeBatch payload codecv0, index: %v, err: %w", dbBatch.Index, err)
-		}
-
-	case encoding.CodecV1, encoding.CodecV2:
-		log.Info("Start to roll up zk proof", "batch hash", dbBatch.Hash)
-		chunks := make([]*encoding.Chunk, len(dbChunks))
-		for i, c := range dbChunks {
-			blocks, dbErr := r.l2BlockOrm.GetL2BlocksInRange(r.ctx, c.StartBlockNumber, c.EndBlockNumber)
-			if dbErr != nil {
-				return fmt.Errorf("failed to fetch blocks: %w", dbErr)
-			}
-			chunks[i] = &encoding.Chunk{Blocks: blocks}
-		}
-		calldata, err = r.constructFinalizeBatchPayloadCodecV1AndV2(dbBatch, dbParentBatch, dbChunks, chunks, aggProof)
-		if err != nil {
-			return fmt.Errorf("failed to construct finalizeBatch payload codecv1, index: %v, err: %w", dbBatch.Index, err)
-		}
-
-	case encoding.CodecV3, encoding.CodecV4:
-		log.Debug("using finalizeBundle instead", "index", dbBatch.Index, "codec version", codecVersion)
-		return nil
-
-	default:
-		return fmt.Errorf("unsupported codec version: %v", codecVersion)
-	}
-
-	txHash, err := r.finalizeSender.SendTransaction(dbBatch.Hash, &r.cfg.RollupContractAddress, calldata, nil, 0)
-	if err != nil {
-		log.Error(
-			"finalizeBatch in layer1 failed",
-			"with proof", withProof,
-			"index", dbBatch.Index,
-			"hash", dbBatch.Hash,
-			"RollupContractAddress", r.cfg.RollupContractAddress,
-			"err", err,
-			"calldata", common.Bytes2Hex(calldata),
-		)
-		return err
-	}
-
-	log.Info("finalizeBatch in layer1", "with proof", withProof, "index", dbBatch.Index, "batch hash", dbBatch.Hash, "tx hash", txHash.String())
-
-	// Updating rollup status in database.
-	if err := r.batchOrm.UpdateFinalizeTxHashAndRollupStatus(r.ctx, dbBatch.Hash, txHash.String(), types.RollupFinalizing); err != nil {
-		log.Error("UpdateFinalizeTxHashAndRollupStatus failed", "index", dbBatch.Index, "batch hash", dbBatch.Hash, "tx hash", txHash.String(), "err", err)
-		return err
-	}
-
-	// Updating the proving status when finalizing without proof, thus the coordinator could omit this task.
-	// it isn't a necessary step, so don't put in a transaction with UpdateFinalizeTxHashAndRollupStatus
-	if !withProof {
-		txErr := r.db.Transaction(func(dbTX *gorm.DB) error {
-			if updateErr := r.batchOrm.UpdateProvingStatus(r.ctx, dbBatch.Hash, types.ProvingTaskVerified, dbTX); updateErr != nil {
-				return updateErr
-			}
-			if updateErr := r.chunkOrm.UpdateProvingStatusByBatchHash(r.ctx, dbBatch.Hash, types.ProvingTaskVerified, dbTX); updateErr != nil {
-				return updateErr
-			}
-			return nil
-		})
-		if txErr != nil {
-			log.Error("Updating chunk and batch proving status when finalizing without proof failure", "batchHash", dbBatch.Hash, "err", txErr)
-		}
-	}
-
-	r.metrics.rollupL2RelayerProcessCommittedBatchesFinalizedSuccessTotal.Inc()
-	return nil
-}
-
 func (r *Layer2Relayer) finalizeBundle(bundle *orm.Bundle, withProof bool) error {
 	// Check batch status before sending `finalizeBundle` tx.
 	if r.cfg.ChainMonitor.Enabled {
@@ -757,7 +568,7 @@ func (r *Layer2Relayer) finalizeBundle(bundle *orm.Bundle, withProof bool) error
 		}
 	}
 
-	calldata, err := r.constructFinalizeBundlePayloadCodecV3AndV4(dbBatch, aggProof)
+	calldata, err := r.constructFinalizeBundlePayloadCodecV4(dbBatch, aggProof)
 	if err != nil {
 		return fmt.Errorf("failed to construct finalizeBundle payload codecv3, index: %v, err: %w", dbBatch.Index, err)
 	}
@@ -963,45 +774,7 @@ func (r *Layer2Relayer) handleL2RollupRelayerConfirmLoop(ctx context.Context) {
 	}
 }
 
-func (r *Layer2Relayer) constructCommitBatchPayloadCodecV0AndV1AndV2(dbBatch *orm.Batch, dbParentBatch *orm.Batch, dbChunks []*orm.Chunk, chunks []*encoding.Chunk) ([]byte, *kzg4844.Blob, error) {
-	codec, err := encoding.CodecFromVersion(encoding.CodecVersion(dbBatch.CodecVersion))
-	if err != nil {
-		return nil, nil, fmt.Errorf("failed to get codec from version %d, err: %w", dbBatch.CodecVersion, err)
-	}
-
-	batch := &encoding.Batch{
-		Index:                      dbBatch.Index,
-		TotalL1MessagePoppedBefore: dbChunks[0].TotalL1MessagesPoppedBefore,
-		ParentBatchHash:            common.HexToHash(dbParentBatch.Hash),
-		Chunks:                     chunks,
-	}
-
-	daBatch, createErr := codec.NewDABatch(batch)
-	if createErr != nil {
-		return nil, nil, fmt.Errorf("failed to create DA batch: %w", createErr)
-	}
-
-	encodedChunks := make([][]byte, len(dbChunks))
-	for i, c := range dbChunks {
-		daChunk, createErr := codec.NewDAChunk(chunks[i], c.TotalL1MessagesPoppedBefore)
-		if createErr != nil {
-			return nil, nil, fmt.Errorf("failed to create DA chunk: %w", createErr)
-		}
-		daChunkBytes, encodeErr := daChunk.Encode()
-		if encodeErr != nil {
-			return nil, nil, fmt.Errorf("failed to encode DA chunk: %w", encodeErr)
-		}
-		encodedChunks[i] = daChunkBytes
-	}
-
-	calldata, packErr := r.l1RollupABI.Pack("commitBatch", daBatch.Version(), dbParentBatch.BatchHeader, encodedChunks, daBatch.SkippedL1MessageBitmap())
-	if packErr != nil {
-		return nil, nil, fmt.Errorf("failed to pack commitBatch: %w", packErr)
-	}
-	return calldata, daBatch.Blob(), nil
-}
-
-func (r *Layer2Relayer) constructCommitBatchPayloadCodecV3AndV4(dbBatch *orm.Batch, dbParentBatch *orm.Batch, dbChunks []*orm.Chunk, chunks []*encoding.Chunk) ([]byte, *kzg4844.Blob, error) {
+func (r *Layer2Relayer) constructCommitBatchPayloadCodecV4(dbBatch *orm.Batch, dbParentBatch *orm.Batch, dbChunks []*orm.Chunk, chunks []*encoding.Chunk) ([]byte, *kzg4844.Blob, error) {
 	batch := &encoding.Batch{
 		Index:                      dbBatch.Index,
 		TotalL1MessagePoppedBefore: dbChunks[0].TotalL1MessagesPoppedBefore,
@@ -1043,91 +816,7 @@ func (r *Layer2Relayer) constructCommitBatchPayloadCodecV3AndV4(dbBatch *orm.Bat
 	return calldata, daBatch.Blob(), nil
 }
 
-func (r *Layer2Relayer) constructFinalizeBatchPayloadCodecV0(dbBatch *orm.Batch, dbParentBatch *orm.Batch, aggProof *message.BatchProof) ([]byte, error) {
-	if aggProof != nil { // finalizeBatch with proof.
-		calldata, packErr := r.l1RollupABI.Pack(
-			"finalizeBatchWithProof",
-			dbBatch.BatchHeader,
-			common.HexToHash(dbParentBatch.StateRoot),
-			common.HexToHash(dbBatch.StateRoot),
-			common.HexToHash(dbBatch.WithdrawRoot),
-			aggProof.Proof,
-		)
-		if packErr != nil {
-			return nil, fmt.Errorf("failed to pack finalizeBatchWithProof: %w", packErr)
-		}
-		return calldata, nil
-	}
-
-	// finalizeBatch without proof.
-	calldata, packErr := r.l1RollupABI.Pack(
-		"finalizeBatch",
-		dbBatch.BatchHeader,
-		common.HexToHash(dbParentBatch.StateRoot),
-		common.HexToHash(dbBatch.StateRoot),
-		common.HexToHash(dbBatch.WithdrawRoot),
-	)
-	if packErr != nil {
-		return nil, fmt.Errorf("failed to pack finalizeBatch: %w", packErr)
-	}
-	return calldata, nil
-}
-
-func (r *Layer2Relayer) constructFinalizeBatchPayloadCodecV1AndV2(dbBatch *orm.Batch, dbParentBatch *orm.Batch, dbChunks []*orm.Chunk, chunks []*encoding.Chunk, aggProof *message.BatchProof) ([]byte, error) {
-	batch := &encoding.Batch{
-		Index:                      dbBatch.Index,
-		TotalL1MessagePoppedBefore: dbChunks[0].TotalL1MessagesPoppedBefore,
-		ParentBatchHash:            common.HexToHash(dbParentBatch.Hash),
-		Chunks:                     chunks,
-	}
-
-	codec, err := encoding.CodecFromVersion(encoding.CodecVersion(dbBatch.CodecVersion))
-	if err != nil {
-		return nil, fmt.Errorf("failed to get codec from version %d, err: %w", dbBatch.CodecVersion, err)
-	}
-
-	daBatch, createErr := codec.NewDABatch(batch)
-	if createErr != nil {
-		return nil, fmt.Errorf("failed to create DA batch: %w", createErr)
-	}
-
-	blobDataProof, getErr := daBatch.BlobDataProofForPointEvaluation()
-	if getErr != nil {
-		return nil, fmt.Errorf("failed to get blob data proof: %w", getErr)
-	}
-
-	if aggProof != nil { // finalizeBatch4844 with proof.
-		calldata, packErr := r.l1RollupABI.Pack(
-			"finalizeBatchWithProof4844",
-			dbBatch.BatchHeader,
-			common.HexToHash(dbParentBatch.StateRoot),
-			common.HexToHash(dbBatch.StateRoot),
-			common.HexToHash(dbBatch.WithdrawRoot),
-			blobDataProof,
-			aggProof.Proof,
-		)
-		if packErr != nil {
-			return nil, fmt.Errorf("failed to pack finalizeBatchWithProof4844: %w", packErr)
-		}
-		return calldata, nil
-	}
-
-	// finalizeBatch4844 without proof.
-	calldata, packErr := r.l1RollupABI.Pack(
-		"finalizeBatch4844",
-		dbBatch.BatchHeader,
-		common.HexToHash(dbParentBatch.StateRoot),
-		common.HexToHash(dbBatch.StateRoot),
-		common.HexToHash(dbBatch.WithdrawRoot),
-		blobDataProof,
-	)
-	if packErr != nil {
-		return nil, fmt.Errorf("failed to pack finalizeBatch4844: %w", packErr)
-	}
-	return calldata, nil
-}
-
-func (r *Layer2Relayer) constructFinalizeBundlePayloadCodecV3AndV4(dbBatch *orm.Batch, aggProof *message.BundleProof) ([]byte, error) {
+func (r *Layer2Relayer) constructFinalizeBundlePayloadCodecV4(dbBatch *orm.Batch, aggProof *message.BundleProof) ([]byte, error) {
 	if aggProof != nil { // finalizeBundle with proof.
 		calldata, packErr := r.l1RollupABI.Pack(
 			"finalizeBundleWithProof",